@rejot-dev/thalo 0.1.0 → 0.2.0

package/dist/parser.node.d.ts

@@ -0,0 +1,66 @@
+import { FileType, GenericTree, ParseOptions, ParsedBlock as ParsedBlock$1, ParsedDocument as ParsedDocument$1, ThaloParser } from "./parser.shared.js";
+import { Workspace } from "./model/workspace.js";
+
+//#region src/parser.node.d.ts
+
+type ParsedBlock = ParsedBlock$1<GenericTree>;
+type ParsedDocument = ParsedDocument$1<GenericTree>;
+/**
+ * Check if the parser has been initialized.
+ */
+declare function isInitialized(): boolean;
+/**
+ * Check if using native bindings (vs WASM fallback).
+ * Only valid after `initParser()` has been called.
+ */
+declare function isUsingNative(): boolean;
+/**
+ * Initialize the parser, trying native first then falling back to WASM.
+ *
+ * This must be called (and awaited) once before using `createParser()` or
+ * `createWorkspace()`. Multiple calls are safe and will return immediately
+ * if already initialized.
+ *
+ * @returns Promise that resolves when parser is ready
+ * @throws Error if both native and WASM initialization fail
+ */
+declare function initParser(): Promise<void>;
+/**
+ * Create a ThaloParser instance.
+ *
+ * Note: `initParser()` must be called first.
+ *
+ * @throws Error if `initParser()` has not been called
+ */
+declare function createParser(): ThaloParser<GenericTree>;
+/**
+ * Create a Workspace with the initialized parser.
+ *
+ * Note: `initParser()` must be called first.
+ *
+ * @example
+ * ```typescript
+ * import { initParser, createWorkspace } from "@rejot-dev/thalo/node";
+ *
+ * await initParser();
+ * const workspace = createWorkspace();
+ * workspace.addDocument(source, { filename: "test.thalo" });
+ * ```
+ *
+ * @throws Error if `initParser()` has not been called
+ */
+declare function createWorkspace(): Workspace;
+/**
+ * Parse a document using the initialized parser.
+ *
+ * Note: `initParser()` must be called first.
+ *
+ * @param source - The source code to parse
+ * @param options - Parse options
+ * @returns A parsed document
+ * @throws Error if `initParser()` has not been called
+ */
+declare function parseDocument(source: string, options?: ParseOptions): ParsedDocument$1<GenericTree>;
+//#endregion
+export { type FileType, type ParseOptions, ParsedBlock, ParsedDocument, type ThaloParser, Workspace, createParser, createWorkspace, initParser, isInitialized, isUsingNative, parseDocument };
+//# sourceMappingURL=parser.node.d.ts.map

package/dist/parser.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.node.d.ts","names":[],"sources":["../src/parser.node.ts"],"sourcesContent":[],"mappings":";;;;;KAuCY,WAAA,GAAc,cAAmB;KACjC,cAAA,GAAiB,iBAAsB;;;;iBAiBnC,aAAA,CAAA;;;;;iBAQA,aAAA,CAAA;;;;;;;;;;;iBAcM,UAAA,CAAA,GAAc;;;;;;;;iBA6EpB,YAAA,CAAA,GAAgB,YAAY;;;;;;;;;;;;;;;;;iBAyB5B,eAAA,CAAA,GAAmB;;;;;;;;;;;iBAsBnB,aAAA,2BAEJ,eACT,iBAAsB"}

package/dist/parser.node.js

