{"version":3,"sources":["function-utils.ts"],"sourcesContent":["import { DX_NOT_TRANSFERABLE } from \"../runtime/constants.ts\";\nimport { LazyPointer } from \"../runtime/lazy-pointer.ts\";\nimport { callWithMetadata, callWithMetadataAsync, getMeta } from \"../utils/caller_metadata.ts\";\nimport { Type } from \"./type.ts\";\n\nconst EXTRACT_USED_VARS = Symbol(\"EXTRACT_USED_VARS\")\n\n/**\n * Used to declare all variables from the parent scope that are used inside the current function.\n * This is required for functions that are transferred to a different context or restored from eternal pointers.\n * \n * Example:\n * \n * ```ts\n * const x = $$(10);\n * \n * const fn = eternal ?? $$(function() {\n *  use (x)\n *  \n *  x.val++\n *  console.log(\"x:\" + x)\n * })\n * ```\n * @param flags - optional flags:\n *  - 'standalone': indicates that the function can run standalone without the datex runtime\n *  - 'silent-errors': suppresses errors when global variables are used\n *  - 'allow-globals': allows transffering global variables in the function. This only works if the variables are never actually transferred between scopes.\n * @param variables \n */\nexport function use(flags: 'standalone'|'silent-errors'|'allow-globals', ...variables: unknown[]): true \n/**\n * Used to declare all variables from the parent scope that are used inside the current function.\n * This is required for functions that are transferred to a different context or restored from eternal pointers.\n * \n * Example:\n * \n * ```ts\n * const x = $$(10);\n * \n * const fn = eternal ?? $$(function() {\n *  use (x)\n *  \n *  x.val++\n *  console.log(\"x:\" + x)\n * })\n * ```\n * @param variables \n */\nexport function use(...variables: unknown[]): true\nexport function use(...variables: unknown[]): true {\n    if (getMeta()?.[EXTRACT_USED_VARS]) {\n        (variables as any)[EXTRACT_USED_VARS] = true;\n        throw variables;\n    }\n    return true;\n}\n\ntype _use = typeof use;\n\n// @ts-ignore global\nglobalThis.use = use;\ndeclare global {\n    const use: _use\n}\n\ntype Flag = 'standalone'|'silent-errors'|'allow-globals'\n\nfunction getUsedVars(fn: (...args:unknown[])=>unknown) {\n    const source = fn.toString();\n    const usedVarsSource = source.match(/^(?:(?:[\\w\\s*])+\\(.*?\\)\\s*{|\\(.*?\\)\\s*=>\\s*[{(]?|.*?\\s*=>\\s*[{(]?)\\s*(?:return *)?use\\s*\\(([\\s\\S]*?)\\)/)?.[1]\n    if (!usedVarsSource) return {};\n\n    const _usedVars = usedVarsSource.split(\",\").map(v=>v.trim()).filter(v=>!!v)\n    const flags:Flag[] = []\n    const usedVars = []\n    let ignoreVarCounter = 0;\n    for (const usedVar of _usedVars) {\n        // TODO: support multiple flags at once\n        if (usedVar == `\"standalone\"` || usedVar == `'standalone'`) flags.push(\"standalone\");\n        else if (usedVar == `\"silent-errors\"` || usedVar == `'silent-errors'`) flags.push(\"silent-errors\");\n        else if (usedVar == `\"allow-globals\"` || usedVar == `'allow-globals'`) flags.push(\"allow-globals\");\n        else if (!usedVar.match(/^[a-zA-Z_$][0-9a-zA-Z_$\\u0080-\\uFFFF]*$/)) {\n            usedVars.push(\"#\" + (ignoreVarCounter++)); // ignore variables start with #\n            // TODO: only warn if not artifact from minification\n            // console.warn(\"Unexpected identifier in 'use' declaration: '\" + usedVar+ \"' - only variable names are allowed.\");\n        }\n        else usedVars.push(usedVar);\n    }\n\n    return {usedVars, flags};\n}\n\n\nexport function getDeclaredExternalVariables(fn: (...args:unknown[])=>unknown) {\n    const {usedVars, flags} = getUsedVars(fn);\n    if (!usedVars) return {vars:{}}\n\n    // call the function with EXTRACT_USED_VARS metadata\n    try {\n        callWithMetadata({[EXTRACT_USED_VARS]: true}, fn as any, [{}]) // TODO: provide call arguments that don't lead to a {}/[] destructuring error\n    }\n    catch (e) {\n        return captureVariables(e, usedVars, flags);\n    }\n    return {vars:{}};\n}\n\nexport async function getDeclaredExternalVariablesAsync(fn: (...args:unknown[])=>Promise<unknown>) {\n    const {usedVars, flags} = getUsedVars(fn);\n    if (!usedVars) return {vars:{}}\n\n    // call the function with EXTRACT_USED_VARS metadata\n    try {\n        await callWithMetadataAsync({[EXTRACT_USED_VARS]: true}, fn as any)\n    }\n    catch (e) {\n        return captureVariables(e, usedVars, flags);\n    }\n    return {vars:{}};\n}\n\n/**\n * Whiteliste for global variables that are allowed to be\n * transferred to a different context per default.\n */\nconst allowedGlobalVars = new Set([\n    \"console\",\n    \"alert\",\n    \"confirm\",\n    \"prompt\",\n])\n\n\nfunction captureVariables(e: unknown, usedVars: string[], flags: Flag[]) {\n    // capture returned variables from use()\n    if (e instanceof Array && (e as any)[EXTRACT_USED_VARS]) {\n        if (flags.length) e.splice(0, flags.length); // remove flags\n        const vars = Object.fromEntries(usedVars.map((v,i)=>[v, e[i]]));\n\n        // for each variable: remove if global variable\n        if (!flags.includes(\"allow-globals\")) {\n            for (const [key, value] of Object.entries(vars)) {\n                if (((key in globalThis && (globalThis as any)[key] === value) || value?.[DX_NOT_TRANSFERABLE] || value instanceof Type) && !allowedGlobalVars.has(key)) {\n                    if (!flags.includes(\"silent-errors\")) {\n                        throw new Error(\"The global variable '\"+key+\"' cannot be transferred to a different context. Remove the 'use(\"+key+\")' declaration.\")\n                    }\n                    delete vars[key];\n                }\n            }\n        }\n        \n        return {vars, flags}\n    }\n    // otherwise, throw normal error\n    else throw e;\n}\n\n\nexport function getSourceWithoutUsingDeclaration(fn: (...args:unknown[])=>unknown) {\n    let fnSource = fn.toString();\n\t// object methods check if 'this' context is component context;\n\tif (!isNormalFunction(fnSource) && !isArrowFunction(fnSource) && isObjectMethod(fnSource)) {\n        if (fnSource.startsWith(\"async\")) fnSource = fnSource.replace(\"async\", \"async function\") \n\t\telse fnSource = \"function \" + fnSource\n\t}\n\n    return fnSource\n        .replace(/(?<=(?:(?:[\\w\\s*])+\\(.*\\)\\s*{|\\(.*\\)\\s*=>\\s*{?|.*\\s*=>\\s*{?)\\s*)(?:return *)?(use\\s*\\((?:[\\s\\S]*?)\\))/, 'true /*$1*/')\n}\n\nconst isObjectMethod = (fnSrc:string) => {\n\treturn !!fnSrc.match(/^(async\\s+)?[^\\s(]+ *(\\(|\\*)/)\n}\nconst isNormalFunction = (fnSrc:string) => {\n\treturn !!fnSrc.match(/^(async\\s+)?function(\\(| |\\*)/)\n}\nconst isArrowFunction = (fnSrc:string) => {\n\treturn !!fnSrc.match(/^(async\\s*)?(\\([^)]*\\)|\\w+)\\s*=>/)\n}\n\nconst isNativeFunction = (fnSrc:string) => {\n    return !!fnSrc.match(/\\{\\s*\\[native code\\]\\s*\\}$/)\n}\n\n\nexport function getSourceWithResolvedPaths(source: string, contextURL: URL) {\n    // TODO: use SWC for source transformation\n    return source  \n        .replace(/import\\([\"']([.]{1,2}\\/[^)]*)[\"']\\)/, (_match, p1) => {\n            const url = new URL(p1, contextURL);\n            return `import('${url}')`\n        })\n}\n\n\nfunction resolveLazyDependencies(deps:Record<string,unknown>, resolve?: ()=>void) {\n    let resolved = false;\n    for (const [key, value] of Object.entries(deps)) {\n        if (value instanceof LazyPointer) value.onLoad((v) => {\n            deps[key] = v;\n            if (!resolved && resolve && !hasUnresolvedLazyDependencies(deps)) {\n                resolved = true;\n                resolve();\n            }\n        });\n    }\n}\n\nfunction assertLazyDependenciesResolved(deps:Record<string,unknown>) {\n    for (const [key, value] of Object.entries(deps)) {\n        // TODO non js-Function specific error\n        if (value instanceof LazyPointer) throw new Error(\"Cannot call <js:Function>, dependency variable '\"+key+\"' is not yet initialized\")\n    }\n}\n\nexport function hasUnresolvedLazyDependencies(deps:Record<string,unknown>) {\n    for (const value of Object.values(deps)) {\n        if (value instanceof LazyPointer) return true;\n    }\n    return false;\n}\n\n/**\n * Create a new function from JS source code with injected dependency variables\n * Also resolves LazyPointer dependencies\n * @param source \n * @param dependencies \n * @returns \n */\nexport function createFunctionWithDependencyInjectionsResolveLazyPointers(source: string, dependencies: Record<string, unknown>, allowValueMutations = true): {intermediateFn: ((...args:unknown[]) => unknown), lazyResolved: Promise<void>} {\n    let fn: Function|undefined;\n\n    const {promise: lazyResolved, resolve} = Promise.withResolvers<void>()\n\n    const intermediateFn = (...args:any[]) => {\n        if (!fn) {\n            assertLazyDependenciesResolved(dependencies);\n            fn = createFunctionWithDependencyInjections(source, dependencies, allowValueMutations)\n        }\n        return fn(...args)\n    }\n\n    if (!hasUnresolvedLazyDependencies(dependencies)) resolve()\n    else resolveLazyDependencies(dependencies, resolve);\n    return {intermediateFn, lazyResolved};\n}\n\n/**\n * Create a new function from JS source code with injected dependency variables\n * @param source \n * @param dependencies \n * @returns \n * @deprecated use createFunctionWithDependencyInjectionsResolveLazyPointers\n */\nexport function createFunctionWithDependencyInjections(source: string, dependencies: Record<string, unknown>, allowValueMutations = true): ((...args:unknown[]) => unknown) {\n    const hasThis = Object.keys(dependencies).includes('this');\n    let ignoreVarCounter = 0;\n    const renamedVars = Object.keys(dependencies).filter(d => d!=='this').map(k => k.startsWith(\"#\") ? '_ignore_'+(ignoreVarCounter++) : '_'+k);\n    const varMapping = renamedVars.filter(v=>!v.startsWith(\"_ignore_\")).map(k=>`const ${k.slice(1)} = ${allowValueMutations ? 'createStaticObject' : ''}(${k});`).join(\"\\n\");\n    const isArrow = isArrowFunction(source);\n\n    if (isNativeFunction(source)) {\n        throw new Error(\"Cannot create transferable function from native function: \" + source);\n    }\n\n    const createStaticFn = `\n    const freezedObjects = new WeakSet();\n    function createStaticObject(val) {\n        if (val && typeof val == \"object\" && !globalThis.Datex?.ReactiveValue.isRef(val)) {\n            if (freezedObjects.has(val)) return val;\n            freezedObjects.add(val);    \n            for (const key of Object.keys(val)) val[key] = createStaticObject(val[key]);\n            Object.freeze(val);\n        }\n        return val;\n    };`\n\n    const creatorSource = `\"use strict\";\\n${(varMapping&&allowValueMutations)?createStaticFn:''}\\n${varMapping};\\nreturn (${source})`;\n\n    try {\n        let creatorFn = new Function(...renamedVars, creatorSource)\n        // arrow function without own this context - bind creatorFn to this\n        if (hasThis && isArrow) creatorFn = creatorFn.bind(dependencies['this']) \n        const fn = creatorFn(...Object.entries(dependencies).filter(([d]) => d!=='this').map(([_,v]) => v));\n        // normal function - bind directly to this\n        if (hasThis && !isArrow) return fn.bind(dependencies['this'])\n        else return fn;\n    }\n    catch (e) {\n        console.error(creatorSource)\n        throw e;\n    }\n    \n}\n\nexport class ExtensibleFunction {\n    constructor(f?:globalThis.Function) {\n        if (f) return Object.setPrototypeOf(f, new.target.prototype);\n    }\n}\n\nexport interface Callable<args extends any[], return_type> {\n    (...args:args): return_type;\n}"],"names":["DX_NOT_TRANSFERABLE","LazyPointer","callWithMetadata","callWithMetadataAsync","getMeta","Type","EXTRACT_USED_VARS","Symbol","use","variables","getUsedVars","fn","source","toString","usedVarsSource","match","_usedVars","split","map","v","trim","filter","flags","usedVars","ignoreVarCounter","usedVar","push","globalThis","getDeclaredExternalVariables","vars","e","captureVariables","getDeclaredExternalVariablesAsync","allowedGlobalVars","Set","Array","length","splice","Object","fromEntries","i","includes","key","value","entries","has","Error","getSourceWithoutUsingDeclaration","fnSource","isNormalFunction","isArrowFunction","isObjectMethod","startsWith","replace","fnSrc","isNativeFunction","getSourceWithResolvedPaths","contextURL","_match","p1","url","URL","resolveLazyDependencies","deps","resolve","resolved","onLoad","hasUnresolvedLazyDependencies","assertLazyDependenciesResolved","values","createFunctionWithDependencyInjectionsResolveLazyPointers","dependencies","allowValueMutations","promise","lazyResolved","Promise","withResolvers","intermediateFn","args","createFunctionWithDependencyInjections","hasThis","keys","renamedVars","d","k","varMapping","slice","join","isArrow","createStaticFn","creatorSource","creatorFn","Function","bind","_","console","error","ExtensibleFunction","constructor","f","setPrototypeOf","prototype"],"mappings":"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","sourceRoot":"/lib/datex-core-js-legacy-0.3.15/types/","file":"function-utils.ts"}