@ohm-js/wasm 0.6.9 → 0.6.11

package/dist/src/AstBuilder.d.ts

@@ -3,6 +3,9 @@ export type AstNodeTemplate<R> = {
     [property: string]: number | string | boolean | object | null | ((this: AstBuilder, children: CstNodeChildren) => R);
 };
 export type AstMapping<R> = Record<string, AstNodeTemplate<R> | number | ((this: AstBuilder, ...children: CstNodeChildren) => R)>;
+export declare function createToAst<TNode = any>(mapping: AstMapping<TNode>, opts?: {
+    debug?: boolean;
+}): (nodeOrResult: MatchResult | CstNode) => TNode;
 export declare class AstBuilder<TNode = any> {
     currNode?: CstNode;
     private _mapping;

package/dist/src/AstBuilder.js

@@ -6,6 +6,10 @@ function childAt(children, idx, ruleName, propName = '') {
     }
     return checkNotNull(children[idx]);
 }
+export function createToAst(mapping, opts = {}) {
+    const builder = new AstBuilder(mapping, opts);
+    return (nodeOrResult) => builder.toAst(nodeOrResult);
+}
 export class AstBuilder {
     currNode;
     _mapping;

package/dist/src/compat.d.ts

@@ -5,5 +5,5 @@ export interface Grammar extends WasmGrammar {
 }
 export declare function grammar(source: string): Grammar;
 export declare function grammars(source: string): Record<string, Grammar>;
-export { AstBuilder } from './AstBuilder.js';
+export { createToAst } from './createToAst.ts';
 //# sourceMappingURL=compat.d.ts.map

package/dist/src/compat.js

@@ -21,5 +21,5 @@ export function grammars(source) {
     }
     return ans;
 }
-export { AstBuilder } from './AstBuilder.js';
+export { createToAst } from "./createToAst.js";
 //# sourceMappingURL=compat.js.map

package/dist/src/createToAst.d.ts

@@ -0,0 +1,22 @@
+import type { CstNode, CstNodeChildren, MatchResult, NonterminalNode, TerminalNode } from './miniohm.ts';
+export type AstNodeTemplate<R> = {
+    [property: string]: number | string | boolean | object | null | ((children: CstNodeChildren) => R);
+};
+export type AstMapping<R> = Record<string, AstNodeTemplate<R> | number | ((...children: CstNodeChildren) => R)>;
+export declare function createToAst<TNode = any>(mapping: AstMapping<TNode>, opts?: {
+    debug?: boolean;
+}): (nodeOrResult: MatchResult | CstNode) => TNode;
+export declare class AstBuilder<TNode = any> {
+    currNode?: CstNode;
+    private _mapping;
+    private _depth;
+    private _debug;
+    constructor(mapping: AstMapping<TNode>, opts?: {
+        debug?: boolean;
+    });
+    private _debugLog;
+    _visitTerminal(node: TerminalNode): string;
+    _visitNonterminal(node: NonterminalNode): unknown;
+    toAst(nodeOrResult: MatchResult | CstNode): TNode;
+}
+//# sourceMappingURL=createToAst.d.ts.map

package/dist/src/createToAst.js

