xmlui 0.4.0

package/dist/scripts/src/components-core/loader/Loader.js

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loader = Loader;
+const react_1 = require("react");
+const react_query_1 = require("@tanstack/react-query");
+const extractParam_1 = require("@components-core/utils/extractParam");
+const immer_1 = require("immer");
+const AppContext_1 = require("@components-core/AppContext");
+const hooks_1 = require("@components-core/utils/hooks");
+function Loader({ state, loader, loaderFn, queryId, pollIntervalInSeconds, registerComponentApi, onLoaded, loaderLoaded, loaderInProgressChanged, loaderError, }) {
+    const { uid } = loader;
+    const appContext = (0, AppContext_1.useAppContext)();
+    // --- Rely on react-query to decide when data fetching should use the cache or when is should fetch the data from
+    // --- its data source.
+    // --- data: The data obtained by the query
+    // --- status: Query execution status
+    // --- error: Error information about the current query error (in "error" state)
+    // --- refetch: The function that can be used to re-fetch the data (because of data/state changes)
+    const { data, status, isFetching, error, refetch } = (0, react_query_1.useQuery)({
+        queryKey: queryId ? queryId : [uid, (0, extractParam_1.extractParam)(state, loader.props, appContext)],
+        queryFn: (_a) => __awaiter(this, [_a], void 0, function* ({ signal }) {
+            const newVar = yield loaderFn(signal);
+            if (newVar === undefined) {
+                return null;
+            }
+            return newVar;
+        }),
+        retry: false
+    });
+    (0, react_1.useEffect)(() => {
+        let intervalId;
+        if (pollIntervalInSeconds) {
+            intervalId = setInterval(() => {
+                refetch();
+            }, pollIntervalInSeconds * 1000);
+        }
+        return () => {
+            if (intervalId) {
+                clearInterval(intervalId);
+            }
+        };
+    }, [pollIntervalInSeconds, refetch]);
+    const prevData = (0, hooks_1.usePrevious)(data);
+    const prevError = (0, hooks_1.usePrevious)(error);
+    (0, react_1.useLayoutEffect)(() => {
+        loaderInProgressChanged(isFetching);
+    }, [isFetching, loaderInProgressChanged]);
+    // --- Respond to the state changes whenever the uid of the loader instance, the data, the dispatcher,
+    // --- or the data query status changes.
+    (0, react_1.useLayoutEffect)(() => {
+        if (status === "success" && data !== prevData) {
+            loaderLoaded(data);
+            onLoaded === null || onLoaded === void 0 ? void 0 : onLoaded(data);
+        }
+        else if (status === "error" && error !== prevError) {
+            loaderError(error);
+        }
+    }, [appContext, data, error, loaderError, loaderLoaded, onLoaded, prevData, prevError, status]);
+    (0, react_1.useLayoutEffect)(() => {
+        return () => {
+            loaderLoaded(undefined);
+        };
+    }, [loaderLoaded, uid]);
+    (0, react_1.useEffect)(() => {
+        registerComponentApi === null || registerComponentApi === void 0 ? void 0 : registerComponentApi({
+            refetch,
+            update: (updater) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const oldData = (_a = appContext.queryClient) === null || _a === void 0 ? void 0 : _a.getQueryData(queryId);
+                if (!oldData) {
+                    //loader not loaded yet, we skip the update
+                    return;
+                }
+                const draft = (0, immer_1.createDraft)(oldData);
+                const ret = yield updater(draft); //if it returns a value, we take it as the new data
+                const newData = ret || (0, immer_1.finishDraft)(draft);
+                if (oldData.length !== newData.length) {
+                    throw new Error("Use this method for update only. If you want to add or delete, call the addItem/deleteItem method.");
+                }
+                // console.log("BEFORE: ", appContext.queryClient?.getQueryData(queryId!));
+                (_b = appContext.queryClient) === null || _b === void 0 ? void 0 : _b.setQueryData(queryId, newData);
+                // console.log("AFTER: ", appContext.queryClient?.getQueryData(queryId!));
+            }),
+            addItem: (element, indexToInsert) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const oldData = (_a = appContext.queryClient) === null || _a === void 0 ? void 0 : _a.getQueryData(queryId);
+                const draft = (0, immer_1.createDraft)(oldData);
+                if (indexToInsert === undefined) {
+                    draft.push(element);
+                }
+                else {
+                    draft.splice(indexToInsert, 0, element);
+                }
+                const newData = (0, immer_1.finishDraft)(draft);
+                (_b = appContext.queryClient) === null || _b === void 0 ? void 0 : _b.setQueryData(queryId, newData);
+            }),
+            getItems: () => __awaiter(this, void 0, void 0, function* () {
+                return data;
+            }),
+            deleteItem: (element) => __awaiter(this, void 0, void 0, function* () {
+                throw new Error("not implemented");
+            }),
+        });
+    }, [appContext.queryClient, data, loader.uid, queryId, refetch, registerComponentApi]);
+    return null;
+}

