fix: inline purely structural generics

src/ExposeNodeParser.ts

@@ -6,6 +6,10 @@
 import type { ReferenceType } from "./Type/ReferenceType.js";
 import { hasJsDocTag } from "./Utils/hasJsDocTag.js";
 import { symbolAtNode } from "./Utils/symbolAtNode.js";
+import { AliasType } from "./Type/AliasType.js";
+import { derefAliasedType, isDeepLiteralUnion } from "./Utils/derefType.js";
+import { ObjectType } from "./Type/ObjectType.js";
+import { IntersectionType } from "./Type/IntersectionType.js";
 
 export class ExposeNodeParser implements SubNodeParser {
     public constructor(
@@ -22,7 +26,7 @@
     public createType(node: ts.Node, context: Context, reference?: ReferenceType): BaseType {
         const baseType = this.subNodeParser.createType(node, context, reference);
 
-        if (!this.isExportNode(node)) {
+        if (!this.isExportNode(node) || this.isFromLib(node) || this.shouldInline(node, baseType, context)) {
             return baseType;
         }
 
@@ -38,7 +42,7 @@
             return false;
         }
 
         const localSymbol: ts.Symbol = (node as any).localSymbol;
         return localSymbol ? "exportSymbol" in localSymbol : false;
     }
 
@@ -49,4 +53,49 @@
 
         return argumentIds.length ? `${fullName}<${argumentIds.join(",")}>` : fullName;
     }
+
+    private isFromLib(node: ts.Node): boolean {
+        const sourceFile = node.getSourceFile();
+        if (!sourceFile) {
+            return false;
+        }
+        return /[\\/]typescript[\\/]lib[\\/]/i.test(sourceFile.fileName);
+    }
+
+    private shouldInline(node: ts.Node, type: BaseType, context: Context): boolean {
+        if (!ts.isTypeAliasDeclaration(node)) {
+            return false;
+        }
+        if (!(type instanceof AliasType)) {
+            return false;
+        }
+        if (!node.typeParameters?.length) {
+            return false;
+        }
+
+        const localSymbol: ts.Symbol = (node as any).localSymbol;
+        const isExported = localSymbol ? "exportSymbol" in localSymbol : false;
+
+        const actual = derefAliasedType(type.getType());
+        const hasStructuralArg = context
+            .getArguments()
+            .some((arg) => /(structure|object|alias|def-alias)-/.test(arg?.getName() ?? ""));
+
+        if (isExported && !hasStructuralArg) {
+            return false;
+        }
+
+        if (isDeepLiteralUnion(actual)) {
+            return true;
+        }
+
+        if (!isExported && (actual instanceof ObjectType || actual instanceof IntersectionType)) {
+            return true;
+        }
+
+        if (hasStructuralArg) {
+            return true;
+        }
+        return false;
+    }
 }

test/valid-data-other.test.ts

@@ -57,6 +57,8 @@ describe("valid-data-other", () => {
     it("generic-nested", assertValidSchema("generic-nested", "MyObject"));
     it("generic-prefixed-number", assertValidSchema("generic-prefixed-number", "MyObject"));
     it("generic-void", assertValidSchema("generic-void", "MyObject"));
+    it("generic-mapped-complex", assertValidSchema("generic-mapped-complex", "*"));
+    it("generic-valueof", assertValidSchema("generic-valueof", "*"));
 
     it("nullable-null", assertValidSchema("nullable-null", "MyObject"));
 

test/valid-data/generic-mapped-complex/main.ts

@@ -0,0 +1,13 @@
+import { OverrideProperties } from "./util";
+
+export type Base = {
+    foo: string;
+    bar: number;
+};
+
+export type MyType = OverrideProperties<
+    Base,
+    {
+        bar: string;
+    }
+>;

test/valid-data/generic-mapped-complex/schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "Base": {
+      "additionalProperties": false,
+      "properties": {
+        "bar": {
+          "type": "number"
+        },
+        "foo": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "foo",
+        "bar"
+      ],
+      "type": "object"
+    },
+    "MyType": {
+      "additionalProperties": false,
+      "properties": {
+        "bar": {
+          "type": "string"
+        },
+        "foo": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "bar",
+        "foo"
+      ],
+      "type": "object"
+    }
+  }
+}

test/valid-data/generic-mapped-complex/util.ts

@@ -0,0 +1,27 @@
+// types are from https://github.com/sindresorhus/type-fest
+
+export type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+export type PickIndexSignature<ObjectType> = {
+    [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
+};
+
+export type OmitIndexSignature<ObjectType> = {
+    [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
+};
+
+type SimpleMerge<Destination, Source> = {
+    [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+
+export type Merge<Destination, Source> = Simplify<
+    SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> &
+        SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
+>;
+
+export type OverrideProperties<
+    TOriginal,
+    TOverride extends Partial<Record<keyof TOriginal, unknown>> & {
+        [Key in keyof TOverride]: Key extends keyof TOriginal ? TOverride[Key] : never;
+    },
+> = Merge<TOriginal, TOverride>;

test/valid-data/generic-valueof/main.ts

@@ -0,0 +1,8 @@
+export const RuntimeObject = {
+    FOO: "foo-val",
+    BAR: "bar-val",
+} as const;
+
+export type ValueOf<T> = T[keyof T];
+
+export type MyType = ValueOf<typeof RuntimeObject>;

test/valid-data/generic-valueof/schema.json

@@ -0,0 +1,13 @@
+{
+  "$ref": "#/definitions/MyType",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "MyType": {
+      "enum": [
+        "foo-val",
+        "bar-val"
+      ],
+      "type": "string"
+    }
+  }
+}