@@ -0,0 +1,140 @@
+import { assert, checkNotNull } from "./assert.js";
+function childAt(children, idx, ruleName, propName = '') {
+    if (idx > children.length) {
+        const path = propName ? `${ruleName}.${propName}` : ruleName;
+        throw new Error(`${path}: Child index ${idx} out of range`);
+    }
+    return checkNotNull(children[idx]);
+}
+export function createToAst(mapping, opts = {}) {
+    const builder = new AstBuilder(mapping, opts);
+    return (nodeOrResult) => builder.toAst(nodeOrResult);
+}
+export class AstBuilder {
+    currNode;
+    _mapping;
+    _depth = -1;
+    _debug = false;
+    constructor(mapping, opts = {}) {
+        const handleListOf = (child) => this.toAst(child);
+        const handleEmptyListOf = () => [];
+        const handleNonemptyListOf = (first, sepAndElemList) => {
+            assert(!!sepAndElemList?.isList(), 'Expected a ListNode');
+            return [this.toAst(first), ...sepAndElemList.collect((_, elem) => this.toAst(elem))];
+        };
+        this._mapping = {
+            listOf: handleListOf,
+            ListOf: handleListOf,
+            emptyListOf: handleEmptyListOf,
+            EmptyListOf: handleEmptyListOf,
+            nonemptyListOf: handleNonemptyListOf,
+            NonemptyListOf: handleNonemptyListOf,
+            ...mapping,
+        };
+        this._debug = opts.debug ?? false;
+    }
+    _debugLog(...data) {
+        if (this._debug)
+            console.log('  '.repeat(this._depth), ...data);
+    }
+    _visitTerminal(node) {
+        return node.sourceString;
+    }
+    _visitNonterminal(node) {
+        const { children, ctorName } = node;
+        const mapping = this._mapping;
+        this._debugLog(`> ${ctorName}`);
+        const dbgReturn = (val) => {
+            this._debugLog(`| ${ctorName} DONE`);
+            return val;
+        };
+        // without customization
+        if (!Object.hasOwn(mapping, ctorName)) {
+            // lexical rule
+            if (node.isLexical()) {
+                return node.sourceString;
+            }
+            // singular node (e.g. only surrounded by literals or lookaheads)
+            const realChildren = children.filter(c => !c.isTerminal());
+            if (realChildren.length === 1) {
+                return dbgReturn(this.toAst(realChildren[0]));
+            }
+            // rest: terms with multiple children
+        }
+        // direct forward
+        if (typeof mapping[ctorName] === 'number') {
+            const idx = mapping[ctorName];
+            return dbgReturn(this.toAst(childAt(children, idx, ctorName)));
+        }
+        assert(typeof mapping[ctorName] !== 'function', "shouldn't be possible");
+        // named/mapped children or unnamed children ('0', '1', '2', ...)
+        const propMap = mapping[ctorName] || children;
+        const ans = {
+            type: ctorName,
+        };
+        // eslint-disable-next-line guard-for-in
+        for (const prop in propMap) {
+            const mappedProp = mapping[ctorName] && mapping[ctorName][prop];
+            if (typeof mappedProp === 'number') {
+                // direct forward
+                ans[prop] = this.toAst(childAt(children, mappedProp, ctorName, prop));
+            }
+            else if (typeof mappedProp === 'string' ||
+                typeof mappedProp === 'boolean' ||
+                mappedProp === null) {
+                // primitive value
+                ans[prop] = mappedProp;
+            }
+            else if (typeof mappedProp === 'object' && mappedProp instanceof Number) {
+                // primitive number (must be unboxed)
+                ans[prop] = Number(mappedProp);
+            }
+            else if (typeof mappedProp === 'function') {
+                // computed value
+                ans[prop] = mappedProp.call(this, children);
+            }
+            else if (mappedProp === undefined) {
+                const child = children[Number(prop)];
+                if (child && !child.isTerminal()) {
+                    ans[prop] = this.toAst(child);
+                }
+                else {
+                    // delete predefined 'type' properties, like 'type', if explicitly removed
+                    delete ans[prop];
+                }
+            }
+        }
+        return dbgReturn(ans);
+    }
+    toAst(nodeOrResult) {
+        let node = nodeOrResult;
+        if (typeof nodeOrResult.succeeded === 'function') {
+            const matchResult = nodeOrResult;
+            assert(matchResult.succeeded(), 'Cannot convert failed match result to AST');
+            node = matchResult.grammar.getCstRoot();
+        }
+        let ans;
+        this._depth++;
+        if (node.isTerminal()) {
+            ans = this._visitTerminal(node);
+        }
+        else if (node.isOptional()) {
+            ans = node.ifPresent((child) => this.toAst(child), () => null);
+        }
+        else if (node.isList() || node.isSeq()) {
+            ans = node.children.map(c => this.toAst(c));
+        }
+        else {
+            assert(node.isNonterminal(), `Unknown node type: ${node.type}`);
+            this.currNode = node;
+            ans =
+                typeof this._mapping[node.ctorName] === 'function'
+                    ? this._mapping[node.ctorName].apply(this, node.children)
+                    : this._visitNonterminal(node);
+            this.currNode = undefined;
+        }
+        this._depth--;
+        return ans;
+    }
+}
+//# sourceMappingURL=createToAst.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohm-js/wasm",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "description": "Compile Ohm.js grammars to WebAsssembly",
   "main": "dist/index.js",
   "exports": {