@tabnas/expr 0.5.19 → 0.5.20

package/dist/expr.d.ts

@@ -16,12 +16,15 @@ type OpDef = {
         required?: boolean;
         allow?: string[];
     };
+    key?: boolean;
+    dynamic?: boolean;
 };
 type ExprOptions = {
     op?: {
         [name: string]: OpDef;
     };
-    evaluate?: typeof evaluation;
+    evaluate?: Evaluate;
+    fold?: FoldOptions;
 };
 type Op = {
     name: string;
@@ -48,22 +51,103 @@ type Op = {
         required: boolean;
         allow?: string[];
     };
+    key: boolean;
+    dynamic: boolean;
     token: Token;
     OP_MARK: typeof OP_MARK;
 };
-type Evaluate = (rule: Rule, ctx: Context, op: Op, ...terms: any) => any;
+type KeyMap = Map<string, Op>;
+type Evaluate = (rule: Rule, ctx: Context, op: Op, terms: any[]) => any;
+type Path = (string | number)[];
+type FoldHit = {
+    found: boolean;
+    cycle: boolean;
+    value?: any;
+};
+type Site = {
+    readonly root: any;
+    readonly doc: string;
+    readonly path: Path;
+    readonly node: any;
+    readonly k: Record<string, any>;
+    readonly token?: Token;
+    at: (path: Path, doc?: string) => FoldHit;
+    locate: (path: Path, doc?: string) => {
+        found: boolean;
+        value?: any;
+    };
+    plain: () => any;
+};
+type FoldEvaluate = (site: Site, op: Op, terms: any[]) => any;
+type Inherit = (site: Site, node: any, k: Record<string, any>) => Record<string, any>;
+type Recognise = (site: Site, op: Op) => boolean;
+type Positions = (node: object) => Token | undefined;
+type FoldEntry = {
+    doc: string;
+    at: string;
+    targetDoc: string;
+    target: string;
+};
+type FoldReport = {
+    cycles: FoldEntry[];
+    unresolved: FoldEntry[];
+    dynamic: {
+        doc: string;
+        at: string;
+        src: string;
+    }[];
+};
+type FoldOptions = {
+    op?: {
+        [name: string]: OpDef;
+    };
+    evaluate: FoldEvaluate;
+    inherit?: Inherit;
+    recognise?: Recognise;
+    k?: Record<string, any>;
+    doc?: string;
+    load?: (doc: string, site: Site) => any;
+    cycle?: 'verbatim' | 'error';
+    tokens?: boolean;
+    positions?: boolean | Positions;
+    maxDepth?: number;
+    report?: (report: FoldReport) => void;
+};
 declare const OP_MARK: {};
 declare let Expr: Plugin;
+declare function isOp(node: any): any;
+declare function makeKeyMap(optop: {
+    [name: string]: OpDef;
+}): KeyMap;
+declare function keyOpOf(keys: KeyMap, node: any): Op | undefined;
+declare class FoldError extends Error {
+    code: string;
+    doc?: string;
+    at?: string;
+    targetDoc?: string;
+    target?: string;
+    constructor(code: string, message: string, fields?: {
+        doc?: string;
+        at?: string;
+        targetDoc?: string;
+        target?: string;
+    });
+}
+declare function recordPositions(tn: Tabnas): Positions;
+declare function fold(root: any, opts: FoldOptions): any;
 declare function prattify(expr: any, op?: Op, whence?: string): any[];
-declare function evaluation(rule: Rule, ctx: Context, expr: any, evaluate: Evaluate): any;
+declare function evaluation(rule: Rule, ctx: Context, expr: any, evaluate: Evaluate, opts?: {
+    objects?: boolean;
+}): any;
 declare function simplify(value: any): any;
 declare function parseSimplified(tn: Tabnas, src: string, meta?: any): any;
+declare function opify<T extends object>(op: T): T;
 declare const testing: {
     prattify: typeof prattify;
-    opify: (x: any) => any;
+    opify: typeof opify;
 };
-declare const VERSION = "0.5.19";
-export { VERSION, Expr, evaluation, simplify, parseSimplified, testing };
-export type { ExprOptions, OpDef, Op, Evaluate };
+declare const VERSION = "0.5.20";
+export { VERSION, Expr, evaluation, simplify, parseSimplified, fold, recordPositions, FoldError, opify, isOp, keyOpOf, makeKeyMap, testing, };
+export type { ExprOptions, OpDef, Op, Evaluate, FoldOptions, FoldEvaluate, FoldHit, FoldEntry, Inherit, Recognise, Positions, Site, FoldReport, Path, KeyMap, };
 export { translate } from './translate';
 export type { TranslationPart, TranslationParts } from './translate';