@@ -0,0 +1,118 @@
+import { createThaloParser } from "./parser.shared.js";
+import { Workspace } from "./model/workspace.js";
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+
+//#region src/parser.node.ts
+const require = createRequire(import.meta.url);
+let parserFactory = null;
+let usingNative = false;
+/**
+* Check if the parser has been initialized.
+*/
+function isInitialized() {
+	return parserFactory !== null;
+}
+/**
+* Check if using native bindings (vs WASM fallback).
+* Only valid after `initParser()` has been called.
+*/
+function isUsingNative() {
+	return usingNative;
+}
+/**
+* Initialize the parser, trying native first then falling back to WASM.
+*
+* This must be called (and awaited) once before using `createParser()` or
+* `createWorkspace()`. Multiple calls are safe and will return immediately
+* if already initialized.
+*
+* @returns Promise that resolves when parser is ready
+* @throws Error if both native and WASM initialization fail
+*/
+async function initParser() {
+	if (parserFactory) return;
+	try {
+		const { default: Parser } = await import("tree-sitter");
+		const { default: thalo } = await import("@rejot-dev/tree-sitter-thalo");
+		thalo.nodeTypeInfo ??= [];
+		new Parser().setLanguage(thalo);
+		parserFactory = () => {
+			const parser = new Parser();
+			parser.setLanguage(thalo);
+			return createThaloParser(parser);
+		};
+		usingNative = true;
+		return;
+	} catch {}
+	try {
+		const { Parser, Language } = await import("web-tree-sitter");
+		const treeSitterWasmPath = require.resolve("web-tree-sitter/tree-sitter.wasm");
+		const languageWasmPath = require.resolve("@rejot-dev/tree-sitter-thalo/tree-sitter-thalo.wasm");
+		const treeSitterWasm = readFileSync(treeSitterWasmPath);
+		const languageWasm = readFileSync(languageWasmPath);
+		await Parser.init({ wasmBinary: treeSitterWasm });
+		const language = await Language.load(languageWasm);
+		parserFactory = () => {
+			const parser = new Parser();
+			parser.setLanguage(language);
+			return createThaloParser(parser);
+		};
+		usingNative = false;
+		return;
+	} catch (wasmError) {
+		throw new Error(`Failed to initialize thalo parser. Native tree-sitter bindings are not available for your platform, and WASM fallback also failed: ${wasmError instanceof Error ? wasmError.message : wasmError}`);
+	}
+}
+let cachedParser = null;
+/**
+* Create a ThaloParser instance.
+*
+* Note: `initParser()` must be called first.
+*
+* @throws Error if `initParser()` has not been called
+*/
+function createParser() {
+	if (!parserFactory) throw new Error("Parser not initialized. Call `await initParser()` before using createParser().");
+	return parserFactory();
+}
+/**
+* Create a Workspace with the initialized parser.
+*
+* Note: `initParser()` must be called first.
+*
+* @example
+* ```typescript
+* import { initParser, createWorkspace } from "@rejot-dev/thalo/node";
+*
+* await initParser();
+* const workspace = createWorkspace();
+* workspace.addDocument(source, { filename: "test.thalo" });
+* ```
+*
+* @throws Error if `initParser()` has not been called
+*/
+function createWorkspace() {
+	if (!parserFactory) throw new Error("Parser not initialized. Call `await initParser()` before using createWorkspace().");
+	if (!cachedParser) cachedParser = parserFactory();
+	return new Workspace(cachedParser);
+}
+/**
+* Parse a document using the initialized parser.
+*
+* Note: `initParser()` must be called first.
+*
+* @param source - The source code to parse
+* @param options - Parse options
+* @returns A parsed document
+* @throws Error if `initParser()` has not been called
+*/
+function parseDocument(source, options) {
+	if (!parserFactory) throw new Error("Parser not initialized. Call `await initParser()` before using parseDocument().");
+	if (!cachedParser) cachedParser = parserFactory();
+	return cachedParser.parseDocument(source, options);
+}
+
+//#endregion
+export { Workspace, createParser, createWorkspace, initParser, isInitialized, isUsingNative, parseDocument };
+//# sourceMappingURL=parser.node.js.map

