@nocobase/plugin-workflow-json-query 1.9.0-beta.17

package/dist/node_modules/jsonpath-plus/package.json

@@ -0,0 +1 @@
+{"author":"Stefan Goessner","name":"jsonpath-plus","version":"10.3.0","type":"module","bin":{"jsonpath":"./bin/jsonpath-cli.js","jsonpath-plus":"./bin/jsonpath-cli.js"},"main":"dist/index-node-cjs.cjs","exports":{"./package.json":"./package.json",".":{"types":"./src/jsonpath.d.ts","browser":"./dist/index-browser-esm.js","umd":"./dist/index-browser-umd.cjs","import":"./dist/index-node-esm.js","require":"./dist/index-node-cjs.cjs","default":"./dist/index-browser-esm.js"}},"module":"dist/index-node-esm.js","browser":"dist/index-browser-esm.js","types":"./src/jsonpath.d.ts","description":"A JS implementation of JSONPath with some additional operators","contributors":[{"name":"Prof. Gössner","email":"stefan.goessner@fh-dortmund.de"},{"name":"Subbu Allamaraju","email":"subbu@subbu.org"},{"name":"Mike Brevoort","email":"mike@brevoort.com"},{"name":"Robert Krahn","email":"robert.krahn@gmail.com"},{"name":"Brett Zamir","email":"brettz9@yahoo.com"},{"name":"Richard Schneider","email":"makaretu@gmail.com"}],"license":"MIT","repository":{"type":"git","url":"git://github.com/s3u/JSONPath.git"},"bugs":"https://github.com/s3u/JSONPath/issues/","homepage":"https://github.com/s3u/JSONPath","engines":{"node":">=18.0.0"},"react-native":{"vm":false},"dependencies":{"@jsep-plugin/assignment":"^1.3.0","@jsep-plugin/regex":"^1.0.4","jsep":"^1.4.0"},"devDependencies":{"@babel/core":"^7.26.8","@babel/preset-env":"^7.26.8","@rollup/plugin-babel":"^6.0.4","@rollup/plugin-node-resolve":"^15.3.1","@rollup/plugin-terser":"^0.4.4","c8":"^10.1.3","chai":"^5.1.2","coveradge":"^0.8.2","eslint":"^9.20.1","eslint-config-ash-nazg":"^36.22.2","http-server":"^14.1.1","license-badger":"^0.21.1","mocha":"^10.8.2","mocha-badge-generator":"^0.11.0","mocha-multi-reporters":"^1.5.1","open-cli":"^8.0.0","rollup":"4.27.2","typedoc":"^0.27.7","typescript":"^5.7.3"},"keywords":["json","jsonpath"],"browserslist":["defaults, not op_mini all"],"c8":{"reporter":["text","html","json-summary"],"exclude":[".mocharc.cjs","eslint.config.js","src/jsonpath.d.ts","rollup.config.js",".idea","coverage","dist","demo","docs","ignore","test","test-helpers"]},"scripts":{"prepublishOnly":"pnpm i","license-badge":"license-badger --corrections --uncategorizedLicenseTemplate \"\\${license} (\\${name} (\\${version}))\" --filteredTypes=nonempty --textTemplate \"License types\n(project, deps, and bundled devDeps)\" --packageJson --production badges/licenses-badge.svg","license-badge-dev":"license-badger --corrections --filteredTypes=nonempty --textTemplate \"License types\n(all devDeps)\" --allDevelopment badges/licenses-badge-dev.svg","license-badges":"npm run license-badge && npm run license-badge-dev","build-docs":"typedoc --out docs/ts src --excludeExternals --entryPointStrategy Expand","open-docs":"open-cli http://localhost:8084/docs/ts/ && npm start","coverage":"open-cli http://localhost:8084/coverage/ && npm start","coverage-badge":"coveradge badges/coverage-badge.svg","node-import-test":"node --experimental-modules demo/node-import-test.mjs","open":"open-cli http://localhost:8084/demo/ && npm start","start":"http-server -p 8084","cli":"./bin/jsonpath-cli.js package.json name","typescript":"tsc","mocha":"mocha --require test-helpers/node-env.js --reporter-options configFile=mocha-multi-reporters.json test","c8":"rm -Rf ./coverage && rm -Rf ./node_modules/.cache && c8 --all npm run mocha && npm run coverage-badge","rollup":"rollup -c","eslint":"eslint .","lint":"npm run eslint","test":"npm run eslint && npm run rollup && npm run c8 && npm run typescript","browser-test":"npm run eslint && npm run rollup && open-cli http://localhost:8084/test/ && npm start"},"_lastModified":"2025-11-21T09:46:33.534Z"}

