{"version":3,"sources":["js_class_adapter.ts"],"sourcesContent":["/**\n ╔══════════════════════════════════════════════════════════════════════════════════════╗\n ║  Datex JS Class Adapter (@sync classes)                                              ║\n ╠══════════════════════════════════════════════════════════════════════════════════════╣\n ║  Unyt core library                                                                   ║\n ║  Visit docs.unyt.org/unyt_js for more information                                    ║\n ╠═════════════════════════════════════════╦════════════════════════════════════════════╣\n ║  © 2022  Benedikt Strehle               ║                                            ║\n ╚═════════════════════════════════════════╩════════════════════════════════════════════╝\n */\n\n/** Imports **/\n\n// import \"../lib/reflect-metadata/Reflect.js\";\nimport { Runtime, StaticScope } from \"../runtime/runtime.ts\";\n\nimport { Logger } from \"../utils/logger.ts\";\nimport { endpoint_name, LOCAL_ENDPOINT, Target, target_clause } from \"../types/addressing.ts\";\nimport { Type } from \"../types/type.ts\";\nimport { getProxyFunction, getProxyStaticValue, ObjectRef, Pointer, UpdateScheduler } from \"../runtime/pointers.ts\";\nimport { Function as DatexFunction } from \"../types/function.ts\";\nimport { DatexObject } from \"../types/object.ts\";\nimport { Tuple } from \"../types/tuple.ts\";\nimport { DX_PERMISSIONS, DX_TYPE, DX_ROOT, INIT_PROPS, DX_EXTERNAL_SCOPE_NAME, DX_EXTERNAL_FUNCTION_NAME, DX_TIMEOUT } from \"../runtime/constants.ts\";\nimport type { Class } from \"../utils/global_types.ts\";\nimport { Conjunction, Disjunction, Logical } from \"../types/logic.ts\";\nimport { client_type } from \"../utils/constants.ts\";\nimport { Assertion } from \"../types/assertion.ts\";\nimport { getCallerInfo } from \"../utils/caller_metadata.ts\";\n\nconst { Reflect: MetadataReflect } = client_type == 'deno' ? await import(\"https://deno.land/x/reflect_metadata@v0.1.12/mod.ts\") : {Reflect};\n\nconst logger = new Logger(\"DATEX JS Adapter\");\n\n\nconst CONSTRUCT_OPTIONS = Symbol(\"CONSTRUCT_OPTIONS\");\n\n// create metadata symbol\nif (!Symbol['metadata']) Symbol['metadata'] = Symbol('metadata');\nexport const METADATA:unique symbol = Symbol['metadata'];\n\n\n// generate a instance of a JS class / DATEX Type by casting\nexport function instance<T>(fromClass:{new(...params:any[]):T}, properties?:PartialRefOrValueObject<T>): T\nexport function instance<T>(fromType:Type<T>, properties?:PartialRefOrValueObject<T>): T\nexport function instance<T>(fromClassOrType:{new(...params:any[]):T}|Type<T>, properties?:PartialRefOrValueObject<T>): T {\n    if (fromClassOrType instanceof Type) return fromClassOrType.cast(properties);\n    else return Type.getClassDatexType(fromClassOrType).cast(properties)\n}\n\n\n// handles all decorators\nexport class Decorators {\n\n    static IS_EXPOSED    = Symbol(\"IS_EXPOSED\");\n    static IS_REMOTE     = Symbol(\"IS_REMOTE\");\n\n    static IS_EACH       = Symbol(\"IS_EACH\");\n    static IS_SYNC       = Symbol(\"IS_SYNC\");\n    static IS_ANONYMOUS  = Symbol(\"IS_ANONYMOUS\");\n    static IS_SEALED     = Symbol(\"IS_SEALED\");\n    static ANONYMIZE     = Symbol(\"ANONYMIZE\");\n\n    static PROPERTY      = Symbol(\"PROPERTY\");\n    static STATIC_PROPERTY  = Symbol(\"STATIC_PROPERTY\");\n    static SERIALIZE     = Symbol(\"SERIALIZE\");\n    static JSDOC         = Symbol(\"JSDOC\");\n\n    static ALLOW_FILTER  = Symbol(\"ALLOW_FILTER\");\n    static SEND_FILTER   = Symbol(\"SEND_FILTER\");\n\n    static NAMESPACE     = Symbol(\"SCOPE_NAME\");\n\n    static DEFAULT       = Symbol(\"ROOT_EXTENSION\");\n    static DEFAULT_PROPERTY = Symbol(\"ROOT_VARIABLE\");\n\n    static DOCS          = Symbol(\"DOCS\");\n\n    static META_INDEX    = Symbol(\"META_INDEX\");\n\n    static SIGN          = Symbol(\"SIGN\");\n    static ENCRYPT       = Symbol(\"ENCRYPT\");\n    static NO_RESULT     = Symbol(\"NO_RESULT\");\n    static TIMEOUT       = Symbol(\"TIMEOUT\");\n    static OBSERVER      = Symbol(\"OBSERVER\");\n    static SCHEDULER     = Symbol(\"SCHEDULER\");\n\n    static FORCE_TYPE    = Symbol(\"FORCE_TYPE\");\n    static FROM_TYPE     = Symbol(\"FROM_TYPE\");\n\n\n    public static setMetadata(context:DecoratorContext, key:string|symbol, value:unknown) {\n        // handle inheritance for nested object: if metadata has prototype but no own properties, inherit nested\n        if (Object.getPrototypeOf(context.metadata) && !Object.getOwnPropertyNames(context.metadata).length && !Object.getOwnPropertySymbols(context.metadata).length) {\n            const proto = Object.getPrototypeOf(context.metadata);\n            for (const key of [...Object.getOwnPropertyNames(proto), ...Object.getOwnPropertySymbols(proto)]) {\n                context.metadata[key] = {};\n                if (proto[key]?.public) (context.metadata[key] as any).public = Object.create(proto[key].public);\n                if (proto[key]?.constructor)(context.metadata[key] as any).constructor = proto[key].constructor;\n            }\n        }\n\n        if (!context.metadata[key]) context.metadata[key] = {}\n        const data = context.metadata[key] as {public?:Record<string|symbol,any>, constructor?:any}\n        if (context.kind == \"class\") {\n            data.constructor = value;\n        }\n        else {\n            if (!data.public) data.public = {};\n            data.public[context.name] = value;\n        }  \n    }\n\n    public static getMetadata(context:DecoratorContext, key:string|symbol) {\n        const data = context.metadata[key]?.public?.[context.name] ?? context.metadata[key]?.constructor;\n        if (data !== Object) return data;\n    }\n\n\n    /** @endpoint(endpoint?:string|Datex.Endpoint, namespace?:string): declare a class as a #public property */\n    static endpoint(endpoint:target_clause|endpoint_name, scope_name:string|undefined, value: Class, context: ClassDecoratorContext) {\n        // target endpoint\n        if (endpoint) {\n            Decorators.addMetaFilter(\n                endpoint, \n                context,\n                Decorators.SEND_FILTER\n            )\n        }\n        else {\n            this.setMetadata(context, Decorators.SEND_FILTER, true) // indicate to always use local endpoint (expose)\n        }\n\n        // custom namespace name\n        this.setMetadata(context, Decorators.NAMESPACE, scope_name ?? value.name);\n        registerPublicStaticClass(value, 'public', context.metadata);\n    }\n\n    /** @entrypoint is set as endpoint entrypoint */\n    static entrypoint(value:Class, context: ClassDecoratorContext) {\n        this.setMetadata(context, Decorators.SEND_FILTER, true) // indicate to always use local endpoint (expose)\n        this.setMetadata(context, Decorators.NAMESPACE, value.name);\n        registerPublicStaticClass(value, 'entrypoint', context.metadata);\n    }\n\n    /** @entrypointProperty is set as a property of the endpoint entrypoint */\n    static entrypointProperty(value:Class, context: ClassDecoratorContext) {\n        this.setMetadata(context, Decorators.SEND_FILTER, true) // indicate to always use local endpoint (expose)\n        this.setMetadata(context, Decorators.NAMESPACE, value.name);\n        registerPublicStaticClass(value, 'entrypointProperty', context.metadata);\n    }\n\n\n    /** @docs(content:string): add docs to a static scope class / pseudo class */\n    static docs(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[string?] = []) {\n    \n        // invalid decorator call\n        if (kind != \"class\") logger.error(\"@docs can only be used for classes\");\n\n        // handle decorator\n        else {\n            setMetadata(Decorators.DOCS, params[0])\n        }\n    }\n\n    /** @sign(sign?:boolean): sign outgoing DATEX requests (default:true) */\n    static sign(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[boolean?] = []) {\n        setMetadata(Decorators.SIGN, params[0])\n    }\n\n    /** @encrypt(encrpyt?:boolean): encrypt outgoing DATEX requests (default:false) */\n    static encrypt(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[boolean?] = []) {\n        setMetadata(Decorators.ENCRYPT, params[0])\n    }\n\n    /** @no_result: do not wait for the result */\n    static no_result(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:undefined) {\n        setMetadata(Decorators.NO_RESULT, true)\n    }\n\n    /** @timeout(msecs?:number): DATEX request timeout */\n    static timeout(timeMs:number, context:ClassMethodDecoratorContext) {\n        if (isFinite(timeMs) && timeMs > 2**31) throw new Error(\"@timeout: timeout too big (max value is 2^31), use Infinity if you want to disable the timeout\")\n        this.setMetadata(context, Decorators.TIMEOUT, timeMs)\n    }\n\n    /** @allow(allow:filter): Allowed endpoints for class/method/field */\n    static allow(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[target_clause?] = []) {\n        Decorators.addMetaFilter(\n            params[0], \n            setMetadata, getMetadata, Decorators.ALLOW_FILTER\n        )\n    }\n\n    /** @to(to:filter): Send DATEX requests to endpoints */\n    static to(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[(target_clause|endpoint_name)?] = []) {\n        Decorators.addMetaFilter(\n            params[0], \n            setMetadata, getMetadata, Decorators.SEND_FILTER\n        )\n    }\n\n    /** @each: sent to all subscribers */\n    static each(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:undefined) {\n        \n        // invalid decorator call\n        if (is_static) logger.error(\"Cannot use @each for static field '\" + name.toString() +\"'\");\n\n        // handle decorator\n        else {\n            setMetadata(Decorators.IS_EACH, true)\n        }\n    }\n\n    static assignType<T>(type:string|Type<T>, context: ClassFieldDecoratorContext|ClassGetterDecoratorContext|ClassMethodDecoratorContext, forceConjunction = false) {\n        let newType = this.getMetadata(context, Decorators.FORCE_TYPE);\n\n        if (newType instanceof Conjunction) {\n            newType.add(type)\n        }\n        else if (newType) {\n            newType = new Conjunction(newType, type)\n        }\n        else {\n            newType = forceConjunction ? new Conjunction(type) : type\n        }\n        this.setMetadata(context, Decorators.FORCE_TYPE, newType)\n    }\n\n\n    /** @property: add a field as a template property */\n    static property<T>(type:string|Type<T>|Class<T>, context: ClassFieldDecoratorContext|ClassGetterDecoratorContext|ClassMethodDecoratorContext) {\n\n        if (context.static) {\n            this.setMetadata(context, Decorators.STATIC_PROPERTY, context.name)\n        }\n        else {\n            this.setMetadata(context, Decorators.PROPERTY, context.name)\n        }\n\n        // type\n        if (type) {\n            const normalizedType = normalizeType(type);\n            this.assignType(normalizedType, context)\n        }\n    }\n\n\n     /** @assert: add type assertion function */\n    static assert<T>(assertion: (val:T) => boolean|string|undefined, context: ClassFieldDecoratorContext) {\n        if (context.static) logger.error(\"Cannot use @assert with static fields\");\n        else {\n            const assertionType = Assertion.get(undefined, assertion, false);\n            this.assignType(assertionType, context, true)\n        }\n    }\n\n    /** @jsdoc parse jsdoc comments and use as docs for DATEX type*/\n    // TODO: only works with real js decorators, otherwise line numbers don't match\n    static jsdoc(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[]) {\n\n        logger.error(\"@jsdoc decorators are not yet supported\")\n        // const caller = getCallerInfo()?.at(-1)!;\n\n        // if (!caller?.file || !caller.row) {\n        //     logger.error(\"cannot get JSDoc data (@jsdoc was used on the \" + kind + \" \"+name+\")\")\n        //     return;\n        // }\n\n        // (async()=>{\n        //     const path = new Path(caller.file!);\n        //     const content = (await path.getTextContent()).split(\"\\n\").slice(Math.min(0,caller.row-60), caller.row).join(\"\\n\");    \n        //     setMetadata(Decorators.JSDOC, \"TODO\")\n        // })()\n    }\n\n\n    /** @serialize: custom serializer for a template property */\n    static serialize(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[Function]) {\n        if (is_static) logger.error(\"@serialize decorator cannot be used for static fields\");\n        else if (kind != \"field\" && kind != \"getter\" && kind != \"setter\" && kind != \"method\") logger.error(\"Invalid use of @serialize decorator\");\n        else if (!params?.[0]) logger.error(\"Missing serializer method on @serialize decorator\");\n\n        else {\n            setMetadata(Decorators.SERIALIZE, params[0])\n        }\n\n    }\n\n\n    /** @sync: sync class/property */\n    static sync(type: string|Type|undefined, value: Class, context?: ClassDecoratorContext, callerFile?:string) {\n        \n        if (context) {\n            this.setMetadata(context ?? {kind: \"class\", metadata:(value as any)[METADATA]}, Decorators.IS_SYNC, true)\n        }\n\n        const originalClass = value;\n\n        let normalizedType: Type;\n\n        // get template type\n        if (typeof type == \"string\" || type instanceof Type) {\n            normalizedType = normalizeType(type, false, \"ext\");\n        }\n        else if (\n            originalClass[METADATA]?.[Decorators.FORCE_TYPE] && \n            Object.hasOwn(originalClass[METADATA]?.[Decorators.FORCE_TYPE], 'constructor')\n        ) normalizedType = originalClass[METADATA]?.[Decorators.FORCE_TYPE]?.constructor\n        else {\n            if (!originalClass.name) throw new Error(\"Cannot create DATEX type mapping for an anonymous class\")\n            normalizedType = Type.get(\"ext\", originalClass.name.replace(/^_/, '')); // remove leading _ from type name\n        }\n\n        if (!callerFile && client_type == \"deno\" && normalizedType.namespace !== \"std\") {\n            callerFile = getCallerInfo()?.[3]?.file ?? undefined;\n            if (!callerFile) {\n                logger.error(\"Could not determine JS module URL for type '\" + normalizedType + \"'\")\n            }\n        }\n        \n        // return new templated class\n        return createTemplateClass(originalClass, normalizedType, true, true, callerFile, context?.metadata);\n    }\n\n\n    /** @update(interval:number|scheduler:DatexUpdateScheduler): set update interval / scheduler */\n    static update(value:any, name:context_name, kind:context_kind, is_static:boolean, is_private:boolean, setMetadata:context_meta_setter, getMetadata:context_meta_getter, params:[(number|UpdateScheduler)?] = []) {\n        \n        if (params[0] instanceof UpdateScheduler) setMetadata(Decorators.SCHEDULER, params[0])\n        else setMetadata(Decorators.SCHEDULER, new UpdateScheduler(params[0]));\n    }\n\n    // handle ALLOW_FILTER for classes, methods and fields\n    // adds filter\n    private static addMetaFilter(new_filter:target_clause|endpoint_name, context: DecoratorContext, filter_symbol:symbol){\n        if (typeof new_filter == \"string\") this.setMetadata(context, filter_symbol, Target.get(new_filter))\n        else this.setMetadata(context, filter_symbol, new_filter)\n    }\n}\n\n/**\n * Converts strings into Datex.Type and checks if type parameters are allowed\n * @param type \n * @param allowTypeParams \n * @returns \n */\nfunction normalizeType(type:Type|string|Class, allowTypeParams = true, defaultNamespace = \"std\") {\n    if (typeof type == \"string\") {\n        // extract type name and parameters\n        const [typeName, paramsString] = type.replace(/^\\</,'').replace(/\\>$/,'').match(/^((?:[\\w-]+\\:)?[\\w-]*)(?:\\((.*)\\))?$/)?.slice(1) ?? [];\n        if (paramsString && !allowTypeParams) throw new Error(`Type parameters not allowed (${type})`);\n        \n        if (!typeName) throw new Error(\"Invalid type: \" + type);\n\n        // TODO: only json-compatible params are allowed for now to avoid async\n        const parsedParams = paramsString ? JSON.parse(`[${paramsString}]`) : undefined;\n        return Type.get(typeName.includes(\":\") ? typeName : defaultNamespace+\":\"+typeName, parsedParams)\n    }\n    else if (type instanceof Type) {\n        if (!allowTypeParams && type.parameters?.length) throw new Error(`Type parameters not allowed (${type})`);\n        return type\n    }\n    else if (typeof type == \"function\") {\n        const classType = Type.getClassDatexType(type)\n        if (!classType) throw new Error(\"Could not get a DATEX type for class \" + type.name + \". Only @sync classes can be used as types\");\n        return classType\n    }\n    else {\n        console.error(\"invalid type\",type)\n        throw new Error(\"Invalid type\")\n    }\n}\n\ntype class_data = {name:string, static_scope:StaticScope, properties: string[], metadata:any}\n\nconst PROPERTY_COLLECTION = Symbol(\"PROPERTY_COLLECTION\");\nconst registeredClasses = new Map<Function,class_data>();\nconst pendingClassRegistrations = new Map<Class, Set<'public'|'entrypoint'|'entrypointProperty'>>().setAutoDefault(Set);\n\nfunction registerPublicStaticClass(publicClass:Class, type:'public'|'entrypoint'|'entrypointProperty', metadata?:Record<string,any>){\n    pendingClassRegistrations.getAuto(publicClass).add(type);\n    initPublicStaticClass(publicClass, type, metadata)\n}\n\nexport function initPublicStaticClasses(){    \n    for (const [reg_class, types] of [...pendingClassRegistrations]) {\n        for (const type of [...types]) {\n            initPublicStaticClass(reg_class, type)\n        }\n    }\n    pendingClassRegistrations.clear();\n}\n\nfunction initPublicStaticClass(publicClass: Class, type: 'public'|'entrypoint'|'entrypointProperty', metadata?:Record<string|symbol,any>) {\n    if (!Runtime.endpoint || Runtime.endpoint === LOCAL_ENDPOINT) return;\n\n    metadata ??= (<any>publicClass)[METADATA];\n    if (!metadata) throw new Error(`Missing metadata for class ${publicClass.name}`)\n    let targets = metadata[Decorators.SEND_FILTER]?.constructor;\n    if (targets == true) targets = Runtime.endpoint; // use own endpoint per default\n\n    let data = registeredClasses.get(publicClass);\n    \n    // expose if current endpoint matches class endpoint\n    if (Logical.matches(Runtime.endpoint, targets, Target)) {\n        data ??= getStaticClassData(publicClass, true, type == 'public', metadata);\n        if (!data) throw new Error(\"Could not get data for static class\")\n        exposeStaticClass(publicClass, data);\n    }\n\n    // also enable remote access if not exactly and only the current endpoint\n    if (Runtime.endpoint !== targets) {\n        data ??= getStaticClassData(publicClass, false, false, metadata);\n        if (!data) throw new Error(\"Could not get data for static class\")\n        remoteStaticClass(publicClass, data, targets)\n    }\n\n    // set method timeouts\n    for (const [method_name, timeout] of Object.entries(metadata[Decorators.TIMEOUT]?.public??{})) {\n        const method = (publicClass as any)[method_name];\n        if (method) method[DX_TIMEOUT] = timeout\n    }\n\n    // set entrypoint\n    if (type == 'entrypoint') {\n        data ??= getStaticClassData(publicClass, true, false, metadata);\n        if (Runtime.endpoint_entrypoint) logger.error(\"Existing entrypoint was overridden with @entrypoint class \" + publicClass.name);\n        Runtime.endpoint_entrypoint = data.static_scope;\n    }\n    else if (type == 'entrypointProperty') {\n        data ??= getStaticClassData(publicClass, true, false, metadata);\n        if (Runtime.endpoint_entrypoint == undefined) Runtime.endpoint_entrypoint = {[PROPERTY_COLLECTION]:true}\n        if (typeof Runtime.endpoint_entrypoint !== \"object\" || !Runtime.endpoint_entrypoint[PROPERTY_COLLECTION]) logger.error(\"Cannot set endpoint property \" + publicClass.name + \". The entrypoint is already set to another value.\");\n        Runtime.endpoint_entrypoint[publicClass.name] = data.static_scope;\n    }\n    \n    // DatexObject.seal(data.static_scope);\n    registeredClasses.set(publicClass, data);\n    pendingClassRegistrations.get(publicClass)!.delete(type);\n}\n\n\nfunction exposeStaticClass(original_class:Class, data:class_data) {\n\n    const exposed_public = data.metadata[Decorators.STATIC_PROPERTY]?.public;\n    const exposed_private = data.metadata[Decorators.STATIC_PROPERTY]?.private;\n    \n    for (const name of data.properties) {\n\n        // is a (exposed) property\n        if ((exposed_public?.hasOwnProperty(name) && exposed_public[name]) || (exposed_private?.hasOwnProperty(name) && exposed_private[name])) {\n            \n            const current_value = (<any>original_class)[name];\n            const static_scope = data.static_scope;\n\n            // function\n            if (typeof current_value == \"function\")  {\n                // set allowed endpoints for this method\n                //static_scope.setAllowedEndpointsForProperty(name, this.method_a_filters.get(name))\n\n                const fn = original_class[name];\n                fn[DX_EXTERNAL_SCOPE_NAME] = static_scope.name;\n                fn[DX_EXTERNAL_FUNCTION_NAME] = exposed_public[name]\n\n                const dx_function = Pointer.proxifyValue(DatexFunction.createFromJSFunction(current_value, original_class, name), true, undefined, false, true) ; // generate <Function>\n\n                static_scope.setVariable(name, dx_function); // add <Function> to static scope\n            }\n\n            // field\n            else {\n                // set static value (datexified)\n                const setProxifiedValue = (val:any) => static_scope.setVariable(name, Pointer.proxifyValue(val, true, undefined, false, true));\n                setProxifiedValue(current_value);\n\n                /*** handle new value assignments to this property: **/\n\n                // similar to addObjProxy in DatexRuntime / DatexPointer\n                const property_descriptor = Object.getOwnPropertyDescriptor(original_class, name);\n\n                // add original getters/setters to static_scope if they exist\n                if (property_descriptor?.set || property_descriptor?.get) {\n                    Object.defineProperty(static_scope, name, {\n                        set: val => { \n                            property_descriptor.set?.call(original_class,val);\n                        },\n                        get: () => { \n                            return property_descriptor.get?.call(original_class);\n                        }\n                    });\n                }\n\n                // new getter + setter\n                Object.defineProperty(original_class, name, {\n                    get:()=>static_scope.getVariable(name),\n                    set:(val)=>setProxifiedValue(val)\n                });\n            }\n        }\n    }\n\n}\n\nfunction remoteStaticClass(original_class:Class, data:class_data, targets:target_clause) {\n\n    // console.warn(\"remote class\", original_class, data);\n\n    let class_send_filter:target_clause = targets;\n    // @ts-ignore\n    if (class_send_filter == Object) class_send_filter = undefined;\n\n    let send_filter = data.metadata[Decorators.SEND_FILTER]?.public;\n    if (send_filter == true) send_filter = Runtime.endpoint; // use own endpoint per default\n\n    const remote_public = data.metadata[Decorators.STATIC_PROPERTY]?.public;\n    const remote_private = data.metadata[Decorators.STATIC_PROPERTY]?.private;\n    const timeout_public = data.metadata[Decorators.TIMEOUT]?.public;\n    const timeout_private = data.metadata[Decorators.TIMEOUT]?.private;\n\n    // prototype for all options objects of static proxy methods (Contains the dynamic_filter)\n    let options_prototype: {[key:string]:any} = {};\n\n    // add builtin methods\n    \n    Object.defineProperty(original_class, 'to', {\n        value: function(...targets:(Target|endpoint_name)[]){\n            options_prototype.dynamic_filter = new Disjunction<Target>(); \n            for (const target of targets) {\n                if (typeof target == \"string\") options_prototype.dynamic_filter.add(Target.get(target))\n                else options_prototype.dynamic_filter.add(target)\n            }\n            return this;\n        },\n        configurable: false,\n        enumerable: false,\n        writable: false\n    });\n\n    \n    for (const name of data.properties) {\n\n        // is a (remote) proeprty\n        if ((remote_public?.hasOwnProperty(name) && remote_public[name]) || (remote_private?.hasOwnProperty(name) && remote_private[name])) {\n        \n            const current_value = (<any>original_class)[name];\n\n            const timeout = timeout_public?.[name]??timeout_private?.[name];\n            const filter = new Conjunction(class_send_filter, send_filter?.[name]); \n    \n            // function\n            if (typeof current_value == \"function\")  {      \n                const options = Object.create(options_prototype);\n                Object.assign(options, {filter, sign:true, scope_name:data.name, timeout});\n                const proxy_fn = getProxyFunction(name, options);\n                Object.defineProperty(original_class, name, {value:proxy_fn})\n            }\n    \n            // field\n            else {\n                const options = Object.create(options_prototype);\n                Object.assign(options, {filter, sign:true, scope_name:data.name, timeout});\n                const proxy_fn = getProxyStaticValue(name, options);\n                Object.defineProperty(original_class, name, {\n                    get: proxy_fn // set proxy function for getting static value\n                });\n            }\n        }\n    \n    }\n\n    \n\n}\n\n\nfunction getStaticClassData(original_class:Class, staticScope = true, expose = true, metadata?:Record<string,any>) {\n    metadata ??= (<any>original_class)[METADATA];\n    if (!metadata) return;\n    const static_scope_name = typeof metadata[Decorators.NAMESPACE]?.constructor == 'string' ? metadata[Decorators.NAMESPACE]?.constructor : original_class.name;\n    const static_properties = Object.getOwnPropertyNames(original_class)\n\n    return {\n        metadata,\n        static_scope: staticScope ? StaticScope.get(static_scope_name, expose) : null,\n        name: static_scope_name,\n        properties: static_properties\n    }\n}\n\n\n\nconst templated_classes = new Map<Function, Function>() // original class, templated class\n\nfunction getInferredType(metadataConstructor: any) {\n    return (metadataConstructor && Type.getClassDatexType(metadataConstructor)) ?? Type.std.Any;\n}\n\nexport function createTemplateClass(original_class: Class, type:Type, sync = true, add_js_interface = true, callerFile?:string, metadata?:Record<string,any>){\n\n    if (templated_classes.has(original_class)) return templated_classes.get(original_class)!;\n\n    original_class[DX_TYPE] = type;\n\n    // set JS interface\n    if (add_js_interface) {\n        type.setJSInterface({\n            class: original_class,\n            proxify_children: true, // proxify children per default\n            is_normal_object: true, // handle like a normal object\n        });\n    }\n\n    if (callerFile) {\n        type.jsTypeDefModule = callerFile;\n    }\n\n    metadata ??= original_class[METADATA];\n\n    // set constructor, replicator, destructor\n    const constructor_name = original_class.prototype['construct'] ? 'construct' : null; // Object.keys(metadata?.[Decorators.CONSTRUCTOR]?.public??{})[0]\n    const replicator_name = original_class.prototype['replicate'] ? 'replicate' : null; // Object.keys(metadata?.[Decorators.REPLICATOR]?.public??{})[0]\n    const destructor_name = original_class.prototype['destruct'] ? 'destruct' : null; // Object.keys(metadata?.[Decorators.DESTRUCTOR]?.public??{})[0]\n\n    if (constructor_name) type.setConstructor(original_class.prototype[constructor_name]);\n    if (replicator_name) type.setReplicator(original_class.prototype[replicator_name]);\n    if (destructor_name) type.setDestructor(original_class.prototype[destructor_name]);\n\n    // set template\n    const property_types = metadata?.[Decorators.FORCE_TYPE]?.public;\n    const allow_filters = metadata?.[Decorators.ALLOW_FILTER]?.public;\n\n    const template = {};\n    template[DX_PERMISSIONS] = {}\n\n    // extend prototype template?\n    let prototype = original_class;\n    // iterate up until Object.protoype reached\n    while ((prototype = Object.getPrototypeOf(prototype)) != Object.prototype) {\n        if ((prototype[DX_TYPE])?.template) {\n            DatexObject.extend(template, prototype[DX_TYPE].template);\n            break;\n        }\n        // is root of dx prototype chain, stop\n        if (prototype[DX_ROOT]) break;\n    }\n\n    // iterate over all properties TODO different dx_name?\n    for (const [name, dx_name] of Object.entries(metadata?.[Decorators.PROPERTY]?.public??{})) {\n        let metadataConstructor = MetadataReflect.getMetadata && MetadataReflect.getMetadata(\"design:type\", original_class.prototype, name);\n        // if type is Object -> std:Any\n        if (metadataConstructor == Object) metadataConstructor = null;\n        // set best guess for property type\n        const existingType = property_types?.[name];\n        template[name] = existingType ?? getInferredType(metadataConstructor); // add type\n\n        if (allow_filters?.[name]) template[DX_PERMISSIONS][name] = allow_filters[name]; // add filter\n    }\n\n    type.setTemplate(template)\n\n    // create shadow class extending the actual class\n    const sync_auto_cast_class = proxyClass(original_class, type, metadata?.[Decorators.IS_SYNC]?.constructor ?? sync)\n    \n    // only for debugging / dev console TODO remove\n    // globalThis[sync_auto_cast_class.name] = sync_auto_cast_class;\n\n    templated_classes.set(original_class, sync_auto_cast_class);\n\n    return sync_auto_cast_class;\n}\n\n// Reflect metadata / decorator metadata, get parameters & types if available\nfunction getMethodParams(target:Function, method_name:string, meta_param_index?:number):Tuple{\n    \n    if (!(method_name in target)) return null;\n\n    const tuple = new Tuple();\n    const metadata:any[] = MetadataReflect.getMetadata && MetadataReflect.getMetadata(\"design:paramtypes\", target, method_name);\n\n    if (!metadata) return null;\n\n    // get parmeters names from function body string\n    const function_body:string = target[method_name]?.toString();\n\n    const args_match = function_body?.match(/^[^(]*\\(([^)]*)\\)/)?.[1];\n\n    if (args_match) {\n        const args_strings = normalizeFunctionParams(args_match)?.split(\",\");\n\n        if (args_strings) {\n            for (let i=0;i<args_strings.length;i++) {\n                args_strings[i] = args_strings[i].trim().split(/[ =]/)[0];\n            }\n    \n            // add type metadata\n            let i = 0;\n            for (const arg of args_strings) {\n                if (meta_param_index != null && meta_param_index == i) {i++; continue} // skip meta param index\n                tuple.set(arg, metadata[i] ? Type.getClassDatexType(metadata[i]) : Type.std.Any);\n                i++;\n            }\n        }\n    }\n\n    return tuple;\n}\nfunction getMetaParamIndex(target:Function, method_name:string):number {\n    return target[METADATA]?.[Decorators.META_INDEX]?.public?.[method_name] ??\n        (MetadataReflect.getMetadata && MetadataReflect.getMetadata(\"unyt:meta\", target, method_name));\n}\n\n// TODO: refactor, merge with parser in function.ts\nfunction normalizeFunctionParams(params: string) {\n    let scopes = 0;\n    let nestedIndex = undefined;\n\n    let i=0;\n    let varCount = 0;\n    for (const x of params) {            \n        if (x === \"[\"||x === \"{\") scopes++;\n        if (x === \"]\"||x === \"}\") scopes--;\n        if (nestedIndex == undefined && scopes !== 0) {\n            nestedIndex = i;\n        }\n        else if(nestedIndex != undefined && scopes == 0) {\n            params = [...params].toSpliced(nestedIndex, i-nestedIndex+1, 'x_'+(varCount++)).join(\"\")\n            i = nestedIndex\n            nestedIndex = undefined;\n        }\n        i++;\n    }\n    \n    return params;\n}\n\n\nDatexFunction.setMethodParamsSource(getMethodParams)\nDatexFunction.setMethodMetaIndexSource(getMetaParamIndex)\n\n\n// new version for implemented feature functions / attributes: call datex_advanced() on the class (ideally usa as a decorator, currently not supported by ts)\n\nexport interface DatexClass<T extends (new (...args: unknown[]) => unknown) = (new (...args: unknown[]) => unknown), Construct = InstanceType<T>[\"construct\" & keyof InstanceType<T>]> {\n\n    new(...args: Construct extends (...args: any) => any ? Parameters<Construct> : ConstructorParameters<T>): datexClassType<T>;\n\n}\n\nexport type MethodKeys<T> = {\n    [K in keyof T]: T[K] extends (...args: any) => any  ? K : never;\n}[keyof T];\n\nexport type dc<T extends Record<string,any>&{new (...args:unknown[]):unknown}, OT extends {new (...args:unknown[]):unknown} = ObjectRef<T>> = \n    DatexClass<OT> &\n    Pick<OT, keyof OT> & \n    ((struct:Omit<InstanceType<OT>, MethodKeys<InstanceType<T>>>) => datexClassType<OT>);\n\n/**\n * Workaround to enable correct @sync class typing, until new decorators support it.\n * Usage:\n * ```ts\n * @sync class _MyClass {}\n * export const MyClass = datexClass(_MyClass)\n * export type MyClass = datexClassType<typeof _MyClass>\n * ```\n */\nexport function datexClass<T extends Record<string,any>&{new (...args:any[]):any}>(_class:T) {\n    return <dc<ObjectRef<T>>> _class;\n}\n\nexport type datexClassType<T extends abstract new (...args: any) => any> = ObjectRef<InstanceType<T>>\n\n\n/**\n * @deprecated use datexClass\n */\nexport const datex_advanced = datexClass;\n\n// extend a given class to create a auto-sync a class which autmatically creates synced objects (does not create a DATEX pseudo type configuration)\n// if no type is provided, <ext:ClassName> is created as type by default\nexport function proxyClass<T extends { new(...args: any[]): any;}>(original_class:T, type?:Type, auto_sync = true):DatexClass&T {\n                \n    type = type ?? Type.get(\"ext\", original_class.name)!;\n    \n    // add Proxy trap for construct\n    const new_class = new Proxy(original_class, {\n        construct(target: T, args: any[], newTarget:Function) {\n            // cast from type\n            if (new_class == newTarget) {\n                // cast and immediately create pointer if auto_sync\n                return type.cast(new Tuple(args), undefined, undefined, auto_sync);\n            }\n            // just return new instance\n            else {\n                const instance:any = Reflect.construct(target, args, newTarget);\n                if (args[0]?.[INIT_PROPS]) {\n                    args[0][INIT_PROPS](instance);\n                }\n                return instance;\n            }\n        },\n        apply(target,_thisArg,argArray) {\n            return Pointer.createOrGet(instance(target, argArray[0])).js_value\n        },\n        getPrototypeOf(target) {\n            return original_class\n        }\n    });\n\n    // custom class methods\n    // -> MyClass.options(...).new(...);\n    Object.defineProperty(new_class, 'options', {value: function(options:{properties:any}){\n        original_class[CONSTRUCT_OPTIONS] = options;\n        return new_class;\n    }});\n\n    Object.defineProperty(new_class, 'new', {value: function(...args:any[]){\n        return new new_class(...args);\n    }});\n\n    return new_class;\n}"],"names":["Runtime","StaticScope","Logger","LOCAL_ENDPOINT","Target","Type","getProxyFunction","getProxyStaticValue","Pointer","UpdateScheduler","Function","DatexFunction","DatexObject","Tuple","DX_PERMISSIONS","DX_TYPE","DX_ROOT","INIT_PROPS","DX_EXTERNAL_SCOPE_NAME","DX_EXTERNAL_FUNCTION_NAME","DX_TIMEOUT","Conjunction","Disjunction","Logical","client_type","Assertion","getCallerInfo","Reflect","MetadataReflect","logger","CONSTRUCT_OPTIONS","Symbol","METADATA","instance","fromClassOrType","properties","cast","getClassDatexType","Decorators","IS_EXPOSED","IS_REMOTE","IS_EACH","IS_SYNC","IS_ANONYMOUS","IS_SEALED","ANONYMIZE","PROPERTY","STATIC_PROPERTY","SERIALIZE","JSDOC","ALLOW_FILTER","SEND_FILTER","NAMESPACE","DEFAULT","DEFAULT_PROPERTY","DOCS","META_INDEX","SIGN","ENCRYPT","NO_RESULT","TIMEOUT","OBSERVER","SCHEDULER","FORCE_TYPE","FROM_TYPE","setMetadata","context","key","value","Object","getPrototypeOf","metadata","getOwnPropertyNames","length","getOwnPropertySymbols","proto","public","create","constructor","data","kind","name","getMetadata","endpoint","scope_name","addMetaFilter","registerPublicStaticClass","entrypoint","entrypointProperty","docs","is_static","is_private","params","error","sign","encrypt","no_result","timeout","timeMs","isFinite","Error","allow","to","each","toString","assignType","type","forceConjunction","newType","add","property","static","normalizedType","normalizeType","assert","assertion","assertionType","get","undefined","jsdoc","serialize","sync","callerFile","originalClass","hasOwn","replace","namespace","file","createTemplateClass","update","new_filter","filter_symbol","allowTypeParams","defaultNamespace","typeName","paramsString","match","slice","parsedParams","JSON","parse","includes","parameters","classType","console","PROPERTY_COLLECTION","registeredClasses","Map","pendingClassRegistrations","setAutoDefault","Set","publicClass","getAuto","initPublicStaticClass","initPublicStaticClasses","reg_class","types","clear","targets","matches","getStaticClassData","exposeStaticClass","remoteStaticClass","method_name","entries","method","endpoint_entrypoint","static_scope","set","delete","original_class","exposed_public","exposed_private","private","hasOwnProperty","current_value","fn","dx_function","proxifyValue","createFromJSFunction","setVariable","setProxifiedValue","val","property_descriptor","getOwnPropertyDescriptor","defineProperty","call","getVariable","class_send_filter","send_filter","remote_public","remote_private","timeout_public","timeout_private","options_prototype","target","dynamic_filter","configurable","enumerable","writable","filter","options","assign","proxy_fn","staticScope","expose","static_scope_name","static_properties","templated_classes","getInferredType","metadataConstructor","std","Any","add_js_interface","has","setJSInterface","class","proxify_children","is_normal_object","jsTypeDefModule","constructor_name","prototype","replicator_name","destructor_name","setConstructor","setReplicator","setDestructor","property_types","allow_filters","template","extend","dx_name","existingType","setTemplate","sync_auto_cast_class","proxyClass","getMethodParams","meta_param_index","tuple","function_body","args_match","args_strings","normalizeFunctionParams","split","i","trim","arg","getMetaParamIndex","nestedIndex","scopes","varCount","x","toSpliced","join","setMethodParamsSource","setMethodMetaIndexSource","datexClass","_class","datex_advanced","auto_sync","new_class","Proxy","construct","args","newTarget","apply","_thisArg","argArray","createOrGet","js_value"],"mappings":"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","sourceRoot":"/lib/datex-core-js-legacy-0.3.15/js_adapter/","file":"js_class_adapter.ts"}