{"version":3,"sources":["functions.ts"],"sourcesContent":["/**\n * This file contains utility funtions to transform pointer to other pointers.\n * The resulting pointers are automatically updated when the input pointers are updated\n */\n\n\nimport { AsyncTransformFunction, INSERT_MARK, MaybeObjectRef, MinimalJSRef, Pointer, ReactiveValue, RefLike, RefOrValue, SmartTransformFunction, SmartTransformOptions, TransformFunction, TransformFunctionInputs, logger } from \"./datex_all.ts\";\nimport { Datex } from \"./mod.ts\";\nimport { PointerError } from \"./types/errors.ts\";\nimport { IterableHandler } from \"./utils/iterable-handler.ts\";\nimport { AsyncSmartTransformFunction, MinimalJSRefWithIndirectRef, RestrictSameType } from \"./runtime/pointers.ts\";\nimport { handleError } from \"./utils/error-handling.ts\";\nimport { KnownError } from \"./utils/error-handling.ts\";\n\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * In contrast to the `transform` function, dependency references are automatically detected, they don't need to be explicitly specified.\n * ```ts\n * const x = $$(10);\n * const y = always (() => x * 2);\n * y.val // 20\n * x.val = 5;\n * y.val // 10\n * ```\n */\nexport function always<T>(transform:SmartTransformFunction<T>, options?: SmartTransformOptions): MinimalJSRefWithIndirectRef<T> // return signature from Value.collapseValue(Pointer.smartTransform())\n\n\n// only works with JUSIX compilation\nexport function always<const T>(value:T, options?: SmartTransformOptions): MinimalJSRef<T>\n\n/**\n * Shortcut for datex `always (...)`\n * @param script \n * @param vars \n */\nexport function always<T=unknown>(script:TemplateStringsArray, ...vars:any[]): Promise<MinimalJSRefWithIndirectRef<T>>\nexport function always(scriptOrJSTransform:TemplateStringsArray|SmartTransformFunction<any>, ...vars:any[]) {\n    // js function\n    if (typeof scriptOrJSTransform == \"function\") {\n        const options: SmartTransformOptions|undefined = typeof vars[0] == \"object\" ? vars[0] : undefined;\n        // make sure handler is not an async function\n        if (scriptOrJSTransform.constructor.name == \"AsyncFunction\" && !options?._allowAsync) {\n            throw new Error(\"Async functions are not allowed as always transforms\")\n        }\n        const ptr = Pointer.createSmartTransform(scriptOrJSTransform, undefined, undefined, undefined, options);\n        if (options?._allowAsync && !ptr.value_initialized && ptr.waiting_for_always_promise) {\n            return ptr.waiting_for_always_promise.then(()=>collapseTransformPointer(ptr, options?._collapseStatic, options?._returnWrapper, options?._allowAnyType));\n        }\n        if (!ptr.value_initialized && ptr.waiting_for_always_promise) {\n            throw new PointerError(`Promises cannot be returned from always transforms - use 'asyncAlways' instead`);\n        }\n        else {\n            return collapseTransformPointer(ptr, options?._collapseStatic, options?._returnWrapper, options?._allowAnyType);\n        }\n    }\n    // datex script\n    else if (scriptOrJSTransform.raw instanceof Array) {\n        return (async ()=>collapseTransformPointer(await datex(`always (${scriptOrJSTransform.raw.join(INSERT_MARK)})`, vars)))()\n    }\n    else {\n        handleError(new KnownError(\"You called 'always' with invalid arguments. It seems like you are not using Deno for UIX.\", [\n            \"Install Deno for UIX, see https://docs.unyt.org/manual/uix/getting-started#install-deno\",\n            \"Call 'always' with a function: always(() => ...)\"\n        ]))\n    }\n}\n\n\nfunction collapseTransformPointer(ptr: Pointer, collapseStatic = false, alwaysReturnWrapper = false, _allowAnyType = false) {\n    // collapse if transform function is static\n    const collapse = collapseStatic && ptr.isStaticTransform;\n\n    if (_allowAnyType) {\n        ptr.allowAnyType(true);\n    }\n    \n    if (alwaysReturnWrapper && !collapse) {\n        return ptr;\n    }\n    \n    const val = ReactiveValue.collapseValue(ptr, false, collapse);\n\n    if (collapse) ptr.delete();\n    // TODO: deproxify static non-primitive objects to garbage-collect pointer and associated data\n    return val;\n}\n\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * In contrast to the always function, this function can return a Promise\n * ```ts\n * const x = $$(42);\n * const y = await asyncAlways (() => complexCalculation(x.val * 10));\n * \n * async function complexCalculation(input: number) {\n *    const res = await ...// some async operation\n *    return res\n * }\n * ```\n */\nexport async function asyncAlways<T>(transform:AsyncSmartTransformFunction<T>, options?: SmartTransformOptions): Promise<MinimalJSRefWithIndirectRef<T>> { // return signature from Value.collapseValue(Pointer.smartTransform())\n    const ptr = Pointer.createSmartTransform(transform, undefined, undefined, undefined, options);\n    if (!ptr.value_initialized && ptr.waiting_for_always_promise) {\n        await ptr.waiting_for_always_promise;\n    }\n    else {\n        logger.warn(\"asyncAlways: transform function did not return a Promise, you should use 'always' instead\")\n    }\n    return ReactiveValue.collapseValue(ptr) as MinimalJSRef<T>\n}\n\n/**\n * Decorator for creating a reactive function.\n * Functions decorated with `reactiveFn` always return a pointer that is automatically updated when input references are updated.\n * This has the same effect as wrapping the function body with `always`.\n * A reactive functions accepts references or values as arguments, but is always called with collapsed values. \n * This means that you don't have to specifiy `Ref` values as arguments, but can use regular types.\n * \n * Example:\n * ```ts\n * // create reactive function 'getSquared'\n * const getSquared = reactiveFn((x: number) => x * x);\n * \n * const x = $$(2);\n * const y = getSquared(x); // Ref<4>\n * x.val = 3;\n * y // Ref<9>\n * ```\n */\nexport function reactiveFn<ReturnType, Args extends unknown[]>(fn: (...args: Args) => Awaited<RestrictSameType<RefOrValue<ReturnType>>>) {\n    return (...args: MapToRefOrVal<Args>) => always(() => {\n        const collapsedArgs = args.map(arg => ReactiveValue.collapseValue(arg, true, true)) as Args;\n        return fn(...collapsedArgs)\n    });\n}\n\ntype MapToRefOrVal<T extends unknown[]> = {[K in keyof T]: T[K] extends ReactiveValue ? T[K] : RefOrValue<T[K]>}\n\n\nconst getGreetingMessage = (country: RefOrValue<string>) => {\n    return always(() => {\n        switch (country) {\n            case \"de\": return \"Hallo\";\n            case \"fr\": return \"Bonjour\";\n            case \"es\": return \"Hola\";\n            default: return \"Hello\";\n        }\n    })\n}\n\n/**\n * Runs each time a dependency reference value changes.\n * Dependency references are automatically detected.\n * ```ts\n * const x = $$(10);\n * effect (() => console.log(\"x is \" + x));\n * x.val = 5; // logs \"x is 5\"\n * ```\n * \n * Disposing effects:\n * ```ts\n * const x = $$(10);\n * const {dispose} = effect (() => console.log(\"x is \" + x));\n * x.val = 5; // logs \"x is 5\"\n * dispose();\n * x.val = 6; // no log\n * ```\n */\nexport function effect<W extends Record<string, WeakKey>|undefined>(handler:W extends undefined ? () => void|Promise<void> :(weakVariables: W) => void|Promise<void>, weakVariables?: W): {dispose: () => void, [Symbol.dispose]: () => void} {\n    \n    let ptr: Pointer;\n\n    // weak variable binding\n    if (weakVariables) {\n        const weakVariablesProxy = {};\n        for (const [k, v] of Object.entries(weakVariables)) {\n            const weakRef = new WeakRef(v);\n            Object.defineProperty(weakVariablesProxy, k, {get() {\n              const val = weakRef.deref()\n              if (!val) {\n                // dispose effect\n                ptr.is_persistent = false;\n                ptr.delete()\n                throw Pointer.WEAK_EFFECT_DISPOSED;\n              }\n              else return val;\n            }})\n        }\n        const originalHandler = handler;\n        handler = (() => originalHandler(weakVariablesProxy)) as any;\n    }\n    \n    ptr = Pointer.createSmartTransform(handler as any, undefined, true, true);\n    ptr.is_persistent = true;\n\n    return {\n        [Symbol.dispose||Symbol.for(\"Symbol.dispose\")]() {\n            ptr.is_persistent = false;\n            ptr.delete()\n        },\n        dispose() {\n            ptr.is_persistent = false;\n            ptr.delete()\n        }\n    }\n}\n\n\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * Dependency references have to be specified. If one of the dependencies changes, the resulting pointe\n * value is recalculated.\n * @param dependencies dependency references\n * @param transform transform function\n * @param persistent_datex_transform optional equivalent datex script describing the transform\n * @returns \n */\nexport function transform<T,V extends TransformFunctionInputs>(dependencies:V, transform:TransformFunction<V,T>, persistent_datex_transform?:string) {\n    return ReactiveValue.collapseValue(Pointer.createTransform(dependencies, transform, persistent_datex_transform));\n}\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * Dependency references have to be specified. If one of the dependencies changes, the resulting pointe\n * value is recalculated.\n * @param dependencies dependency references\n * @param transform an async transform function (returning a Promise)\n * @param persistent_datex_transform optional equivalent datex script describing the transform\n * @returns \n */\nexport async function transformAsync<T,V extends TransformFunctionInputs>(dependencies:V, transform:AsyncTransformFunction<V,T>, persistent_datex_transform?:string) {\n    return ReactiveValue.collapseValue(await Pointer.createTransformAsync(dependencies, transform, persistent_datex_transform));\n}\n\n\nexport function map<T, U, O extends 'array'|'map' = 'array'>(iterable: Iterable<T>, mapFn: (value: MaybeObjectRef<T>, index: number, array: Iterable<T>) => U, options?: {outType: O}): O extends \"array\" ? U[] : Map<number, U> {\n    let mapped:U[]|Map<number, U>\n    \n    // live map\n    if (Datex.ReactiveValue.isRef(iterable)) {\n\n        // return map\n        if (options?.outType == \"map\") {\n            mapped = $$(new Map())\n\n            const iterableHandler = new IterableHandler(iterable, {\n                map: (v,k)=>{\n                    return mapFn(v,k,iterable)\n                },\n                onEntryRemoved: (v,k) => {\n                    (mapped as Map<number,U>).delete(k)\n                },\n                onNewEntry: (v,k) => (mapped as Map<number,U>).set(k,v),\n                onEmpty: () => (mapped as Map<number,U>).clear()\n            })\n            // reverse transform binding\n            Datex.Pointer.bindDisposable(mapped, iterableHandler)\n        }\n\n        // return array\n        else {\n            mapped = $$([])\n\n            // no gaps in a set -> array splice required\n            const spliceArray = iterable instanceof Set; \n\n            const iterableHandler = new IterableHandler(iterable, {\n                map: (v,k)=>{\n                    return mapFn(v,k,iterable)\n                },\n                onEntryRemoved: (v,k) => {\n                    if (spliceArray) (mapped as U[]).splice(k, 1);\n                    else delete (mapped as U[])[k];\n                },\n                onNewEntry: (v,k) => {\n                    (mapped as U[])[k] = v\n                },\n                onEmpty: () => {\n                    (mapped as U[]).length = 0\n                }\n            })\n            // reverse transform binding\n            Datex.Pointer.bindDisposable(mapped, iterableHandler)\n        }\n\n    }\n\n    // static map\n    else {\n        if (options?.outType == \"map\") {\n            mapped = new Map()\n            let i = 0;\n            for (const val of iterable) {\n                mapped.set(i, mapFn(val, i++, iterable))\n            }\n        }\n        else {\n            mapped = []\n            let i = 0;\n            for (const val of iterable) {\n                mapped.push(mapFn(val, i++, iterable))\n            }\n        }\n        \n    }\n\n    const ptr = Pointer.getByValue(mapped);\n    if (ptr) ptr.isTransform = true;\n    \n    return mapped as any;\n}\n\n\n// TODO: (remove empty entries inbetween)\n// export function filter<T, U>(array: Array<T>, predicate: (value: T, index: number, array: T[]) => value is T&U) {\n\n// \t// live map\n// \tif (Datex.Ref.isRef(array)) {\n\n// \t\tconst filtered:U[] = $$([])\n\n// \t\tconst spliceArray = true;\n\n// \t\tnew IterableHandler<T,U>(array, {\n// \t\t\tfilter: (v,k):v is T&U => {\n// \t\t\t\treturn predicate(v,k,array)\n// \t\t\t},\n// \t\t\tonEntryRemoved: (v,k) => {\n// \t\t\t\tif (spliceArray) filtered.splice(k, 1);\n// \t\t\t\telse delete filtered[k];\n// \t\t\t},\n// \t\t\tonNewEntry: (v,k) => {\n// \t\t\t\tfiltered[k] = v\n// \t\t\t},\n// \t\t\tonEmpty: () => {\n// \t\t\t\tfiltered.length = 0\n// \t\t\t}\n// \t\t})\n\n// \t\treturn filtered;\n\n// \t}\n\n// \t// static map\n// \telse return array.filter(predicate)\n// }\n\n\n/**\n * Switches between two values depending if a value is true or false\n * @param value input value\n * @param if_true value selected if true\n * @param if_false value selected if false\n */\nexport function toggle<T>(value:RefLike<boolean>, if_true:T, if_false:T = null as T): MinimalJSRef<T> {\n    return transform([value], v=>v?<any>if_true:<any>if_false, \n    // dx transforms not working correctly (with uix)\n    /*`\n    always (\n        if (${Runtime.valueToDatexString(value)}) (${Runtime.valueToDatexString(if_true)}) \n        else (${Runtime.valueToDatexString(if_false)})\n    )`*/);\n}\n\n\n/**\n * @deprecated, use toggle()\n */\nexport const select = toggle;\n\n\n/**\n * Returns a pointer representing a === b\n * @param a input value\n * @param b input value\n */\nexport function equals<T,V>(a:RefLike<T>|T, b: RefLike<V>|V): Datex.Pointer<boolean> {\n    return transform([a, b], (a,b) =>  Datex.ReactiveValue.collapseValue(a, true, true) === Datex.ReactiveValue.collapseValue(b, true, true), \n    // dx transforms not working correctly (with uix)\n        /*`always (${Runtime.valueToDatexString(a)} === ${Runtime.valueToDatexString(b)})`*/) as any;\n}\n\n\n/**\n * Selects a property from an object\n * @param property property name\n * @param object the reference object\n * @returns \n */\nexport function selectProperty<K extends string|number, V>(property:RefLike<K>, object:Readonly<Record<K, V>>):MinimalJSRef<V> {\n    return <MinimalJSRef<V>> transform([property], (v)=><any>object[<K>v]);\n}\n\n\n/**\n * Inverts a boolean value/reference\n * @param value \n * @returns \n */\nexport function not(value:RefOrValue<boolean>): Pointer<boolean> {\n    return transform([value], v=>!v);\n}\n\n/**\n * Performs a boolean 'and' operation on one or more boolean values/references\n * @param values \n * @returns \n */\nexport function and(...values:RefOrValue<boolean>[]): Pointer<boolean> {\n    return transform(values, (...values)=>{\n        for (const v of values) {\n            if (!v) return false;\n        }\n        return true;\n    });\n}\n\n/**\n * Performs a boolean 'or' operation on one or more boolean values/references\n * @param values \n * @returns \n */\nexport function or(...values:RefOrValue<boolean>[]): Pointer<boolean> {\n    return transform(values, (...values)=>{\n        for (const v of values) {\n            if (v) return true;\n        }\n        return false;\n    });\n}\n\n/**\n * Performs an 'add' operation on one or more values (strings, numbers)\n * @param numbers \n * @returns \n */\nexport function add<T>(...numbers:RefOrValue<T>[]): MinimalJSRef<T>\nexport function add(...args:any[]) {\n    return transform([...args], (...args) => args.reduce((a, b) => a + b, 0));\n}\n\n/**\n * Performs a 'subtract' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function sub(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function sub(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function sub(...args:any[]) {\n    return transform([...args], (...args) => args.slice(1).reduce((a, b) => a - b, args[0]));\n}\n\n/**\n * Performs a 'multiply' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function mul(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function mul(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function mul(...args:any[]) {\n    return transform([...args], (...args) => args.reduce((a, b) => a * b, 1));\n}\n\n/**\n * Performs a 'division' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function div(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function div(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function div(...args:any[]) {\n    return transform([...args], (...args) => args.slice(1).reduce((a, b) => a / b, args[0]));\n}\n\n/**\n * Performs a 'power' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function pow(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function pow(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function pow(...args:any[]) {\n    return transform([...args], (...args) => args.slice(1).reduce((a, b) => a ** b, args[0]));\n}\n\n\n// @ts-ignore\nglobalThis.transform = transform;\n// @ts-ignore\nglobalThis.transformAsync = transformAsync;\n\n// @ts-ignore\nglobalThis.and = and;\n// @ts-ignore\nglobalThis.or = or;\n// @ts-ignore\nglobalThis.not = not;"],"names":["INSERT_MARK","Pointer","ReactiveValue","logger","Datex","PointerError","IterableHandler","handleError","KnownError","always","scriptOrJSTransform","vars","options","undefined","constructor","name","_allowAsync","Error","ptr","createSmartTransform","value_initialized","waiting_for_always_promise","then","collapseTransformPointer","_collapseStatic","_returnWrapper","_allowAnyType","raw","Array","datex","join","collapseStatic","alwaysReturnWrapper","collapse","isStaticTransform","allowAnyType","val","collapseValue","delete","asyncAlways","transform","warn","reactiveFn","fn","args","map","arg","effect","handler","weakVariables","weakVariablesProxy","k","v","Object","entries","weakRef","WeakRef","defineProperty","get","deref","is_persistent","WEAK_EFFECT_DISPOSED","originalHandler","Symbol","dispose","for","dependencies","persistent_datex_transform","createTransform","transformAsync","createTransformAsync","iterable","mapFn","mapped","isRef","outType","$$","Map","iterableHandler","onEntryRemoved","onNewEntry","set","onEmpty","clear","bindDisposable","spliceArray","Set","splice","length","i","push","getByValue","isTransform","toggle","value","if_true","if_false","select","equals","a","b","selectProperty","property","object","not","and","values","or","add","reduce","sub","slice","mul","div","pow","globalThis"],"mappings":"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","sourceRoot":"/core-lib/datex-core-js-legacy/","file":"functions.ts"}