@cr_docs_t/dts 0.26.0 → 0.28.0

package/dist/treesitter/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./AST.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/treesitter/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/treesitter/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/treesitter/types/index.js

@@ -0,0 +1 @@
+export * from "./AST.js";

package/dist/treesitter.d.ts

@@ -0,0 +1,2 @@
+export * from "./treesitter/index.js";
+//# sourceMappingURL=treesitter.d.ts.map

package/dist/treesitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treesitter.d.ts","sourceRoot":"","sources":["../src/treesitter.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/treesitter.js

@@ -0,0 +1 @@
+export * from "./treesitter/index.js";

package/dist/type-gen.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gen.d.ts.map

package/dist/type-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gen.d.ts","sourceRoot":"","sources":["../src/type-gen.ts"],"names":[],"mappings":""}

package/dist/type-gen.js

@@ -0,0 +1,184 @@
+// Inspired by https://github.com/github/semantic/tree/main/semantic-ast
+import { writeFileSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const dir = dirname(__filename);
+const INPUT_PATH = join(dir, "node-types.json"); // Adjust as needed
+const OUTPUT_PATH = join(dir, "treesitter", "types", "AST.ts");
+const toPascalCase = (str) => {
+    return (str
+        .match(/[a-z_]+/gi)
+        ?.map((word) => word
+        .split("_")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(""))
+        .join("") || str);
+};
+function generate() {
+    const rawData = readFileSync(INPUT_PATH, "utf8");
+    const nodes = JSON.parse(rawData);
+    let output = `// Auto-generated from node-types.json\n\n`;
+    output += `import  { Node } from 'web-tree-sitter';
+import { v4 } from 'uuid'
+
+export type NodeId = string;
+
+export interface ParserContext {
+    nodes: Map<NodeId, AstNode>;
+}
+
+`;
+    let interfacesOut = `// Interfaces
+
+`;
+    let unmarshalersOut = `// Unmarshalers
+
+`;
+    let switches = "";
+    const allNamedNodes = [];
+    for (const node of nodes) {
+        if (!node.named)
+            continue;
+        // Generate interfaces
+        const interfaceName = toPascalCase(node.type) + "Node";
+        // Handle Supertypes
+        if (node.subtypes && node.subtypes.length > 0) {
+            const subtypeNames = node.subtypes.filter((st) => st.named).map((st) => toPascalCase(st.type) + "Node");
+            if (subtypeNames.length > 0) {
+                interfacesOut += `export type ${interfaceName} = ${subtypeNames.join(" | ")};\n\n`;
+            }
+            continue;
+        }
+        allNamedNodes.push(interfaceName);
+        // Handle Standard Concrete Nodes
+        interfacesOut += `export interface ${interfaceName} {\n`;
+        // Use a Map to track properties so we can merge collisions
+        const props = new Map();
+        // Set default properties
+        props.set("id", { type: "NodeId", optional: false });
+        props.set("parentId", { type: "NodeId | null", optional: false });
+        props.set("type", { type: `'${node.type}'`, optional: false });
+        props.set("text", { type: "string", optional: false });
+        // Map Fields
+        if (node.fields) {
+            for (const [fieldName, fieldData] of Object.entries(node.fields)) {
+                let typeString = fieldData.multiple ? "NodeId[]" : "NodeId";
+                const isOptional = !fieldData.required;
+                if (props.has(fieldName)) {
+                    // Merge types on collision
+                    const existing = props.get(fieldName);
+                    existing.type = `${existing.type} | ${typeString}`;
+                    existing.optional = existing.optional && isOptional;
+                }
+                else {
+                    props.set(fieldName, { type: typeString, optional: isOptional });
+                }
+            }
+        }
+        props.set("childrenIds", { type: "NodeId[]", optional: false });
+        // Write all properties to the interface
+        for (const [propName, propData] of props.entries()) {
+            const optMod = propData.optional ? "?" : "";
+            interfacesOut += `  ${propName}${optMod}: ${propData.type};\n`;
+        }
+        interfacesOut += `}\n\n`;
+        // Generate Unmarshalers
+        const funcName = `unmarshaler${interfaceName}`;
+        switches += `case '${node.type}': return ${funcName}(node, ctx, parentId);\n`;
+        unmarshalersOut += `function ${funcName}(node: Node, ctx: ParserContext, parentId: NodeId | null): NodeId {
+            const id = v4();
+            const n: Partial<${interfaceName}> = {
+                id,
+                parentId,
+                type: '${node.type}',
+                text: node.text,
+            };
+            ctx.nodes.set(id, n as AstNode);
+
+`;
+        let fieldExtractionNodes = "";
+        if (node.fields) {
+            for (const [fieldName, fieldData] of Object.entries(node.fields)) {
+                if (fieldData.multiple) {
+                    unmarshalersOut += `n.${fieldName} = node.childrenForFieldName('${fieldName}').map(n => unmarshalNode(n, ctx, id));\n`;
+                    fieldExtractionNodes += `...node.childrenForFieldName('${fieldName}').map(n => n.id), `;
+                }
+                else {
+                    if (fieldData.required) {
+                        unmarshalersOut += `n.${fieldName} = unmarshalNode(node.childForFieldName('${fieldName}')!, ctx, id);\n`;
+                        fieldExtractionNodes += `node.childForFieldName('${fieldName}')!.id, `;
+                    }
+                    else {
+                        unmarshalersOut += `const ${fieldName}Node = node.childForFieldName('${fieldName}');
+n.${fieldName} = ${fieldName}Node ? unmarshalNode(${fieldName}Node, ctx, id) : undefined;
+`;
+                        fieldExtractionNodes += `${fieldName}Node ? ${fieldName}Node.id : undefined, `;
+                    }
+                }
+            }
+        }
+        if (fieldExtractionNodes.length > 0) {
+            unmarshalersOut += `
+const fieldNodes = new Set([${fieldExtractionNodes}].filter(id => id !== undefined));
+n.childrenIds = node.namedChildren.filter(n => !fieldNodes.has(n.id)).map(n => unmarshalNode(n, ctx, id));
+`;
+        }
+        else {
+            unmarshalersOut += `n.childrenIds = node.namedChildren.map(n => unmarshalNode(n, ctx, id));\n`;
+        }
+        unmarshalersOut += `return id;
+}
+
+`;
+    }
+    const core = `// Parser core
+
+export const unmarshalNode = (node: Node, ctx: ParserContext, parentId: NodeId | null): NodeId => {
+    switch(node.type) {
+        ${switches}
+        default: {
+            const id = v4();
+            const n = {
+                id,
+                parentId,
+                type: node.type as any,
+                text: node.text,
+                childrenIds: [] as NodeId[],
+            };
+            ctx.nodes.set(id, n as AstNode);
+            n.childrenIds = node.namedChildren.map(n => unmarshalNode(n, ctx, id));
+            return id;
+        }
+    }
+}
+
+ export type BragiAST = {rootId: NodeId, nodes: Map<NodeId, AstNode> };
+
+ // Parses a treesitter CST into a Bragi AST node map
+ export const parseCST = (root: Node | null) : BragiAST => {
+     if (!root) throw new Error ("No root node provided");
+     const ctx: ParserContext = { nodes: new Map() };
+     const rootId = unmarshalNode(root, ctx, null);
+     return {rootId, nodes: ctx.nodes};
+ }
+    `;
+    // Create a generic ASTNode type
+    const concreteNodes = nodes
+        .filter((n) => n.named && (!n.subtypes || n.subtypes.length === 0))
+        .map((n) => toPascalCase(n.type) + "Node");
+    const genericType = `export type AstNode = ${concreteNodes.join(" | ")};\n`;
+    // Consolidate output
+    output += `
+    ${interfacesOut}
+
+    ${genericType}
+
+    ${unmarshalersOut}
+
+    ${core}
+    `;
+    writeFileSync(OUTPUT_PATH, output);
+    console.log(`Successfully generated AST types at ${OUTPUT_PATH}`);
+}
+generate();

package/dist/types/index.js

@@ -1,4 +1,4 @@
-// export * from "./Fugue/index.js";
+// dxport * from "./Fugue/index.js";
 export * from "./FugueTree/index.js";
 export * from "./Enums.js";
 export * from "./Models/index.js";

package/package.json

@@ -1,22 +1,29 @@
 {
   "name": "@cr_docs_t/dts",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "",
   "main": "dist/index.js",
   "type": "module",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "prebuild": "npm run gen-types",
     "prepublishOnly": "npm run build",
     "ci": "npm install && npm run build",
     "pretest": "npm run build",
-    "sest": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "gen-types": "tsx ./src/type-gen.ts && biome format --write ./src/treesitter/types/AST.ts"
   },
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./treesitter": {
+      "import": "./dist/treesitter.js",
+      "require": "./dist/treesitter.js",
+      "types": "./dist/treesitter.d.ts"
     }
   },
   "publishConfig": {
@@ -56,6 +63,7 @@
   "license": "ISC",
   "packageManager": "pnpm@10.20.0",
   "devDependencies": {
+    "@biomejs/biome": "2.4.4",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/jest": "^30.0.0",
@@ -64,6 +72,7 @@
     "jest": "^30.2.0",
     "semantic-release": "^25.0.2",
     "ts-jest": "^29.4.6",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
   "files": [
@@ -72,6 +81,8 @@
   "dependencies": {
     "@msgpack/msgpack": "^3.1.3",
     "lz4js": "^0.2.0",
+    "uuid": "^13.0.0",
+    "web-tree-sitter": "^0.26.5",
     "zod": "^4.3.6"
   }
 }