package/dist/node_modules/jsonpath-plus/src/Safe-Script.js

@@ -0,0 +1,200 @@
+/* eslint-disable no-bitwise -- Convenient */
+import jsep from 'jsep';
+import jsepRegex from '@jsep-plugin/regex';
+import jsepAssignment from '@jsep-plugin/assignment';
+
+// register plugins
+jsep.plugins.register(jsepRegex, jsepAssignment);
+jsep.addUnaryOp('typeof');
+jsep.addLiteral('null', null);
+jsep.addLiteral('undefined', undefined);
+
+const BLOCKED_PROTO_PROPERTIES = new Set([
+    'constructor',
+    '__proto__',
+    '__defineGetter__',
+    '__defineSetter__'
+]);
+
+const SafeEval = {
+    /**
+     * @param {jsep.Expression} ast
+     * @param {Record<string, any>} subs
+     */
+    evalAst (ast, subs) {
+        switch (ast.type) {
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            return SafeEval.evalBinaryExpression(ast, subs);
+        case 'Compound':
+            return SafeEval.evalCompound(ast, subs);
+        case 'ConditionalExpression':
+            return SafeEval.evalConditionalExpression(ast, subs);
+        case 'Identifier':
+            return SafeEval.evalIdentifier(ast, subs);
+        case 'Literal':
+            return SafeEval.evalLiteral(ast, subs);
+        case 'MemberExpression':
+            return SafeEval.evalMemberExpression(ast, subs);
+        case 'UnaryExpression':
+            return SafeEval.evalUnaryExpression(ast, subs);
+        case 'ArrayExpression':
+            return SafeEval.evalArrayExpression(ast, subs);
+        case 'CallExpression':
+            return SafeEval.evalCallExpression(ast, subs);
+        case 'AssignmentExpression':
+            return SafeEval.evalAssignmentExpression(ast, subs);
+        default:
+            throw SyntaxError('Unexpected expression', ast);
+        }
+    },
+    evalBinaryExpression (ast, subs) {
+        const result = {
+            '||': (a, b) => a || b(),
+            '&&': (a, b) => a && b(),
+            '|': (a, b) => a | b(),
+            '^': (a, b) => a ^ b(),
+            '&': (a, b) => a & b(),
+            // eslint-disable-next-line eqeqeq -- API
+            '==': (a, b) => a == b(),
+            // eslint-disable-next-line eqeqeq -- API
+            '!=': (a, b) => a != b(),
+            '===': (a, b) => a === b(),
+            '!==': (a, b) => a !== b(),
+            '<': (a, b) => a < b(),
+            '>': (a, b) => a > b(),
+            '<=': (a, b) => a <= b(),
+            '>=': (a, b) => a >= b(),
+            '<<': (a, b) => a << b(),
+            '>>': (a, b) => a >> b(),
+            '>>>': (a, b) => a >>> b(),
+            '+': (a, b) => a + b(),
+            '-': (a, b) => a - b(),
+            '*': (a, b) => a * b(),
+            '/': (a, b) => a / b(),
+            '%': (a, b) => a % b()
+        }[ast.operator](
+            SafeEval.evalAst(ast.left, subs),
+            () => SafeEval.evalAst(ast.right, subs)
+        );
+        return result;
+    },
+    evalCompound (ast, subs) {
+        let last;
+        for (let i = 0; i < ast.body.length; i++) {
+            if (
+                ast.body[i].type === 'Identifier' &&
+                ['var', 'let', 'const'].includes(ast.body[i].name) &&
+                ast.body[i + 1] &&
+                ast.body[i + 1].type === 'AssignmentExpression'
+            ) {
+                // var x=2; is detected as
+                // [{Identifier var}, {AssignmentExpression x=2}]
+                // eslint-disable-next-line @stylistic/max-len -- Long
+                // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient
+                i += 1;
+            }
+            const expr = ast.body[i];
+            last = SafeEval.evalAst(expr, subs);
+        }
+        return last;
+    },
+    evalConditionalExpression (ast, subs) {
+        if (SafeEval.evalAst(ast.test, subs)) {
+            return SafeEval.evalAst(ast.consequent, subs);
+        }
+        return SafeEval.evalAst(ast.alternate, subs);
+    },
+    evalIdentifier (ast, subs) {
+        if (Object.hasOwn(subs, ast.name)) {
+            return subs[ast.name];
+        }
+        throw ReferenceError(`${ast.name} is not defined`);
+    },
+    evalLiteral (ast) {
+        return ast.value;
+    },
+    evalMemberExpression (ast, subs) {
+        const prop = String(
+            // NOTE: `String(value)` throws error when
+            // value has overwritten the toString method to return non-string
+            // i.e. `value = {toString: () => []}`
+            ast.computed
+                ? SafeEval.evalAst(ast.property) // `object[property]`
+                : ast.property.name // `object.property` property is Identifier
+        );
+        const obj = SafeEval.evalAst(ast.object, subs);
+        if (obj === undefined || obj === null) {
+            throw TypeError(
+                `Cannot read properties of ${obj} (reading '${prop}')`
+            );
+        }
+        if (!Object.hasOwn(obj, prop) && BLOCKED_PROTO_PROPERTIES.has(prop)) {
+            throw TypeError(
+                `Cannot read properties of ${obj} (reading '${prop}')`
+            );
+        }
+        const result = obj[prop];
+        if (typeof result === 'function') {
+            return result.bind(obj); // arrow functions aren't affected by bind.
+        }
+        return result;
+    },
+    evalUnaryExpression (ast, subs) {
+        const result = {
+            '-': (a) => -SafeEval.evalAst(a, subs),
+            '!': (a) => !SafeEval.evalAst(a, subs),
+            '~': (a) => ~SafeEval.evalAst(a, subs),
+            // eslint-disable-next-line no-implicit-coercion -- API
+            '+': (a) => +SafeEval.evalAst(a, subs),
+            typeof: (a) => typeof SafeEval.evalAst(a, subs)
+        }[ast.operator](ast.argument);
+        return result;
+    },
+    evalArrayExpression (ast, subs) {
+        return ast.elements.map((el) => SafeEval.evalAst(el, subs));
+    },
+    evalCallExpression (ast, subs) {
+        const args = ast.arguments.map((arg) => SafeEval.evalAst(arg, subs));
+        const func = SafeEval.evalAst(ast.callee, subs);
+        // if (func === Function) {
+        //     throw new Error('Function constructor is disabled');
+        // }
+        return func(...args);
+    },
+    evalAssignmentExpression (ast, subs) {
+        if (ast.left.type !== 'Identifier') {
+            throw SyntaxError('Invalid left-hand side in assignment');
+        }
+        const id = ast.left.name;
+        const value = SafeEval.evalAst(ast.right, subs);
+        subs[id] = value;
+        return subs[id];
+    }
+};
+
+/**
+ * A replacement for NodeJS' VM.Script which is also {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP | Content Security Policy} friendly.
+ */
+class SafeScript {
+    /**
+     * @param {string} expr Expression to evaluate
+     */
+    constructor (expr) {
+        this.code = expr;
+        this.ast = jsep(this.code);
+    }
+
+    /**
+     * @param {object} context Object whose items will be added
+     *   to evaluation
+     * @returns {EvaluatedResult} Result of evaluated code
+     */
+    runInNewContext (context) {
+        // `Object.create(null)` creates a prototypeless object
+        const keyMap = Object.assign(Object.create(null), context);
+        return SafeEval.evalAst(this.ast, keyMap);
+    }
+}
+
+export {SafeScript};