package/dist/scripts/src/components-core/loader/MockLoaderRenderer.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockLoaderRenderer = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const Loader_1 = require("./Loader");
+const misc_1 = require("@components-core/utils/misc");
+const extractParam_1 = require("@components-core/utils/extractParam");
+const renderers_1 = require("@components-core/renderers");
+const AppContext_1 = require("@components-core/AppContext");
+function ApiLoader({ loader, loaderInProgressChanged, loaderError, loaderLoaded, state }) {
+    const appContext = (0, AppContext_1.useAppContext)();
+    const waitTime = (0, extractParam_1.extractParam)(state, loader.props.waitTime, appContext);
+    const responseObj = (0, extractParam_1.extractParam)(state, loader.props.data, appContext);
+    const doLoad = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        waitTime && (yield (0, misc_1.asyncWait)(waitTime));
+        return responseObj;
+    }), [responseObj, waitTime]);
+    return ((0, jsx_runtime_1.jsx)(Loader_1.Loader, { state: state, loader: loader, loaderInProgressChanged: loaderInProgressChanged, loaderLoaded: loaderLoaded, loaderError: loaderError, loaderFn: doLoad }));
+}
+exports.mockLoaderRenderer = (0, renderers_1.createLoaderRenderer)("MockLoader", ({ loader, state, loaderInProgressChanged, loaderLoaded, loaderError }) => {
+    return ((0, jsx_runtime_1.jsx)(ApiLoader, { loader: loader, state: state, loaderInProgressChanged: loaderInProgressChanged, loaderLoaded: loaderLoaded, loaderError: loaderError }));
+});

