@sdk-it/core 0.22.0 → 0.23.0

package/dist/lib/deriver.test.js

@@ -1,417 +1,382 @@
 import { describe, it } from "node:test";
-import ts from "typescript";
-describe("TypeDeriver Class", () => {
-  describe("Initialization and Core Properties", () => {
-    it.todo("instantiates with a TypeScript TypeChecker instance", () => {
-    });
-    it.todo("initializes the `collector` property as an empty object", () => {
-    });
-    it.todo(
-      "exposes the `deriveSymbol` constant for marking serialized objects",
-      () => {
-      }
-    );
-    it.todo(
-      "exposes the `$types` symbol constant for holding serialized type information",
-      () => {
-      }
-    );
+describe("serializeType: Basic Primitive and Special Types", () => {
+  it.todo("serializes `any` type to an empty type list", () => {
   });
-  describe("serializeType: Basic Primitive and Special Types", () => {
-    it.todo("serializes `any` type to an empty type list", () => {
-    });
-    it.todo("serializes `unknown` type to an empty type list", () => {
-    });
-    it.todo("serializes `string` type", () => {
-    });
-    it.todo("serializes `number` type", () => {
-    });
-    it.todo("serializes `boolean` type", () => {
-    });
-    it.todo("serializes `null` type as optional", () => {
-    });
-    it.todo(
-      "serializes `void` type (likely falls back to Any/Unknown or unhandled)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes `never` type (likely falls back to Any/Unknown or unhandled)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes `undefined` type implicitly via union/intersection optional flag",
-      () => {
-      }
-    );
+  it.todo("serializes `unknown` type to an empty type list", () => {
   });
-  describe("serializeType: Literal Types", () => {
-    it.todo("serializes string literal types with their value", () => {
-    });
-    it.todo("serializes numeric literal types with their value", () => {
-    });
-    it.todo("serializes boolean literal `true` type", () => {
-    });
-    it.todo("serializes boolean literal `false` type", () => {
-    });
-    it.todo("serializes template literal types as base `string`", () => {
-    });
+  it.todo("serializes `string` type", () => {
   });
-  describe("serializeType: Enum Types", () => {
-    it.todo(
-      "serializes an Enum type (e.g., `enum Color {}`) potentially via unhandled path",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an EnumLiteral type (e.g., `Color.Red`) potentially via unhandled path or base type",
-      () => {
-      }
-    );
+  it.todo("serializes `number` type", () => {
   });
-  describe("serializeType: Union Types (`|`)", () => {
-    it.todo(
-      "serializes a union of primitive types (e.g., string | number)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a union type including `null` (e.g., string | null)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a union type including `undefined`, setting optional flag and filtering `undefined`",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a union type including both `null` and `undefined`",
-      () => {
-      }
-    );
-    it.todo('serializes a union of literal types (e.g., "a" | "b" | 1)', () => {
-    });
-    it.todo(
-      "serializes a union including complex types (e.g., string | MyInterface)",
-      () => {
-      }
-    );
-    it.todo("serializes a union containing only `undefined`", () => {
-    });
-    it.todo("serializes a union containing only `null`", () => {
-    });
+  it.todo("serializes `boolean` type", () => {
   });
-  describe("serializeType: Intersection Types (`&`)", () => {
-    it.todo(
-      "serializes an intersection of object/interface types (e.g., A & B)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an intersection type including `undefined`, setting optional flag and filtering `undefined`",
-      () => {
-      }
-    );
-    it.todo("serializes an intersection containing only `undefined`", () => {
-    });
+  it.todo("serializes `null` type as optional", () => {
   });
-  describe("serializeType: Array and Tuple Types", () => {
-    it.todo("serializes a simple array type (e.g., string[])", () => {
-    });
-    it.todo("serializes readonly array types (e.g., readonly number[])", () => {
-    });
-    it.todo(
-      "serializes an array type with object elements (e.g., MyInterface[])",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an array type with union elements (e.g., (string | number)[])",
-      () => {
-      }
-    );
-    it.todo("serializes an array type where element type has no symbol", () => {
-    });
-    it.todo(
-      "serializes an array type where element symbol has no value declaration but has declarations",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an array type with a mapped type element (e.g., MappedType[])",
-      () => {
-      }
-    );
-    it.todo(
-      "handles array-like types with missing type arguments gracefully (e.g., Array)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes tuple types (e.g., [string, number]) potentially as array of union",
-      () => {
-      }
-    );
+  it.todo(
+    "serializes `void` type (likely falls back to Any/Unknown or unhandled)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes `never` type (likely falls back to Any/Unknown or unhandled)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes `undefined` type implicitly via union/intersection optional flag",
+    () => {
+    }
+  );
+});
+describe("serializeType: Literal Types", () => {
+  it.todo("serializes string literal types with their value", () => {
+  });
+  it.todo("serializes numeric literal types with their value", () => {
+  });
+  it.todo("serializes boolean literal `true` type", () => {
+  });
+  it.todo("serializes boolean literal `false` type", () => {
+  });
+  it.todo("serializes template literal types as base `string`", () => {
+  });
+});
+describe("serializeType: Enum Types", () => {
+  it.todo(
+    "serializes an Enum type (e.g., `enum Color {}`) potentially via unhandled path",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an EnumLiteral type (e.g., `Color.Red`) potentially via unhandled path or base type",
+    () => {
+    }
+  );
+});
+describe("serializeType: Union Types (`|`)", () => {
+  it.todo(
+    "serializes a union of primitive types (e.g., string | number)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a union type including `null` (e.g., string | null)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a union type including `undefined`, setting optional flag and filtering `undefined`",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a union type including both `null` and `undefined`",
+    () => {
+    }
+  );
+  it.todo('serializes a union of literal types (e.g., "a" | "b" | 1)', () => {
+  });
+  it.todo(
+    "serializes a union including complex types (e.g., string | MyInterface)",
+    () => {
+    }
+  );
+  it.todo("serializes a union containing only `undefined`", () => {
   });
-  describe("serializeType: Record/Index Types", () => {
-    it.todo(
-      "serializes a string index signature type (Record<string, number>)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a string index signature type with complex value (Record<string, MyInterface>)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a type with only a number index signature ([key: number]: boolean)",
-      () => {
-      }
-    );
+  it.todo("serializes a union containing only `null`", () => {
   });
-  describe("serializeType: Object Types (Interfaces, Classes, Inline, Mapped)", () => {
-    it.todo("serializes an inline object type literal (passed as type)", () => {
-    });
-    it.todo(
-      "serializes a mapped type directly (e.g., type M = { [K in keyof T]: T[K] })",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an object type using literal property assignments from declarations",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an object type with mixed declared types (PropertySignature) and literal assignments (PropertyAssignment)",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an empty object type `{}` potentially falling back to name or generic",
-      () => {
-      }
-    );
-    it.todo(
-      "handles object types matching default overrides (e.g., DateConstructor -> string)",
-      () => {
-      }
-    );
-    it.todo(
-      "handles known object types NOT in defaults (e.g., RegExp) by attempting standard object serialization",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an interface type by deferring to serializeNode for reference/collection",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a class type by deferring to serializeNode for reference/collection",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an interface type using its name when its declaration cannot be found",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a class type using its name when its declaration cannot be found",
-      () => {
-      }
-    );
+});
+describe("serializeType: Intersection Types (`&`)", () => {
+  it.todo(
+    "serializes an intersection of object/interface types (e.g., A & B)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an intersection type including `undefined`, setting optional flag and filtering `undefined`",
+    () => {
+    }
+  );
+  it.todo("serializes an intersection containing only `undefined`", () => {
+  });
+});
+describe("serializeType: Array and Tuple Types", () => {
+  it.todo("serializes a simple array type (e.g., string[])", () => {
   });
-  describe("serializeType: Unhandled Types", () => {
-    it.todo(
-      "handles an unhandled type flag by using checker.typeToString and warns",
-      () => {
-      }
-    );
+  it.todo("serializes readonly array types (e.g., readonly number[])", () => {
   });
-  describe("serializeNode: Object Literal Expressions (`{ ... }`)", () => {
-    it.todo(
-      "serializes an object literal node with various primitive property types",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an object literal node with nested object/array literals",
-      () => {
-      }
-    );
-    it.todo("serializes an empty object literal node `{}`", () => {
-    });
+  it.todo(
+    "serializes an array type with object elements (e.g., MyInterface[])",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an array type with union elements (e.g., (string | number)[])",
+    () => {
+    }
+  );
+  it.todo("serializes an array type where element type has no symbol", () => {
   });
-  describe("serializeNode: Property Access/Signature/Declaration", () => {
-    it.todo(
-      "serializes a PropertyAccessExpression node (e.g., `obj.prop`) by resolving its type",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a PropertySignature node (e.g., `prop: string;`) by resolving its type",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a PropertyDeclaration node (e.g., `prop: number;`) by resolving its type",
-      () => {
-      }
-    );
-    it.todo(
-      "handles property nodes where symbol cannot be found for the property name and warns",
-      () => {
-      }
-    );
+  it.todo(
+    "serializes an array type where element symbol has no value declaration but has declarations",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an array type with a mapped type element (e.g., MappedType[])",
+    () => {
+    }
+  );
+  it.todo(
+    "handles array-like types with missing type arguments gracefully (e.g., Array)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes tuple types (e.g., [string, number]) potentially as array of union",
+    () => {
+    }
+  );
+});
+describe("serializeType: Record/Index Types", () => {
+  it.todo(
+    "serializes a string index signature type (Record<string, number>)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a string index signature type with complex value (Record<string, MyInterface>)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a type with only a number index signature ([key: number]: boolean)",
+    () => {
+    }
+  );
+});
+describe("serializeType: Object Types (Interfaces, Classes, Inline, Mapped)", () => {
+  it.todo("serializes an inline object type literal (passed as type)", () => {
+  });
+  it.todo(
+    "serializes a mapped type directly (e.g., type M = { [K in keyof T]: T[K] })",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an object type using literal property assignments from declarations",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an object type with mixed declared types (PropertySignature) and literal assignments (PropertyAssignment)",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an empty object type `{}` potentially falling back to name or generic",
+    () => {
+    }
+  );
+  it.todo(
+    "handles object types matching default overrides (e.g., DateConstructor -> string)",
+    () => {
+    }
+  );
+  it.todo(
+    "handles known object types NOT in defaults (e.g., RegExp) by attempting standard object serialization",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an interface type by deferring to serializeNode for reference/collection",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a class type by deferring to serializeNode for reference/collection",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an interface type using its name when its declaration cannot be found",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a class type using its name when its declaration cannot be found",
+    () => {
+    }
+  );
+});
+describe("serializeType: Unhandled Types", () => {
+  it.todo(
+    "handles an unhandled type flag by using checker.typeToString and warns",
+    () => {
+    }
+  );
+});
+describe("serializeNode: Object Literal Expressions (`{ ... }`)", () => {
+  it.todo(
+    "serializes an object literal node with various primitive property types",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an object literal node with nested object/array literals",
+    () => {
+    }
+  );
+  it.todo("serializes an empty object literal node `{}`", () => {
+  });
+});
+describe("serializeNode: Property Access/Signature/Declaration", () => {
+  it.todo(
+    "serializes a PropertyAccessExpression node (e.g., `obj.prop`) by resolving its type",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a PropertySignature node (e.g., `prop: string;`) by resolving its type",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a PropertyDeclaration node (e.g., `prop: number;`) by resolving its type",
+    () => {
+    }
+  );
+  it.todo(
+    "handles property nodes where symbol cannot be found for the property name and warns",
+    () => {
+    }
+  );
+});
+describe("serializeNode: Interface Declarations (`interface ...`) and Collector Interaction", () => {
+  it.todo(
+    "serializes a new interface declaration, adding its structure to the collector",
+    () => {
+    }
+  );
+  it.todo(
+    "returns only a reference for an already serialized interface declaration (present in collector)",
+    () => {
+    }
+  );
+  it.todo(
+    "handles interface declarations matching default overrides without adding to collector",
+    () => {
+    }
+  );
+  it.todo("throws an error for an interface declaration without a name", () => {
+  });
+  it.todo(
+    "handles interfaces with no members correctly (adds empty object to collector)",
+    () => {
+    }
+  );
+  it.todo(
+    "handles interfaces extending other interfaces (serialization includes only own properties)",
+    () => {
+    }
+  );
+});
+describe("serializeNode: Class Declarations (`class ...`) and Collector Interaction", () => {
+  it.todo(
+    "serializes a new class declaration, adding its property structure to the collector",
+    () => {
+    }
+  );
+  it.todo(
+    "returns only a reference for an already serialized class declaration (present in collector)",
+    () => {
+    }
+  );
+  it.todo(
+    "handles class declarations matching default overrides without adding to collector",
+    () => {
+    }
+  );
+  it.todo(
+    "throws an error for a class declaration without a name (e.g., anonymous default export)",
+    () => {
+    }
+  );
+  it.todo(
+    "handles classes with no property declarations (only methods/constructor) correctly (adds empty object to collector)",
+    () => {
+    }
+  );
+  it.todo(
+    "handles classes implementing interfaces (serialization includes only own properties)",
+    () => {
+    }
+  );
+  it.todo(
+    "handles classes extending other classes (serialization includes only own properties)",
+    () => {
+    }
+  );
+});
+describe("serializeNode: Other Node Types", () => {
+  it.todo(
+    "serializes a VariableDeclaration node with an explicit type annotation",
+    () => {
+    }
+  );
+  it.todo(
+    "handles VariableDeclaration node without a type annotation and warns",
+    () => {
+    }
+  );
+  it.todo(
+    "handles VariableDeclaration node where symbol cannot be found for the variable name and warns",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an Identifier node by resolving its type at that location",
+    () => {
+    }
+  );
+  it.todo(
+    "handles Identifier node where symbol cannot be found and warns",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an AwaitExpression node by resolving the awaited type",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a CallExpression node by resolving its return type",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes an AsExpression node by resolving the asserted type",
+    () => {
+    }
+  );
+  it.todo(
+    "serializes a TypeLiteralNode (`{ ... }` used as a type) by resolving its properties",
+    () => {
+    }
+  );
+  it.todo("serializes NullKeyword node", () => {
   });
-  describe("serializeNode: Interface Declarations (`interface ...`) and Collector Interaction", () => {
-    it.todo(
-      "serializes a new interface declaration, adding its structure to the collector",
-      () => {
-      }
-    );
-    it.todo(
-      "returns only a reference for an already serialized interface declaration (present in collector)",
-      () => {
-      }
-    );
-    it.todo(
-      "handles interface declarations matching default overrides without adding to collector",
-      () => {
-      }
-    );
-    it.todo(
-      "throws an error for an interface declaration without a name",
-      () => {
-      }
-    );
-    it.todo(
-      "handles interfaces with no members correctly (adds empty object to collector)",
-      () => {
-      }
-    );
-    it.todo(
-      "handles interfaces extending other interfaces (serialization includes only own properties)",
-      () => {
-      }
-    );
+  it.todo("serializes BooleanKeyword node", () => {
   });
-  describe("serializeNode: Class Declarations (`class ...`) and Collector Interaction", () => {
-    it.todo(
-      "serializes a new class declaration, adding its property structure to the collector",
-      () => {
-      }
-    );
-    it.todo(
-      "returns only a reference for an already serialized class declaration (present in collector)",
-      () => {
-      }
-    );
-    it.todo(
-      "handles class declarations matching default overrides without adding to collector",
-      () => {
-      }
-    );
-    it.todo(
-      "throws an error for a class declaration without a name (e.g., anonymous default export)",
-      () => {
-      }
-    );
-    it.todo(
-      "handles classes with no property declarations (only methods/constructor) correctly (adds empty object to collector)",
-      () => {
-      }
-    );
-    it.todo(
-      "handles classes implementing interfaces (serialization includes only own properties)",
-      () => {
-      }
-    );
-    it.todo(
-      "handles classes extending other classes (serialization includes only own properties)",
-      () => {
-      }
-    );
+  it.todo("serializes TrueKeyword node as boolean literal", () => {
   });
-  describe("serializeNode: Other Node Types", () => {
-    it.todo(
-      "serializes a VariableDeclaration node with an explicit type annotation",
-      () => {
-      }
-    );
-    it.todo(
-      "handles VariableDeclaration node without a type annotation and warns",
-      () => {
-      }
-    );
-    it.todo(
-      "handles VariableDeclaration node where symbol cannot be found for the variable name and warns",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an Identifier node by resolving its type at that location",
-      () => {
-      }
-    );
-    it.todo(
-      "handles Identifier node where symbol cannot be found and warns",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an AwaitExpression node by resolving the awaited type",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a CallExpression node by resolving its return type",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes an AsExpression node by resolving the asserted type",
-      () => {
-      }
-    );
-    it.todo(
-      "serializes a TypeLiteralNode (`{ ... }` used as a type) by resolving its properties",
-      () => {
-      }
-    );
-    it.todo("serializes NullKeyword node", () => {
-    });
-    it.todo("serializes BooleanKeyword node", () => {
-    });
-    it.todo("serializes TrueKeyword node as boolean literal", () => {
-    });
-    it.todo("serializes FalseKeyword node as boolean literal", () => {
-    });
-    it.todo(
-      "serializes an ArrayLiteralExpression node by resolving its inferred type",
-      () => {
-      }
-    );
-    it.todo(
-      "handles an unhandled node kind by returning `any` and warns",
-      () => {
-      }
-    );
+  it.todo("serializes FalseKeyword node as boolean literal", () => {
   });
-  describe("Helper Function: isInterfaceType", () => {
-    it.todo("returns true for a type whose symbol is an Interface", () => {
-    });
-    it.todo("returns false for a type whose symbol is a Class", () => {
-    });
-    it.todo("returns false for a type that is not a class or interface", () => {
-    });
-    it.todo("returns false if the type has no symbol", () => {
-    });
+  it.todo(
+    "serializes an ArrayLiteralExpression node by resolving its inferred type",
+    () => {
+    }
+  );
+  it.todo("handles an unhandled node kind by returning `any` and warns", () => {
   });
 });
 //# sourceMappingURL=deriver.test.js.map