package/dist/node_modules/jsonpath-plus/src/jsonpath-browser.js

@@ -0,0 +1,102 @@
+import {JSONPath} from './jsonpath.js';
+
+/**
+ * @typedef {any} ContextItem
+ */
+
+/**
+ * @typedef {any} EvaluatedResult
+ */
+
+/**
+ * @callback ConditionCallback
+ * @param {ContextItem} item
+ * @returns {boolean}
+ */
+
+/**
+ * Copy items out of one array into another.
+ * @param {GenericArray} source Array with items to copy
+ * @param {GenericArray} target Array to which to copy
+ * @param {ConditionCallback} conditionCb Callback passed the current item;
+ *     will move item if evaluates to `true`
+ * @returns {void}
+ */
+const moveToAnotherArray = function (source, target, conditionCb) {
+    const il = source.length;
+    for (let i = 0; i < il; i++) {
+        const item = source[i];
+        if (conditionCb(item)) {
+            // eslint-disable-next-line @stylistic/max-len -- Long
+            // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient
+            target.push(source.splice(i--, 1)[0]);
+        }
+    }
+};
+
+/**
+ * In-browser replacement for NodeJS' VM.Script.
+ */
+class Script {
+    /**
+     * @param {string} expr Expression to evaluate
+     */
+    constructor (expr) {
+        this.code = expr;
+    }
+
+    /**
+     * @param {object} context Object whose items will be added
+     *   to evaluation
+     * @returns {EvaluatedResult} Result of evaluated code
+     */
+    runInNewContext (context) {
+        let expr = this.code;
+        const keys = Object.keys(context);
+        const funcs = [];
+        moveToAnotherArray(keys, funcs, (key) => {
+            return typeof context[key] === 'function';
+        });
+        const values = keys.map((vr) => {
+            return context[vr];
+        });
+
+        const funcString = funcs.reduce((s, func) => {
+            let fString = context[func].toString();
+            if (!(/function/u).test(fString)) {
+                fString = 'function ' + fString;
+            }
+            return 'var ' + func + '=' + fString + ';' + s;
+        }, '');
+
+        expr = funcString + expr;
+
+        // Mitigate http://perfectionkills.com/global-eval-what-are-the-options/#new_function
+        if (!(/(['"])use strict\1/u).test(expr) && !keys.includes('arguments')) {
+            expr = 'var arguments = undefined;' + expr;
+        }
+
+        // Remove last semi so `return` will be inserted before
+        //  the previous one instead, allowing for the return
+        //  of a bare ending expression
+        expr = expr.replace(/;\s*$/u, '');
+
+        // Insert `return`
+        const lastStatementEnd = expr.lastIndexOf(';');
+        const code =
+            lastStatementEnd !== -1
+                ? expr.slice(0, lastStatementEnd + 1) +
+                  ' return ' +
+                  expr.slice(lastStatementEnd + 1)
+                : ' return ' + expr;
+
+        // eslint-disable-next-line no-new-func -- User's choice
+        return new Function(...keys, code)(...values);
+    }
+}
+
+JSONPath.prototype.vm = {
+    Script
+};
+
+export {JSONPath};

package/dist/node_modules/jsonpath-plus/src/jsonpath-node.js

@@ -0,0 +1,8 @@
+import vm from 'vm';
+import {JSONPath} from './jsonpath.js';
+
+JSONPath.prototype.vm = vm;
+
+export {
+    JSONPath
+};

package/dist/node_modules/jsonpath-plus/src/jsonpath.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Declaration for https://github.com/s3u/JSONPath
+ */
+declare module 'jsonpath-plus' {
+  type JSONPathCallback = (
+      payload: any, payloadType: any, fullPayload: any
+  ) => any
+
+  type JSONPathOtherTypeCallback = (...args: any[]) => void
+
+  class EvalClass {
+    constructor(code: string);
+    runInNewContext(context: object): any;
+  }
+
+  interface JSONPathOptions {
+    /**
+     * The JSONPath expression as a (normalized or unnormalized) string or
+     *   array.
+     */
+    path: string | any[]
+    /**
+     * The JSON object to evaluate (whether of null, boolean, number,
+     *   string, object, or array type).
+     */
+    json: null | boolean | number | string | object | any[]
+    /**
+     * If this is supplied as false, one may call the evaluate method
+     *  manually.
+     *
+     * @default true
+     */
+    autostart?: true | boolean
+    /**
+     * Whether the returned array of results will be flattened to a
+     *   single dimension array.
+     *
+     * @default false
+     */
+    flatten?: false | boolean
+    /**
+     * Can be case-insensitive form of "value", "path", "pointer", "parent",
+     *   or "parentProperty" to determine respectively whether to return
+     *   results as the values of the found items, as their absolute paths,
+     *   as JSON Pointers to the absolute paths, as their parent objects,
+     *   or as their parent's property name.
+     *
+     * If set to "all", all of these types will be returned on an object with
+     *   the type as key name.
+     *
+     * @default 'value'
+     */
+    resultType?:
+        'value' | 'path' | 'pointer' | 'parent' | 'parentProperty' | 'all'
+
+    /**
+     * Key-value map of variables to be available to code evaluations such
+     *   as filtering expressions.
+     * (Note that the current path and value will also be available to those
+     *   expressions; see the Syntax section for details.)
+     */
+    sandbox?: Map<string, any>
+    /**
+     * Whether or not to wrap the results in an array.
+     *
+     * If wrap is set to false, and no results are found, undefined will be
+     *   returned (as opposed to an empty array when wrap is set to true).
+     *
+     * If wrap is set to false and a single non-array result is found, that
+     *   result will be the only item returned (not within an array).
+     *
+     * An array will still be returned if multiple results are found, however.
+     * To avoid ambiguities (in the case where it is necessary to distinguish
+     * between a result which is a failure and one which is an empty array),
+     * it is recommended to switch the default to false.
+     *
+     * @default true
+     */
+    wrap?: true | boolean
+    /**
+     * Script evaluation method.
+     *
+     * `safe`: In browser, it will use a minimal scripting engine which doesn't
+     * use `eval` or `Function` and satisfies Content Security Policy. In NodeJS,
+     * it has no effect and is equivalent to native as scripting is safe there.
+     *
+     * `native`: uses the native scripting capabilities. i.e. unsafe `eval` or
+     * `Function` in browser and `vm.Script` in nodejs.
+     *
+     * `true`: Same as 'safe'
+     *
+     * `false`: Disable Javascript executions in path string. Same as `preventEval: true` in previous versions.
+     *
+     * `callback [ (code, context) => value]`: A custom implementation which is called
+     * with `code` and `context` as arguments to return the evaluated value.
+     *
+     * `class`: A class similar to nodejs vm.Script. It will be created with `code` as constructor argument and the code
+     * is evaluated by calling `runInNewContext` with `context`.
+     *
+     * @default 'safe'
+     */
+    eval?: 'safe' | 'native' | boolean | ((code: string, context: object) => any) | typeof EvalClass
+    /**
+     * Ignore errors while evaluating JSONPath expression.
+     *
+     * `true`: Don't break entire search if an error occurs while evaluating JSONPath expression on one key/value pair.
+     *
+     * `false`: Break entire search if an error occurs while evaluating JSONPath expression on one key/value pair.
+     *
+     * @default false
+     *
+     */
+    ignoreEvalErrors?: boolean
+    /**
+     * In the event that a query could be made to return the root node,
+     * this allows the parent of that root node to be returned within results.
+     *
+     * @default null
+     */
+    parent?: null | any
+    /**
+     * In the event that a query could be made to return the root node,
+     * this allows the parentProperty of that root node to be returned within
+     * results.
+     *
+     * @default null
+     */
+    parentProperty?: null | any
+    /**
+     * If supplied, a callback will be called immediately upon retrieval of
+     * an end point value.
+     *
+     * The three arguments supplied will be the value of the payload
+     * (according to `resultType`), the type of the payload (whether it is
+     * a normal "value" or a "property" name), and a full payload object
+     * (with all `resultType`s).
+     *
+     * @default undefined
+     */
+    callback?: undefined | JSONPathCallback
+    /**
+     * In the current absence of JSON Schema support,
+     * one can determine types beyond the built-in types by adding the
+     * perator `@other()` at the end of one's query.
+     *
+     * If such a path is encountered, the `otherTypeCallback` will be invoked
+     * with the value of the item, its path, its parent, and its parent's
+     * property name, and it should return a boolean indicating whether the
+     * supplied value belongs to the "other" type or not (or it may handle
+     * transformations and return false).
+     *
+     * @default undefined
+     *   <A function that throws an error when `@other()` is encountered>
+     */
+    otherTypeCallback?: undefined | JSONPathOtherTypeCallback
+  }
+
+  interface JSONPathOptionsAutoStart extends JSONPathOptions {
+    autostart: false
+  }
+
+  interface JSONPathCallable {
+    <T = any>(options: JSONPathOptionsAutoStart): JSONPathClass
+    <T = any>(options: JSONPathOptions): T
+
+    <T = any>(
+        path: JSONPathOptions['path'],
+        json: JSONPathOptions['json'],
+        callback: JSONPathOptions['callback'],
+        otherTypeCallback: JSONPathOptions['otherTypeCallback']
+    ): T
+  }
+
+  class JSONPathClass {
+    /**
+     * Exposes the cache object for those who wish to preserve and reuse
+     *   it for optimization purposes.
+     */
+    cache: any
+
+    /**
+     * Accepts a normalized or unnormalized path as string and
+     * converts to an array: for example,
+     * `['$', 'aProperty', 'anotherProperty']`.
+     */
+    toPathArray(path: string): string[]
+
+    /**
+     * Accepts a path array and converts to a normalized path string.
+     * The string will be in a form like:
+     *   `$['aProperty']['anotherProperty][0]`.
+     * The JSONPath terminal constructions `~` and `^` and type operators
+     *   like `@string()` are silently stripped.
+     */
+    toPathString(path: string[]): string
+
+    /**
+     * Accepts a path array and converts to a JSON Pointer.
+     *
+     * The string will be in a form like: `/aProperty/anotherProperty/0`
+     * (with any `~` and `/` internal characters escaped as per the JSON
+     * Pointer spec).
+     *
+     * The JSONPath terminal constructions `~` and `^` and type operators
+     *   like `@string()` are silently stripped.
+     */
+    toPointer(path: string[]): any
+
+    evaluate(
+        path: JSONPathOptions['path'],
+        json: JSONPathOptions['json'],
+        callback: JSONPathOptions['callback'],
+        otherTypeCallback: JSONPathOptions['otherTypeCallback']
+    ): any
+    evaluate(options: {
+        path: JSONPathOptions['path'],
+        json: JSONPathOptions['json'],
+        callback: JSONPathOptions['callback'],
+        otherTypeCallback: JSONPathOptions['otherTypeCallback']
+    }): any
+  }
+
+  type JSONPathType = JSONPathCallable & JSONPathClass
+
+  export const JSONPath: JSONPathType
+}