package/dist/scripts/src/components-core/loader/PageableLoader.js

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageableLoader = PageableLoader;
+const react_1 = require("react");
+const react_query_1 = require("@tanstack/react-query");
+const immer_1 = __importStar(require("immer"));
+const extractParam_1 = require("@components-core/utils/extractParam");
+const AppContext_1 = require("@components-core/AppContext");
+const hooks_1 = require("@components-core/utils/hooks");
+function PageableLoader({ state, loader, loaderFn, queryId, direction = "BACKWARD", registerComponentApi, pollIntervalInSeconds, onLoaded, loaderInProgressChanged, loaderLoaded, loaderError, }) {
+    const { uid } = loader;
+    const appContext = (0, AppContext_1.useAppContext)();
+    const queryKey = (0, react_1.useMemo)(() => (queryId ? queryId : [uid, (0, extractParam_1.extractParam)(state, loader.props, appContext)]), [appContext, loader.props, queryId, state, uid]);
+    const thizRef = (0, react_1.useRef)(queryKey);
+    const { data, status, error, hasNextPage, isFetchingNextPage, hasPreviousPage, isFetchingPreviousPage, isFetching, refetch, fetchPreviousPage, fetchNextPage, } = (0, react_query_1.useInfiniteQuery)({
+        queryKey,
+        queryFn: (_a) => __awaiter(this, [_a], void 0, function* ({ signal, pageParam }) {
+            // console.log("FETCHING PAGE: ", pageParam);
+            const { result, prevPageParam, nextPageParam } = yield loaderFn(signal, pageParam);
+            // console.log("fetched PAGE: ", { result, prevPageParam, nextPageParam });
+            return { result, prevPageParam, nextPageParam };
+        }),
+        getPreviousPageParam: direction === "BACKWARD" || direction === "BIDIRECTIONAL"
+            ? (firstPage, a) => {
+                if (!firstPage.prevPageParam) {
+                    return undefined;
+                }
+                // console.log("getting previous page param", { firstPage, a });
+                return {
+                    prevPageParam: firstPage.prevPageParam,
+                };
+            }
+            : undefined,
+        getNextPageParam: direction === "FORWARD" || direction === "BIDIRECTIONAL"
+            ? (lastPage) => {
+                if (!lastPage.nextPageParam) {
+                    return undefined;
+                }
+                return {
+                    nextPageParam: lastPage.nextPageParam,
+                };
+            }
+            : undefined,
+    });
+    //TODO revisit
+    // //we clear all the pages, except the last one (it's suitable for the chat app, but for the other direction we'll have to leave the first page)
+    // // otherwise it'll keep it in the cache, and refetch all the pages when you come back
+    // //  see more here: https://stackoverflow.com/questions/71286123/reactquery-useinfinitequery-refetching-issue
+    // //  and here: https://tanstack.com/query/latest/docs/react/guides/infinite-queries?from=reactQueryV3&original=https%3A%2F%2Ftanstack.com%2Fquery%2Fv3%2Fdocs%2Fguides%2Finfinite-queries#what-happens-when-an-infinite-query-needs-to-be-refetched
+    (0, react_1.useEffect)(() => {
+        const queryKey = thizRef.current;
+        return () => {
+            var _a, _b;
+            (_a = appContext.queryClient) === null || _a === void 0 ? void 0 : _a.cancelQueries(queryKey);
+            (_b = appContext.queryClient) === null || _b === void 0 ? void 0 : _b.setQueryData(queryKey, (old) => {
+                if (!old) {
+                    return old;
+                }
+                return (0, immer_1.default)(old, (draft) => {
+                    draft.pages = draft.pages.length ? [draft.pages[draft.pages.length - 1]] : [];
+                    // draft.pageParams = draft.pageParams.length ? [draft.pageParams[draft.pageParams.length - 1]] : [];
+                    draft.pageParams = [];
+                });
+            });
+            loaderLoaded(undefined, undefined);
+        };
+    }, [appContext.queryClient, loaderLoaded, uid]);
+    const flatData = (0, react_1.useMemo)(() => {
+        if (!data) {
+            return [];
+        }
+        return data.pages.flatMap((d) => d.result);
+    }, [data]);
+    const prevData = (0, hooks_1.usePrevious)(data);
+    const prevError = (0, hooks_1.usePrevious)(error);
+    (0, react_1.useLayoutEffect)(() => {
+        loaderInProgressChanged(isFetching); //TODO isFetchingPrevPage / nextPage
+    }, [isFetching, loaderInProgressChanged]);
+    const pageInfo = (0, react_1.useMemo)(() => {
+        return {
+            hasPrevPage: hasPreviousPage,
+            isFetchingPrevPage: isFetchingPreviousPage,
+            hasNextPage,
+            isFetchingNextPage,
+        };
+    }, [hasNextPage, hasPreviousPage, isFetchingNextPage, isFetchingPreviousPage]);
+    const prevPageInfo = (0, hooks_1.usePrevious)(pageInfo);
+    (0, react_1.useLayoutEffect)(() => {
+        // console.log("data changed", {
+        //   status,
+        //   flatData,
+        //   pageInfo,
+        // });
+        if (status === "success" && (prevData !== data || prevPageInfo !== pageInfo)) {
+            loaderLoaded(flatData, pageInfo);
+            onLoaded === null || onLoaded === void 0 ? void 0 : onLoaded(flatData);
+        }
+        else if (status === "error" && prevError !== error) {
+            loaderError(error);
+        }
+    }, [
+        appContext,
+        data,
+        error,
+        flatData,
+        loaderError,
+        loaderLoaded,
+        onLoaded,
+        pageInfo,
+        prevData,
+        prevError,
+        prevPageInfo,
+        status,
+    ]);
+    (0, react_1.useEffect)(() => {
+        let intervalId;
+        if (pollIntervalInSeconds) {
+            intervalId = setInterval(() => {
+                refetch();
+            }, pollIntervalInSeconds * 1000);
+        }
+        return () => {
+            if (intervalId) {
+                clearInterval(intervalId);
+            }
+        };
+    }, [pollIntervalInSeconds, refetch]);
+    const fetchPrevPage = (0, react_1.useCallback)(() => {
+        return fetchPreviousPage();
+    }, [fetchPreviousPage]);
+    const stableFetchNextPage = (0, react_1.useCallback)(() => {
+        return fetchNextPage();
+    }, [fetchNextPage]);
+    (0, react_1.useEffect)(() => {
+        registerComponentApi({
+            fetchPrevPage,
+            fetchNextPage: stableFetchNextPage,
+            refetch,
+            update: (updater) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const oldData = (_a = appContext.queryClient) === null || _a === void 0 ? void 0 : _a.getQueryData(queryId);
+                if (!oldData) {
+                    //loader not loaded yet, we skip the update
+                    return;
+                }
+                const originalFlatItems = oldData.pages.flatMap((d) => d.result);
+                const draft = (0, immer_1.createDraft)(oldData);
+                const flatItems = [];
+                for (let i = 0; i < draft.pages.length; i++) {
+                    const page = draft.pages[i];
+                    yield updater(page.result);
+                    flatItems.push(...page.result);
+                }
+                if (flatItems.length !== originalFlatItems.length) {
+                    throw new Error("Use this method for update only. If you want to add or delete, call the addItem/deleteItem method.");
+                }
+                const newData = (0, immer_1.finishDraft)(draft);
+                // console.log("BEFORE: ", appContext.queryClient?.getQueryData(queryId!));
+                (_b = appContext.queryClient) === null || _b === void 0 ? void 0 : _b.setQueryData(queryId, newData);
+                // console.log("AFTER: ", appContext.queryClient?.getQueryData(queryId!));
+            }),
+            addItem: (element, indexToInsert) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const oldData = (_a = appContext.queryClient) === null || _a === void 0 ? void 0 : _a.getQueryData(queryId);
+                const draft = (0, immer_1.createDraft)(oldData);
+                if (indexToInsert === undefined) {
+                    draft.pages[draft.pages.length - 1].result.push(element);
+                }
+                else {
+                    throw new Error("not implemented");
+                    // TODO is should be something like this
+                    // //find the pageIndex and itemIndex in that page
+                    // let pageIndex = -1;
+                    // let itemIndex = -1;
+                    // let i = 0;
+                    // oldData.pages.forEach((page, index)=>{
+                    //   i += page.result.length;
+                    //   if(i >= indexToInsert){
+                    //     pageIndex = index;
+                    //     itemIndex = i - indexToInsert;
+                    //     return;
+                    //   }
+                    // });
+                    // draft.pages[pageIndex].result.splice(itemIndex, 0, element);
+                }
+                const newData = (0, immer_1.finishDraft)(draft);
+                (_b = appContext.queryClient) === null || _b === void 0 ? void 0 : _b.setQueryData(queryId, newData);
+            }),
+            getItems: () => {
+                return flatData;
+            },
+            deleteItem: (element) => __awaiter(this, void 0, void 0, function* () {
+                throw new Error("not implemented");
+            }),
+        });
+    }, [
+        appContext.queryClient,
+        fetchPrevPage,
+        flatData,
+        loader.uid,
+        queryId,
+        queryKey,
+        refetch,
+        registerComponentApi,
+        stableFetchNextPage,
+    ]);
+    return null;
+}

