{"version":3,"sources":["object.ts"],"sourcesContent":["// only \"interface\" for all DATEX objects, has special hidden properties (symbols) and static methods for object extending\n\nimport { DX_TYPE, DX_SLOTS, SLOT_WRITE, SLOT_READ, SLOT_EXEC, EXTENDED_OBJECTS, INHERITED_PROPERTIES, SET_PROXY, SHADOW_OBJECT } from \"../runtime/constants.ts\";\nimport { ValueError } from \"./errors.ts\";\nimport { Tuple } from \"./tuple.ts\";\nimport { type_clause } from \"./type.ts\";\nimport { target_clause } from \"./addressing.ts\";\n\n\nexport type CompatObject<T> = Tuple<T>|Record<string|number, T>\n\n\n// base class for all Datex object based types (Record, custom typed values)\nexport abstract class DatexObject {\n\n    private [DX_TYPE]: type_clause\n\n    private [EXTENDED_OBJECTS]: Set<Record<string|symbol,unknown>>;\n    private [INHERITED_PROPERTIES]: Set<string>;\n    private [SET_PROXY]:(k:unknown, v:unknown)=>void\n    private [SHADOW_OBJECT]:Record<string|symbol,unknown>;\n\n\n    // return whether this objects extends an other object (recursive check)\n    static extends(object:Record<string|symbol,unknown>,extends_object:Record<string|symbol,unknown>):boolean {\n        const extended_objects = <Set<Record<string|symbol,unknown>>>object[EXTENDED_OBJECTS];\n        if (!extended_objects) return false; // does not extend any object\n        if (extended_objects.has(extends_object)) return true;\n        // recursive check all extended objects\n        else {\n            for (const ext_object of extended_objects) {\n                if (ext_object[EXTENDED_OBJECTS] && DatexObject.extends(ext_object, extends_object)) {\n                    return true;\n                }\n            }\n            return false;\n        }\n    }\n\n\n    // extend any object (only currently available properties are bound to this object, properties that are added later are ignored)\n    // if update_back is false, changes on this object do not reflect onto the extended object\n    static extend(object:Record<string|symbol,unknown>, extend_object:Record<string|symbol,unknown>, update_back = true):Record<string|symbol,unknown>|void {\n        if (typeof extend_object != \"object\") throw new ValueError(\"Cannot extend an object with a primitive value\");\n        if (typeof object != \"object\" || object == null) throw new ValueError(\"Not an object or null\");\n\n        // add sets\n        if (!object[EXTENDED_OBJECTS]) object[EXTENDED_OBJECTS] = new Set();\n        if (!object[INHERITED_PROPERTIES]) object[INHERITED_PROPERTIES] = new Set();\n\n        // already extends\n        if (DatexObject.extends(object, extend_object)) return;\n\n        // cross referenced extension - not allowed\n        if (DatexObject.extends(extend_object, object)) throw new ValueError(\"Cross-referenced extensions are not allowed\");\n\n        // extended object does not change, just copy key-value pairs\n        if (Object.isFrozen(extend_object) || !update_back) {\n            for (const key of Object.keys(extend_object)) {\n                (<Set<string>>object[INHERITED_PROPERTIES]).add(key);\n                object[key] = extend_object[key];\n            }\n        }\n\n        else {\n            for (const key of Object.keys(extend_object)) {\n                const descriptor = Object.getOwnPropertyDescriptor(object, key);\n                if (!descriptor || descriptor.configurable) {\n                    Object.defineProperty(object, key, <PropertyDescriptor>{\n                        set(v){\n                            extend_object[key] = v;\n                        },\n                        get(){\n                            return extend_object[key]\n                        },\n                        enumerable: true,\n                        configurable: true\n                    })\n                }\n                // cannot define new getter/setters!\n                else {\n                    console.warn(\"Cannot create new getter/setter for extendable object key: \" + key);\n                    object[key] = extend_object[key];\n                }\n                (<Set<string>>object[INHERITED_PROPERTIES]).add(key);\n            }\n        }\n\n        (<Set<Record<string|symbol,unknown>>>object[EXTENDED_OBJECTS]).add(extend_object);\n\n        return object;\n    }\n\n    // always call this method to seal a DatexObject, not Object.seal(...)\n    static seal(object:Record<string|symbol,unknown>){\n        if (Object.isSealed(object)) return; // already sealed\n\n        // add required symbol properties (SET_PROXY)\n        object[SET_PROXY] = undefined;\n\n        // add getter / setter proxies for all properties (not extended properties)\n        // required if DatexObject is a pointer\n        const shadow_object:Record<string|symbol,unknown> = object[SHADOW_OBJECT] = {};\n        for (const key of Object.keys(object)) {\n            // only add if not inherited from an extended object\n            if (!(<Set<string>>object[INHERITED_PROPERTIES])?.has(key)) {\n\n\n                // get descriptor containing getter/setter\n                const property_descriptor = Object.getOwnPropertyDescriptor(object,key);\n\n                // add original getters/setters to shadow_object if they exist (and call with right 'this' context)\n                if (property_descriptor?.set || property_descriptor?.get) {\n                    const descriptor:PropertyDescriptor = {};\n                    if (property_descriptor.set) descriptor.set = val => property_descriptor.set?.call(object,val);\n                    if (property_descriptor.get) descriptor.get = () =>  property_descriptor.get?.call(object)\n\n                    Object.defineProperty(shadow_object, key, descriptor);\n                }\n                else shadow_object[key] = object[key];\n\n                Object.defineProperty(object, key, <PropertyDescriptor>{\n                    set(v){\n                        if (object[SET_PROXY]) (<(k:unknown, v:unknown)=>void>object[SET_PROXY])(key, v); // set via proxy\n                        else shadow_object[key] = v;\n                    },\n                    get(){\n                        return shadow_object[key]\n                    },\n                    enumerable: true,\n                    configurable: false\n                })\n            }\n\n        }\n\n        Object.seal(shadow_object);\n        Object.seal(object);\n        return object;\n    }\n\n    static freeze(object:Record<string|symbol,unknown>){\n        Object.freeze(object);\n        return object;\n    }\n\n\n    // compat methods for object/tuples\n    public static entries(value:Record<string|symbol,unknown>) {\n        if (value instanceof Tuple) return value.entries();\n        else return Object.entries(value)\n    }\n\n    public static keys(value:Record<string|symbol,unknown>) {\n        if (value instanceof Tuple) return value.keys();\n        else return Object.keys(value)\n    }\n\n    public static set(parent:Record<string|symbol,unknown>, key:string|number,value:unknown) {\n        if (parent instanceof Tuple) return parent.set(key, value);\n        else return parent[key] = value;\n    }\n\n    public static get(parent:Record<string|symbol,unknown>, key:string|number) {\n        if (parent instanceof Tuple) return parent.get(key);\n        else return parent[key];\n    }\n\n    public static has(parent:Record<string|symbol,unknown>, key:string|number) {\n        if (parent instanceof Tuple) return parent.has(key);\n        else return (parent && key in parent);\n    }\n\n    // DATEX meta data\n    public static setType(value:Record<string|symbol,unknown>, type:type_clause) {\n        value[DX_TYPE] = type;\n    }\n\n\n    public static setWritePermission(value:Record<string|symbol,unknown>, permission:target_clause|undefined) {\n        if (!value[DX_SLOTS]) value[DX_SLOTS] = new Map();\n        (<Map<number,target_clause|undefined>>value[DX_SLOTS]).set(SLOT_WRITE, permission);\n    }\n\n    public static setReadPermission(value:Record<string|symbol,unknown>, permission:target_clause|undefined) {\n        if (!value[DX_SLOTS]) value[DX_SLOTS] = new Map();\n        (<Map<number,target_clause|undefined>>value[DX_SLOTS]).set(SLOT_READ, permission);\n    }\n\n    public static setExecPermission(value:Record<string|symbol,unknown>, permission:target_clause|undefined) {\n        if (!value[DX_SLOTS]) value[DX_SLOTS] = new Map();\n        (<Map<number,target_clause|undefined>>value[DX_SLOTS]).set(SLOT_EXEC, permission);\n    }\n\n    // get / set methods\n    // get<K extends keyof T>(key:K):T[K] {return (<T><unknown>this)[key];}\n    // set<K extends keyof T, V extends T[K]>(key:K, value:V) {(<T><unknown>this)[key] = value;}\n    // has<K extends keyof T>(key:K) {return this.hasOwnProperty(key);}\n}\n\n\n"],"names":["DX_TYPE","DX_SLOTS","SLOT_WRITE","SLOT_READ","SLOT_EXEC","EXTENDED_OBJECTS","INHERITED_PROPERTIES","SET_PROXY","SHADOW_OBJECT","ValueError","Tuple","DatexObject","extends","object","extends_object","extended_objects","has","ext_object","extend","extend_object","update_back","Set","Object","isFrozen","key","keys","add","descriptor","getOwnPropertyDescriptor","configurable","defineProperty","set","v","get","enumerable","console","warn","seal","isSealed","undefined","shadow_object","property_descriptor","val","call","freeze","entries","value","parent","setType","type","setWritePermission","permission","Map","setReadPermission","setExecPermission"],"mappings":"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","sourceRoot":"/lib/datex-core-js-legacy-0.3.15/types/","file":"object.ts"}