package/dist/parser.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.node.js","names":["parserFactory: (() => ThaloParser<GenericTree>) | null","cachedParser: ThaloParser<GenericTree> | null"],"sources":["../src/parser.node.ts"],"sourcesContent":["/**\n * Node.js parser with automatic fallback from native to WASM.\n *\n * This module provides a unified API for Node.js environments that:\n * 1. Tries to use native tree-sitter bindings (fastest)\n * 2. Falls back to web-tree-sitter WASM if native bindings aren't available\n *\n * The fallback is transparent - callers don't need to know which implementation\n * is being used. The only requirement is that `initParser()` must be called\n * (and awaited) before using `createParser()` or `createWorkspace()`.\n *\n * @example\n * ```typescript\n * import { initParser, createWorkspace } from \"@rejot-dev/thalo/node\";\n *\n * // Initialize once at startup (required)\n * await initParser();\n *\n * // Then use synchronously\n * const workspace = createWorkspace();\n * workspace.addDocument(source, { filename: \"test.thalo\" });\n * ```\n */\n\nimport { readFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport {\n  createThaloParser,\n  type ThaloParser,\n  type ParsedBlock as GenericParsedBlock,\n  type ParsedDocument as GenericParsedDocument,\n  type FileType,\n  type ParseOptions,\n  type GenericTree,\n} from \"./parser.shared.js\";\nimport type { Language as NativeLanguage } from \"tree-sitter\";\nimport { Workspace } from \"./model/workspace.js\";\n\n// Re-export shared types\nexport type ParsedBlock = GenericParsedBlock<GenericTree>;\nexport type ParsedDocument = GenericParsedDocument<GenericTree>;\nexport type { FileType, ParseOptions, ThaloParser };\n\n// Re-export Workspace for convenience\nexport { Workspace } from \"./model/workspace.js\";\n\nconst require = createRequire(import.meta.url);\n\n// Parser factory function - set after initialization\nlet parserFactory: (() => ThaloParser<GenericTree>) | null = null;\n\n// Track which implementation is being used\nlet usingNative = false;\n\n/**\n * Check if the parser has been initialized.\n */\nexport function isInitialized(): boolean {\n  return parserFactory !== null;\n}\n\n/**\n * Check if using native bindings (vs WASM fallback).\n * Only valid after `initParser()` has been called.\n */\nexport function isUsingNative(): boolean {\n  return usingNative;\n}\n\n/**\n * Initialize the parser, trying native first then falling back to WASM.\n *\n * This must be called (and awaited) once before using `createParser()` or\n * `createWorkspace()`. Multiple calls are safe and will return immediately\n * if already initialized.\n *\n * @returns Promise that resolves when parser is ready\n * @throws Error if both native and WASM initialization fail\n */\nexport async function initParser(): Promise<void> {\n  // Already initialized\n  if (parserFactory) {\n    return;\n  }\n\n  // Try native first\n  try {\n    const { default: Parser } = await import(\"tree-sitter\");\n    const { default: thalo } = await import(\"@rejot-dev/tree-sitter-thalo\");\n\n    // Ensure nodeTypeInfo is an array\n    thalo.nodeTypeInfo ??= [];\n\n    // Test that we can actually create a parser (this will fail if native bindings are broken)\n    const testParser = new Parser();\n    testParser.setLanguage(thalo as unknown as NativeLanguage);\n\n    // Native works! Set up the factory\n    parserFactory = () => {\n      const parser = new Parser();\n      parser.setLanguage(thalo as unknown as NativeLanguage);\n      return createThaloParser(parser);\n    };\n    usingNative = true;\n    return;\n  } catch {\n    // Native failed, try WASM fallback\n  }\n\n  // Fall back to WASM\n  try {\n    const { Parser, Language } = await import(\"web-tree-sitter\");\n\n    // Resolve WASM file paths from installed dependencies\n    const treeSitterWasmPath = require.resolve(\"web-tree-sitter/tree-sitter.wasm\");\n    const languageWasmPath = require.resolve(\"@rejot-dev/tree-sitter-thalo/tree-sitter-thalo.wasm\");\n\n    // Load WASM files\n    const treeSitterWasm = readFileSync(treeSitterWasmPath);\n    const languageWasm = readFileSync(languageWasmPath);\n\n    // Initialize web-tree-sitter\n    await Parser.init({\n      wasmBinary: treeSitterWasm,\n    });\n\n    // Load the thalo language\n    const language = await Language.load(languageWasm);\n\n    // WASM works! Set up the factory\n    parserFactory = () => {\n      const parser = new Parser();\n      parser.setLanguage(language);\n      return createThaloParser(parser);\n    };\n    usingNative = false;\n    return;\n  } catch (wasmError) {\n    throw new Error(\n      `Failed to initialize thalo parser. ` +\n        `Native tree-sitter bindings are not available for your platform, ` +\n        `and WASM fallback also failed: ${wasmError instanceof Error ? wasmError.message : wasmError}`,\n    );\n  }\n}\n\n// Cached parser instance for createWorkspace\nlet cachedParser: ThaloParser<GenericTree> | null = null;\n\n/**\n * Create a ThaloParser instance.\n *\n * Note: `initParser()` must be called first.\n *\n * @throws Error if `initParser()` has not been called\n */\nexport function createParser(): ThaloParser<GenericTree> {\n  if (!parserFactory) {\n    throw new Error(\n      \"Parser not initialized. Call `await initParser()` before using createParser().\",\n    );\n  }\n  return parserFactory();\n}\n\n/**\n * Create a Workspace with the initialized parser.\n *\n * Note: `initParser()` must be called first.\n *\n * @example\n * ```typescript\n * import { initParser, createWorkspace } from \"@rejot-dev/thalo/node\";\n *\n * await initParser();\n * const workspace = createWorkspace();\n * workspace.addDocument(source, { filename: \"test.thalo\" });\n * ```\n *\n * @throws Error if `initParser()` has not been called\n */\nexport function createWorkspace(): Workspace {\n  if (!parserFactory) {\n    throw new Error(\n      \"Parser not initialized. Call `await initParser()` before using createWorkspace().\",\n    );\n  }\n  if (!cachedParser) {\n    cachedParser = parserFactory();\n  }\n  return new Workspace(cachedParser);\n}\n\n/**\n * Parse a document using the initialized parser.\n *\n * Note: `initParser()` must be called first.\n *\n * @param source - The source code to parse\n * @param options - Parse options\n * @returns A parsed document\n * @throws Error if `initParser()` has not been called\n */\nexport function parseDocument(\n  source: string,\n  options?: ParseOptions,\n): GenericParsedDocument<GenericTree> {\n  if (!parserFactory) {\n    throw new Error(\n      \"Parser not initialized. Call `await initParser()` before using parseDocument().\",\n    );\n  }\n  if (!cachedParser) {\n    cachedParser = parserFactory();\n  }\n  return cachedParser.parseDocument(source, options);\n}\n"],"mappings":";;;;;;AA8CA,MAAM,UAAU,cAAc,OAAO,KAAK,IAAI;AAG9C,IAAIA,gBAAyD;AAG7D,IAAI,cAAc;;;;AAKlB,SAAgB,gBAAyB;AACvC,QAAO,kBAAkB;;;;;;AAO3B,SAAgB,gBAAyB;AACvC,QAAO;;;;;;;;;;;;AAaT,eAAsB,aAA4B;AAEhD,KAAI,cACF;AAIF,KAAI;EACF,MAAM,EAAE,SAAS,WAAW,MAAM,OAAO;EACzC,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;AAGxC,QAAM,iBAAiB,EAAE;AAIzB,EADmB,IAAI,QAAQ,CACpB,YAAY,MAAmC;AAG1D,wBAAsB;GACpB,MAAM,SAAS,IAAI,QAAQ;AAC3B,UAAO,YAAY,MAAmC;AACtD,UAAO,kBAAkB,OAAO;;AAElC,gBAAc;AACd;SACM;AAKR,KAAI;EACF,MAAM,EAAE,QAAQ,aAAa,MAAM,OAAO;EAG1C,MAAM,qBAAqB,QAAQ,QAAQ,mCAAmC;EAC9E,MAAM,mBAAmB,QAAQ,QAAQ,sDAAsD;EAG/F,MAAM,iBAAiB,aAAa,mBAAmB;EACvD,MAAM,eAAe,aAAa,iBAAiB;AAGnD,QAAM,OAAO,KAAK,EAChB,YAAY,gBACb,CAAC;EAGF,MAAM,WAAW,MAAM,SAAS,KAAK,aAAa;AAGlD,wBAAsB;GACpB,MAAM,SAAS,IAAI,QAAQ;AAC3B,UAAO,YAAY,SAAS;AAC5B,UAAO,kBAAkB,OAAO;;AAElC,gBAAc;AACd;UACO,WAAW;AAClB,QAAM,IAAI,MACR,sIAEoC,qBAAqB,QAAQ,UAAU,UAAU,YACtF;;;AAKL,IAAIC,eAAgD;;;;;;;;AASpD,SAAgB,eAAyC;AACvD,KAAI,CAAC,cACH,OAAM,IAAI,MACR,iFACD;AAEH,QAAO,eAAe;;;;;;;;;;;;;;;;;;AAmBxB,SAAgB,kBAA6B;AAC3C,KAAI,CAAC,cACH,OAAM,IAAI,MACR,oFACD;AAEH,KAAI,CAAC,aACH,gBAAe,eAAe;AAEhC,QAAO,IAAI,UAAU,aAAa;;;;;;;;;;;;AAapC,SAAgB,cACd,QACA,SACoC;AACpC,KAAI,CAAC,cACH,OAAM,IAAI,MACR,kFACD;AAEH,KAAI,CAAC,aACH,gBAAe,eAAe;AAEhC,QAAO,aAAa,cAAc,QAAQ,QAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rejot-dev/thalo",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -29,6 +29,11 @@
       "types": "./dist/parser.web.d.ts",
       "default": "./dist/parser.web.js"
     },
+    "./node": {
+      "development": "./src/parser.node.ts",
+      "types": "./dist/parser.node.d.ts",
+      "default": "./dist/parser.node.js"
+    },
     "./services/semantic-tokens": {
       "development": "./src/services/semantic-tokens.ts",
       "types": "./dist/services/semantic-tokens.d.ts",
@@ -88,12 +93,17 @@
       "development": "./src/files.ts",
       "types": "./dist/files.d.ts",
       "default": "./dist/files.js"
+    },
+    "./api": {
+      "development": "./src/api.ts",
+      "types": "./dist/api.d.ts",
+      "default": "./dist/api.js"
     }
   },
   "main": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
   "dependencies": {
-    "@rejot-dev/tree-sitter-thalo": "0.1.0"
+    "@rejot-dev/tree-sitter-thalo": "0.2.0"
   },
   "peerDependencies": {
     "tree-sitter": "^0.25.0",