package/dist/scripts/src/components-core/renderers.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComponentRenderer = createComponentRenderer;
+exports.createPropHolderComponent = createPropHolderComponent;
+exports.createLoaderRenderer = createLoaderRenderer;
+/**
+ * This helper function creates a component renderer definition from its arguments.
+ * @param type The unique identifier of the component definition
+ * @param renderer The function that renders the component definition into a React node
+ * @param hints Optional hints to help fix the rendering errors coming from invalid component property definitions
+ * @returns The view renderer definition composed of the arguments
+ */
+function createComponentRenderer(type, renderer, hints) {
+    return {
+        type,
+        renderer,
+        metadata: hints,
+    };
+}
+/**
+ * Create a non-visual component used for encapsulating property values
+ * @param type Component type
+ * @param metadata Component metadata
+ */
+function createPropHolderComponent(type, metadata) {
+    return createComponentRenderer(type, () => {
+        throw new Error("Prop holder component, shouldn't render");
+    }, metadata);
+}
+/**
+ * AppEngine uses React as its UI framework to declare and render loaders. This type declares a function that renders
+ * a particular loader definition into its React representation.
+ *
+ * The type parameter of the function refers to the loader definition the function is about to render.
+ * @param type The unique ID of the loader
+ * @param renderer The function that renders the loader
+ * @param hints Optional hints to help fix the rendering errors coming from invalid component property definitions
+ */
+function createLoaderRenderer(type, renderer, hints) {
+    return {
+        type,
+        renderer,
+        hints,
+    };
+}

