lemmascript 0.0.1 → 0.2.0

package/tools/dist/typedir.js

@@ -0,0 +1,7 @@
+/**
+ * Typed IR — Raw IR annotated with resolved types and classifications.
+ *
+ * Produced by the resolve pass. Consumed by the transform.
+ * Still TS-shaped (not Lean-shaped).
+ */
+export {};

package/tools/dist/types.js

@@ -0,0 +1,71 @@
+/**
+ * Type mapping — TS types → Lean types.
+ *
+ * Single source of truth for type-related decisions.
+ * The transform phase imports this.
+ */
+/** Split generic type arguments respecting nested angle brackets. */
+function splitTypeArgs(s) {
+    const args = [];
+    let depth = 0, start = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '<')
+            depth++;
+        else if (s[i] === '>')
+            depth--;
+        else if (s[i] === ',' && depth === 0) {
+            args.push(s.slice(start, i));
+            start = i + 1;
+        }
+    }
+    args.push(s.slice(start));
+    return args.map(a => a.trim());
+}
+export function parseTsType(tsType) {
+    const t = tsType.trim();
+    // Union: T | undefined → optional<T>
+    if (t.includes(" | ")) {
+        const arms = t.split(" | ").map(a => a.trim());
+        const nonUndef = arms.filter(a => a !== "undefined");
+        if (nonUndef.length === 1 && arms.length === 2) {
+            return { kind: "optional", inner: parseTsType(nonUndef[0]) };
+        }
+    }
+    if (t === "number")
+        return { kind: "int" };
+    if (t === "bigint")
+        return { kind: "int" };
+    if (t === "nat")
+        return { kind: "nat" };
+    if (t === "boolean" || t === "true" || t === "false")
+        return { kind: "bool" };
+    if (t === "string")
+        return { kind: "string" };
+    if (t === "void" || t === "undefined")
+        return { kind: "void" };
+    if (t === "unknown")
+        return { kind: "unknown" };
+    // Record<K, V> → map
+    const recordMatch = t.match(/^Record<(.+)>$/);
+    if (recordMatch) {
+        const args = splitTypeArgs(recordMatch[1]);
+        if (args.length === 2)
+            return { kind: "map", key: parseTsType(args[0]), value: parseTsType(args[1]) };
+    }
+    // Array<T> or T[]
+    const m = t.match(/^(?:Array<(.+)>|(.+)\[\])$/);
+    if (m)
+        return { kind: "array", elem: parseTsType(m[1] || m[2]) };
+    // Map<K, V>
+    const mapMatch = t.match(/^Map<(.+)>$/);
+    if (mapMatch) {
+        const args = splitTypeArgs(mapMatch[1]);
+        if (args.length === 2)
+            return { kind: "map", key: parseTsType(args[0]), value: parseTsType(args[1]) };
+    }
+    // Set<T>
+    const setMatch = t.match(/^Set<(.+)>$/);
+    if (setMatch)
+        return { kind: "set", elem: parseTsType(setMatch[1]) };
+    return { kind: "user", name: t };
+}

package/dist/index.d.ts

@@ -1 +0,0 @@
-export declare const VERSION = "0.0.1";

package/dist/index.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = void 0;
-exports.VERSION = "0.0.1";

package/src/index.ts

@@ -1 +0,0 @@
-export const VERSION = "0.0.1";

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "dist",
-    "rootDir": "src",
-    "declaration": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true
-  },
-  "include": ["src"]
-}