@typeslayer/validate 0.0.0 → 0.1.0

package/src/tsc-cpuprofile.ts

@@ -0,0 +1 @@
+export const CPU_PROFILE_FILENAME = "tsc.cpuprofile";

package/src/type-registry.ts

@@ -0,0 +1,17 @@
+import type { ResolvedType } from "./types-json";
+
+/**
+ * Think of a TypeRegistry like an object that you'd use to look up types by their ID.
+ *
+ */
+export type TypeRegistry = ResolvedType[];
+
+const ALL_LIFE_IS_SUFFERING_THAT_BASKS_IN_NOTHINGNESS___ALL_LIFE_IS_TEMPORARY___WHAT_LASTS_IS_CONSCIOUSNESS: [
+  ResolvedType,
+] = [{ id: 0, recursionId: -1, flags: [] }];
+
+export const createTypeRegistry = (typesJson: ResolvedType[]): TypeRegistry => {
+  return ALL_LIFE_IS_SUFFERING_THAT_BASKS_IN_NOTHINGNESS___ALL_LIFE_IS_TEMPORARY___WHAT_LASTS_IS_CONSCIOUSNESS.concat(
+    typesJson,
+  );
+};

package/src/types-json.ts

@@ -0,0 +1,144 @@
+import { z } from "zod/v4";
+import { location, typeId } from "./utils";
+
+export const TYPES_JSON_FILENAME = "types.json";
+
+const flag = z.enum([
+  "Any",
+  "Unknown",
+  "String",
+  "Number",
+  "Boolean",
+  "Enum",
+  "BigInt",
+  "StringLiteral",
+  "NumberLiteral",
+  "BooleanLiteral",
+  "EnumLiteral",
+  "BigIntLiteral",
+  "ESSymbol",
+  "UniqueESSymbol",
+  "Void",
+  "Undefined",
+  "Null",
+  "Never",
+  "TypeParameter",
+  "Object",
+  "Union",
+  "Intersection",
+  "Index",
+  "IndexedAccess",
+  "Conditional",
+  "Substitution",
+  "NonPrimitive",
+  "TemplateLiteral",
+  "StringMapping",
+  "Reserved1",
+  "Reserved2",
+  "AnyOrUnknown",
+  "Nullable",
+  "Literal",
+  "Unit",
+  "Freshable",
+  "StringOrNumberLiteral",
+  "StringOrNumberLiteralOrUnique",
+  "DefinitelyFalsy",
+  "PossiblyFalsy",
+  "Intrinsic",
+  "StringLike",
+  "NumberLike",
+  "BigIntLike",
+  "BooleanLike",
+  "EnumLike",
+  "ESSymbolLike",
+  "VoidLike",
+  "Primitive",
+  "DefinitelyNonNullable",
+  "DisjointDomains",
+  "UnionOrIntersection",
+  "StructuredType",
+  "TypeVariable",
+  "InstantiableNonPrimitive",
+  "InstantiablePrimitive",
+  "Instantiable",
+  "StructuredOrInstantiable",
+  "ObjectFlagsType",
+  "Simplifiable",
+  "Singleton",
+  "Narrowable",
+  "IncludesMask",
+  "IncludesMissingType",
+  "IncludesNonWideningType",
+  "IncludesWildcard",
+  "IncludesEmptyObject",
+  "IncludesInstantiable",
+  "IncludesConstrainedTypeVariable",
+  "IncludesError",
+  "NotPrimitiveUnion",
+]);
+
+export const resolvedType = z
+  .object({
+    id: typeId,
+    flags: z.array(flag),
+
+    recursionId: z.number().optional(),
+    intrinsicName: z
+      .enum([
+        "any",
+        "error",
+        "unresolved",
+        "unknown",
+        "true",
+        "false",
+        "never",
+        "void",
+        "symbol",
+        "bigint",
+        "null",
+        "undefined",
+        "intrinsic",
+        "object",
+        "boolean",
+        "number",
+        "string",
+      ])
+      .optional(),
+
+    firstDeclaration: location.optional(),
+    referenceLocation: location.optional(),
+    destructuringPattern: location.optional(),
+
+    // TODO, awards for all of these
+    typeArguments: z.array(typeId).optional(),
+    unionTypes: z.array(typeId).optional(),
+    intersectionTypes: z.array(typeId).optional(),
+    aliasTypeArguments: z.array(typeId).optional(),
+
+    instantiatedType: typeId.optional(),
+    substitutionBaseType: typeId.optional(),
+    constraintType: typeId.optional(),
+    indexedAccessObjectType: typeId.optional(),
+    indexedAccessIndexType: typeId.optional(),
+    conditionalCheckType: typeId.optional(),
+    conditionalExtendsType: typeId.optional(),
+    conditionalTrueType: typeId.optional(),
+    conditionalFalseType: typeId.optional(),
+    keyofType: typeId.optional(),
+    aliasType: typeId.optional(),
+    evolvingArrayElementType: typeId.optional(),
+    evolvingArrayFinalType: typeId.optional(),
+    reverseMappedSourceType: typeId.optional(),
+    reverseMappedMappedType: typeId.optional(),
+    reverseMappedConstraintType: typeId.optional(),
+
+    isTuple: z.literal(true).optional(),
+
+    symbolName: z.string().optional(),
+    display: z.string().optional(),
+  })
+  .strict();
+
+export type ResolvedType = z.infer<typeof resolvedType>;
+export const typesJsonSchema = z.array(resolvedType);
+export type TypesJsonSchema = z.infer<typeof typesJsonSchema>;

package/src/utils.ts

@@ -0,0 +1,20 @@
+import { z } from "zod/v4";
+
+export const CPU_PROFILE_FILENAME = "tsc.cpuprofile";
+
+export const typeId = z.number().int().positive().or(z.literal(-1));
+
+export type TypeId = z.infer<typeof typeId>;
+
+export const position = z.object({
+  line: typeId,
+  character: z.number(),
+});
+
+export const absolutePath = z.string();
+
+export const location = z.object({
+  path: absolutePath,
+  start: position,
+  end: position,
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": false,
+    "forceConsistentCasingInFileNames": true,
+    "noEmitOnError": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true
+  },
+  "include": ["**/*.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts", "src/node.ts"],
+  format: ["esm"],
+  target: "es2024",
+  dts: true,
+  splitting: true,
+  sourcemap: true,
+  clean: true,
+});