package/dist/scripts/src/components-core/reportEngineError.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppErrors = getAppErrors;
+exports.resetErrors = resetErrors;
+exports.reportEngineError = reportEngineError;
+const EngineError_1 = require("./EngineError");
+const appErrors = [];
+/**
+ * Get all errors collected during the last run
+ */
+function getAppErrors() {
+    return appErrors;
+}
+/**
+ * Use this function to reset the errors raised by the execution engine
+ */
+function resetErrors() {
+    appErrors.length = 0;
+}
+/**
+ * Use this function to report an error
+ * @param error Error or string describing the error to report
+ * @param errorToThrow The error to throw
+ */
+function reportEngineError(error, errorToThrow) {
+    var _a, _b;
+    // --- Wrap a string into an error
+    if (typeof error === "string") {
+        error = new Error(error);
+    }
+    let helperMessage = "";
+    let colors = [];
+    // --- Error-specific helper messages
+    if (error instanceof EngineError_1.ScriptParseError) {
+        let pos = ((_a = error === null || error === void 0 ? void 0 : error.position) !== null && _a !== void 0 ? _a : 0) - 1;
+        if (error.source) {
+            while (pos < error.source.length - 1 && error.source[pos] === " ") {
+                pos++;
+            }
+            helperMessage += `%c${error.message}%c\n\n`;
+            helperMessage += `${error.source.substring(0, pos)}%c${error.source[pos]}%c${(_b = error.source.substring(pos + 1)) !== null && _b !== void 0 ? _b : ""}\n\n`;
+        }
+        helperMessage += `%cThe error handler associated with the parsed code did not run.%c`;
+        colors = ["color: red", "color: inherited", "color: red", "color: inherited", "color: orange", "color: inherited"];
+    }
+    else if (error instanceof EngineError_1.StatementExecutionError) {
+        helperMessage += `%cError while executing code: ${error.message}%c\n\n${error.source}`;
+        colors = ["color: red", "color: inherited"];
+    }
+    else if (error instanceof EngineError_1.ThrowStatementError) {
+        helperMessage += `A 'throw' statement executed:\n\n%c${error.message}%c\n\n${error.errorObject}`;
+        colors = ["color: red", "color: inherited"];
+    }
+    if (helperMessage) {
+        console.log(helperMessage, ...colors);
+    }
+    appErrors.push({ error, helperMessage, colors });
+    throw errorToThrow !== null && errorToThrow !== void 0 ? errorToThrow : error;
+}

package/dist/scripts/src/components-core/script-runner/BindingTreeEvaluationContext.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancellationToken = void 0;
+exports.createEvalContext = createEvalContext;
+/**
+ * A token that signals the cancellation of an operation
+ */
+class CancellationToken {
+    constructor() {
+        this._cancelled = false;
+    }
+    get cancelled() {
+        return this._cancelled;
+    }
+    cancel() {
+        this._cancelled = true;
+    }
+}
+exports.CancellationToken = CancellationToken;
+/**
+ * Creates an evaluation context with the given parts
+ * @param parts Parts of the evaluation context
+ * @returns New evaluation context
+ */
+function createEvalContext(parts) {
+    return Object.assign({
+        mainThread: {
+            childThreads: [],
+            blocks: [{ vars: {} }],
+            loops: [],
+            breakLabelValue: -1
+        },
+        localContext: {}
+    }, parts);
+}

package/dist/scripts/src/components-core/script-runner/ICustomOperations.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomOperationType = void 0;
+var CustomOperationType;
+(function (CustomOperationType) {
+    CustomOperationType[CustomOperationType["MemberAccess"] = 0] = "MemberAccess";
+    CustomOperationType[CustomOperationType["CalculatedMemberAccess"] = 1] = "CalculatedMemberAccess";
+    CustomOperationType[CustomOperationType["UnaryPlus"] = 2] = "UnaryPlus";
+    CustomOperationType[CustomOperationType["UnaryMinus"] = 3] = "UnaryMinus";
+    CustomOperationType[CustomOperationType["LogicalNot"] = 4] = "LogicalNot";
+    CustomOperationType[CustomOperationType["BitwiseNot"] = 5] = "BitwiseNot";
+    CustomOperationType[CustomOperationType["Multiply"] = 6] = "Multiply";
+    CustomOperationType[CustomOperationType["Divide"] = 7] = "Divide";
+    CustomOperationType[CustomOperationType["Remainder"] = 8] = "Remainder";
+    CustomOperationType[CustomOperationType["Add"] = 9] = "Add";
+    CustomOperationType[CustomOperationType["Subtract"] = 10] = "Subtract";
+    CustomOperationType[CustomOperationType["SignedRightShift"] = 11] = "SignedRightShift";
+    CustomOperationType[CustomOperationType["UnsignedRightShift"] = 12] = "UnsignedRightShift";
+    CustomOperationType[CustomOperationType["LeftShift"] = 13] = "LeftShift";
+    CustomOperationType[CustomOperationType["LessThan"] = 14] = "LessThan";
+    CustomOperationType[CustomOperationType["LessThanOrEqual"] = 15] = "LessThanOrEqual";
+    CustomOperationType[CustomOperationType["GreaterThan"] = 16] = "GreaterThan";
+    CustomOperationType[CustomOperationType["GreaterThanOrEqual"] = 17] = "GreaterThanOrEqual";
+    CustomOperationType[CustomOperationType["Equal"] = 18] = "Equal";
+    CustomOperationType[CustomOperationType["StrictEqual"] = 19] = "StrictEqual";
+    CustomOperationType[CustomOperationType["NotEqual"] = 20] = "NotEqual";
+    CustomOperationType[CustomOperationType["StrictNotEqual"] = 21] = "StrictNotEqual";
+    CustomOperationType[CustomOperationType["BitwiseAnd"] = 22] = "BitwiseAnd";
+    CustomOperationType[CustomOperationType["BitwiseXor"] = 23] = "BitwiseXor";
+    CustomOperationType[CustomOperationType["BitwiseOr"] = 24] = "BitwiseOr";
+    CustomOperationType[CustomOperationType["LogicalAnd"] = 25] = "LogicalAnd";
+    CustomOperationType[CustomOperationType["LogicalOr"] = 26] = "LogicalOr";
+    CustomOperationType[CustomOperationType["NullCoalesce"] = 27] = "NullCoalesce";
+})(CustomOperationType || (exports.CustomOperationType = CustomOperationType = {}));

package/dist/scripts/src/components-core/script-runner/LogicalThread.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/scripts/src/components-core/script-runner/LoopScope.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });