@zcomponent/core 0.0.13 → 0.0.14

package/lib/behavior.d.ts

@@ -7,7 +7,6 @@ export type BehaviorConstructorProps = {
     [id: string]: unknown;
 };
 export declare class Behavior<InstanceType extends Component = Component> extends Entity {
-    protected readonly contextManager: ContextManager;
     readonly instance: InstanceType;
     /**
      * Constructs this behavior

package/lib/behavior.js

@@ -7,8 +7,7 @@ export class Behavior extends Entity {
      * @param instance The instance of the component that this behavior is attached to
      */
     constructor(contextManager, instance) {
-        super();
-        this.contextManager = contextManager;
+        super(contextManager);
         this.instance = instance;
         this._updateEnabledResolved = () => {
             let newValue = this.enabled.value;

package/lib/component.d.ts

@@ -7,7 +7,7 @@ export type ConstructorForComponent<ComponentType extends Component = Component>
 export type ComponentChild<ComponentType extends Component> = [ConstructorForComponent<ComponentType>, ComponentType extends Component<any, infer U> ? U : never] | [
     ConstructorForComponent<ComponentType>,
     ComponentType extends Component<any, infer U> ? U : never,
-    Observable<ComponentType>
+    Observable<ComponentType | undefined>
 ];
 export type ComponentChildren = ComponentChild<Component>[];
 export interface ConstructorProps {
@@ -15,7 +15,6 @@ export interface ConstructorProps {
     children?: ComponentChildren;
 }
 export declare class Component<ElementType = any, ConstructorPropsType extends ConstructorProps = ConstructorProps> extends Entity {
-    readonly contextManager: ContextManager;
     protected constructorProps?: ConstructorPropsType | undefined;
     /**
      * The raw element(s) that this component exposes

package/lib/component.js

@@ -3,8 +3,7 @@ import { Entity } from './entity';
 import { Observable } from './observable';
 export class Component extends Entity {
     constructor(contextManager, constructorProps) {
-        super();
-        this.contextManager = contextManager;
+        super(contextManager);
         this.constructorProps = constructorProps;
         this.children = [];
         /**

package/lib/contexts/canvascontext.d.ts

@@ -5,6 +5,7 @@ export interface CanvasContextOptions {
     canvas?: HTMLCanvasElement;
     overlay?: HTMLDivElement;
 }
+/** @zcontext */
 export declare class CanvasContext extends Context {
     constructorProps: CanvasContextOptions;
     onBeforeRender: Event<[number]>;
@@ -12,6 +13,7 @@ export declare class CanvasContext extends Context {
     canvas: HTMLCanvasElement;
     overlayDefault: HTMLDivElement;
     overlay: Observable<HTMLDivElement>;
+    /** @zui */
     size: Observable<[number, number]>;
     private _resizeObserver;
     constructor(contextManager: ContextManager, constructorProps: CanvasContextOptions);

package/lib/contexts/canvascontext.js

@@ -1,6 +1,7 @@
 import { Context } from '../context';
 import { Event } from '../event';
 import { Observable } from '../observable';
+/** @zcontext */
 export class CanvasContext extends Context {
     constructor(contextManager, constructorProps) {
         super(contextManager, constructorProps);

package/lib/contexts/environmentcontext.d.ts

@@ -1,9 +1,19 @@
 import { ContextManager, Context } from '../context';
 import { Observable } from '../observable';
+/** @zcontext */
 export declare class EnvironmentContext extends Context {
+    /** @zprop */
     designTime: Observable<boolean, never>;
+    /** @zprop */
     editTime: Observable<boolean, never>;
+    /** @zprop */
+    runTime: Observable<boolean, never>;
+    /** @zprop */
+    developmentBuild: Observable<boolean, never>;
+    /** @zprop */
+    productionBuild: Observable<boolean, never>;
 }
 export declare function isDesignTime(ctx: ContextManager): boolean;
 export declare function isEditTime(ctx: ContextManager): boolean;
 export declare function isDevelopmentBuild(ctx: ContextManager): boolean;
+export declare function isProductionBuild(ctx: ContextManager): boolean;

package/lib/contexts/environmentcontext.js

@@ -1,10 +1,19 @@
 import { Context } from '../context';
 import { Observable } from '../observable';
+/** @zcontext */
 export class EnvironmentContext extends Context {
     constructor() {
         super(...arguments);
+        /** @zprop */
         this.designTime = new Observable(false);
+        /** @zprop */
         this.editTime = new Observable(false);
+        /** @zprop */
+        this.runTime = new Observable(true);
+        /** @zprop */
+        this.developmentBuild = new Observable(typeof process !== 'undefined' && process?.env?.NODE_ENV === 'development');
+        /** @zprop */
+        this.productionBuild = new Observable(!this.developmentBuild.value);
     }
 }
 export function isDesignTime(ctx) {
@@ -14,5 +23,8 @@ export function isEditTime(ctx) {
     return ctx.get(EnvironmentContext).editTime.value;
 }
 export function isDevelopmentBuild(ctx) {
-    return (typeof process !== 'undefined' && process?.env?.NODE_ENV === 'development');
+    return ctx.get(EnvironmentContext).developmentBuild.value;
+}
+export function isProductionBuild(ctx) {
+    return ctx.get(EnvironmentContext).productionBuild.value;
 }

package/lib/contexts/loadcontext.d.ts

@@ -1,9 +1,14 @@
 import { ContextManager, Context } from '../context';
 import { Observable } from '../observable';
+/** @zcontext */
 export declare class LoadContext extends Context {
+    /** @zui */
     isConstructed: Observable<boolean, never>;
+    /** @zui */
     isLoaded: Observable<boolean, never>;
+    /** @zui */
     isStarted: Observable<boolean, never>;
+    /** @zui */
     progressPercent: Observable<number, never>;
     private _startedResolved;
     started: Promise<void>;

package/lib/contexts/loadcontext.js

@@ -1,11 +1,16 @@
 import { Context } from '../context';
 import { Observable } from '../observable';
+/** @zcontext */
 export class LoadContext extends Context {
     constructor() {
         super(...arguments);
+        /** @zui */
         this.isConstructed = new Observable(false);
+        /** @zui */
         this.isLoaded = new Observable(false);
+        /** @zui */
         this.isStarted = new Observable(false);
+        /** @zui */
         this.progressPercent = new Observable(0);
         this.started = new Promise(resolve => this._startedResolved = resolve);
         this._loadables = new Set();

package/lib/data.d.ts

@@ -1,8 +1,13 @@
-import { BehaviorByID, BehaviorData, ComputedHierarchy, NodeByID, NodeData, ZComponentData } from "./interfaces";
+import { BehaviorByID, BehaviorData, ComputedHierarchy, EntityPropOverride, NodeByID, NodeData, ZComponentData } from "./interfaces";
+import { Prop } from "./types";
 export declare function computeNodeHierarchy(nodes: NodeByID): ComputedHierarchy;
 export declare function computeBehaviorHierarchy(behaviors: BehaviorByID): ComputedHierarchy;
 export declare function addNode(zcomp: ZComponentData, info: NodeDataCombined): void;
 export declare function addBehavior(zcomp: ZComponentData, info: BehaviorDataCombined): void;
+export declare function updateComponentProp(zcomp: ZComponentData, prop: string, isConstructorProp: boolean, newValue: Prop | undefined, newIsConstructorProp: boolean): void;
+export declare function addEntityPropOverride(zcomp: ZComponentData, o: EntityPropOverride): void;
+export declare function deleteEntityPropOverride(zcomp: ZComponentData, id: string): void;
+export declare function clone<T>(obj: T): T;
 export declare function addEntity(zcomp: ZComponentData, id: string, info: EntityDataCombined): void;
 export declare function moveNodes(zcomp: ZComponentData, nodeIDs: string[], newParentID: string, indx: number): void;
 export declare function deleteNode(zcomp: ZComponentData, id: string): void;

package/lib/data.js

@@ -1,4 +1,5 @@
 import { generateKeyBetween, generateNKeysBetween } from "./fractionalindexing";
+import { EntityPropOverrideType } from "./interfaces";
 // Simple memoizing of computed hierarchy
 const computedHierarchies = new Map();
 const computedBehaviors = new Map();
@@ -66,6 +67,80 @@ export function addBehavior(zcomp, info) {
     addEntity(zcomp, info.data.id, info);
     computedBehaviors.delete(zcomp.behaviors);
 }
+export function updateComponentProp(zcomp, prop, isConstructorProp, newValue, newIsConstructorProp) {
+    if (zcomp.constructorProps === undefined)
+        zcomp.constructorProps = {};
+    if (newValue === undefined) {
+        if (isConstructorProp)
+            delete zcomp.constructorProps[prop];
+        else
+            delete zcomp.props[prop];
+        if (zcomp.entityPropOverrides) {
+            for (const [id, override] of Object.entries(zcomp.entityPropOverrides)) {
+                if (override.type !== EntityPropOverrideType.ComponentProp)
+                    continue;
+                if (override.isConstructorProp !== isConstructorProp)
+                    continue;
+                if (override.propName !== prop)
+                    continue;
+                delete zcomp.entityPropOverrides[id];
+            }
+        }
+        return;
+    }
+    if (newValue.name !== prop || isConstructorProp !== newIsConstructorProp) {
+        if (isConstructorProp)
+            delete zcomp.constructorProps[prop];
+        else
+            delete zcomp.props[prop];
+        if (zcomp.entityPropOverrides) {
+            for (const [id, override] of Object.entries(zcomp.entityPropOverrides)) {
+                if (override.type !== EntityPropOverrideType.ComponentProp)
+                    continue;
+                if (override.isConstructorProp !== isConstructorProp)
+                    continue;
+                if (override.propName !== prop)
+                    continue;
+                delete zcomp.entityPropOverrides[id];
+                if (!(override.entityPropIsConstructor && !newIsConstructorProp)) {
+                    const newOverride = clone(override);
+                    newOverride.propName = newValue.name;
+                    newOverride.id = idForEntityPropOverride(override);
+                    zcomp.entityPropOverrides[newOverride.id] = newOverride;
+                }
+            }
+        }
+    }
+    newValue.type.isObservable = !newIsConstructorProp;
+    if (newIsConstructorProp)
+        zcomp.constructorProps[newValue.name] = newValue;
+    else
+        zcomp.props[newValue.name] = newValue;
+}
+export function addEntityPropOverride(zcomp, o) {
+    if (!zcomp.entityPropOverrides)
+        zcomp.entityPropOverrides = {};
+    o.id = idForEntityPropOverride(o);
+    zcomp.entityPropOverrides[o.id] = o;
+}
+export function deleteEntityPropOverride(zcomp, id) {
+    if (!zcomp.entityPropOverrides)
+        return;
+    delete zcomp.entityPropOverrides[id];
+}
+function idForEntityPropOverride(override) {
+    return override.type + ":" + (override.entityPropIsConstructor ? 'constructorprop' : 'prop') + ":" + override.entityID + ":" + override.entityPropPath.join('.');
+}
+export function clone(obj) {
+    try {
+        if (typeof structuredClone !== 'undefined')
+            return structuredClone(obj);
+    }
+    catch {
+        // Ignore
+    }
+    return JSON.parse(JSON.stringify(obj));
+}
 export function addEntity(zcomp, id, info) {
     zcomp.entityProps[id] = info.props;
     zcomp.entityConstructorProps[id] = info.constructorProps;
@@ -265,6 +340,13 @@ export function changeNodeScriptName(zcomp, id, newScriptName) {
 export function deleteEntity(zcomp, id) {
     delete zcomp.entityProps[id];
     delete zcomp.entityConstructorProps[id];
+    if (zcomp.entityPropOverrides) {
+        for (const [overrideID, override] of Object.entries(zcomp.entityPropOverrides)) {
+            if (override.entityID !== id)
+                continue;
+            delete zcomp.entityPropOverrides[overrideID];
+        }
+    }
 }
 export function forEachNodeAncestor(zcomp, id, fn) {
     const node = zcomp.nodes[id];

package/lib/entity.d.ts

@@ -1,8 +1,10 @@
 import { ConstructorForComponent } from "./component";
+import { ContextManager } from "./context";
 import { Event } from "./event";
 import { Observable } from "./observable";
 import { ZComponent } from "./zcomponent";
 export declare class Entity {
+    readonly contextManager: ContextManager;
     private _registered;
     private _zcomponent;
     private _disposed;
@@ -10,7 +12,7 @@ export declare class Entity {
      * An event that is fired as the last act of this entity being destroyed.
      */
     readonly onDispose: Event<[]>;
-    constructor();
+    constructor(contextManager: ContextManager);
     get disposed(): boolean;
     private set disposed(value);
     /**

package/lib/entity.js

@@ -2,7 +2,8 @@ import { Event } from "./event";
 import { Observable } from "./observable";
 import { getCurrentZComponentConstruction } from "./zcomponentconstruction";
 export class Entity {
-    constructor() {
+    constructor(contextManager) {
+        this.contextManager = contextManager;
         this._registered = [];
         this._disposed = false;
         /**
@@ -73,6 +74,10 @@ export class Entity {
         throw new Error("getZComponentInstance called in entity passing wrong kind of ZComponent");
     }
     register(e, fn) {
+        for (const entry of this._registered) {
+            if (entry[0] === e && entry[1] === fn)
+                return;
+        }
         if (e instanceof Event)
             e.bindfn(fn);
         else if (e instanceof Observable)

package/lib/interfaces.d.ts

@@ -29,15 +29,12 @@ export interface ZComponentData {
     nodes: NodeByID;
     root: string;
     props: Props;
+    constructorProps?: Props;
     entityProps: PropsByID;
     entityConstructorProps: PropsByID;
     preview: Import;
-    propEntityOverrides?: {
-        [propName: string]: {
-            [entityID: string]: {
-                [propName: string]: boolean;
-            };
-        };
+    entityPropOverrides?: {
+        [id: string]: EntityPropOverride;
     };
     behaviors: BehaviorByID;
     animation?: Animation;
@@ -70,3 +67,30 @@ export interface BehaviorData {
         order: string;
     };
 }
+export type EntityPropOverride = PropEntityPropOverride | ImportEntityPropOverride | ContextValueEntityPropOverride;
+export declare enum EntityPropOverrideType {
+    ComponentProp = "componentprop",
+    Import = "import",
+    ContextValue = "contextvalue"
+}
+export interface BaseEntityPropOverride {
+    id: string;
+    entityID: string;
+    entityPropPath: (string | number)[];
+    entityPropIsConstructor: boolean;
+    type: EntityPropOverrideType;
+}
+export interface PropEntityPropOverride extends BaseEntityPropOverride {
+    propName: string;
+    isConstructorProp: boolean;
+    type: EntityPropOverrideType.ComponentProp;
+}
+export interface ImportEntityPropOverride extends BaseEntityPropOverride {
+    imp: string;
+    type: EntityPropOverrideType.Import;
+}
+export interface ContextValueEntityPropOverride extends BaseEntityPropOverride {
+    imp: string;
+    val: string;
+    type: EntityPropOverrideType.ContextValue;
+}

package/lib/interfaces.js

@@ -1 +1,6 @@
-export {};
+export var EntityPropOverrideType;
+(function (EntityPropOverrideType) {
+    EntityPropOverrideType["ComponentProp"] = "componentprop";
+    EntityPropOverrideType["Import"] = "import";
+    EntityPropOverrideType["ContextValue"] = "contextvalue";
+})(EntityPropOverrideType || (EntityPropOverrideType = {}));

package/lib/selectors.d.ts

@@ -1,4 +1,4 @@
-import { Import, NodeByID, ParsedImport, Props } from './interfaces';
+import { EntityPropOverride, Import, NodeByID, ParsedImport, Props } from './interfaces';
 export declare function parseImport(i: Import): ParsedImport;
 export declare function constructImport(from: string, destFile: string, imp: string): string;
 export declare function getScriptName(n: string, requireUniqueIn: {
@@ -6,8 +6,20 @@ export declare function getScriptName(n: string, requireUniqueIn: {
 }): string;
 export declare function isValidVariableName(n: string): boolean;
 export declare function variableNameFromImport(imp: ParsedImport): string;
-export declare const typeDefinitionForComponent: (nodes: NodeByID, props: Props, scriptNames: {
+export type EntityPropOverrideByEntityPropPath = {
+    [entityID: string]: {
+        [propName: string]: {
+            [path: string]: EntityPropOverride;
+        };
+    };
+};
+export declare function entityPropOverrideByEntityAndProp(entityPropOverrides: {
+    [id: string]: EntityPropOverride;
+}): EntityPropOverrideByEntityPropPath;
+export declare function summaryForEntityPropOverrideDestination(o: EntityPropOverride): string;
+export declare const typeDefinitionForComponent: (nodes: NodeByID, props: Props, constructorProps: Props | undefined, scriptNames: {
     [id: string]: {
         [id: string]: boolean;
     };
-}, url: string) => string;
+} | undefined, url: string) => string;
+export declare function getSafeKeyName(n: string): string;

package/lib/selectors.js

@@ -1,3 +1,4 @@
+import { EntityPropOverrideType } from './interfaces';
 import * as path from 'path';
 import { outputForType } from './types';
 export function parseImport(i) {
@@ -117,11 +118,52 @@ export function variableNameFromImport(imp) {
         return imp[1];
     return 'unknown';
 }
-export const typeDefinitionForComponent = (nodes, props, scriptNames, url) => {
+export function entityPropOverrideByEntityAndProp(entityPropOverrides) {
+    const ret = Object.create(null);
+    for (const val of Object.values(entityPropOverrides)) {
+        if (!Array.isArray(val.entityPropPath) || val.entityPropPath.length < 1)
+            continue;
+        const obj = ret[val.entityID] || Object.create(null);
+        ret[val.entityID] = obj;
+        const propName = val.entityPropPath[0];
+        const arr = obj[propName] || Object.create(null);
+        obj[propName] = arr;
+        arr[val.entityPropPath.join('.')] = val;
+    }
+    return ret;
+}
+export function summaryForEntityPropOverrideDestination(o) {
+    switch (o.type) {
+        case EntityPropOverrideType.ComponentProp:
+            return 'Component Prop: ' + o.propName;
+        case EntityPropOverrideType.ContextValue: {
+            const imp = parseImport(o.imp);
+            if (imp[1] === 'default' && typeof imp[0] === 'string') {
+                const parts = imp[0].split(path.sep);
+                return parts[parts.length - 1] + '.' + o.val;
+            }
+            if (typeof imp[1] === 'string')
+                return imp[1] + '.' + o.val;
+            return `?.` + o.val;
+        }
+        case EntityPropOverrideType.Import: {
+            return o.imp;
+            // const imp = parseImport(o.imp);
+            // if (imp[1] === 'default' && typeof imp[0] === 'string') {
+            // 	const parts = imp[0].split(path.sep);
+            // 	return parts[parts.length - 1];
+            // }
+            // if (typeof imp[1] === 'string') return imp[1];
+            // return '?';
+        }
+    }
+    return '?';
+}
+export const typeDefinitionForComponent = (nodes, props, constructorProps, scriptNames, url) => {
     const importMapping = new Map();
     let indx = 0;
     let importStrings = [];
-    for (const scriptNameNodes of Object.values(scriptNames)) {
+    for (const scriptNameNodes of Object.values(scriptNames ?? {})) {
         for (const nodeID of Object.keys(scriptNameNodes)) {
             const node = nodes[nodeID];
             if (!node)
@@ -139,15 +181,20 @@ export const typeDefinitionForComponent = (nodes, props, scriptNames, url) => {
 
 ${importStrings.join('\n')}
 
+interface ConstructorProps {
+${Object.values(constructorProps ?? {}).map(typeOutputForConstructorProp).join('\n\n')}
+}
+
 /**
 * @zcomponent
+* @zicon zcomponent
 */
 declare class Comp extends ZComponent {
 
-	constructor(contextManager: ContextManager, constructorProps: {});
+	constructor(contextManager: ContextManager, constructorProps: ConstructorProps);
 
 	nodes: {
-${Object.entries(scriptNames).map(entry => {
+${Object.entries(scriptNames ?? {}).map(entry => {
         const values = Object.keys(entry[1]);
         if (values.length > 1) {
             return `\t\t${entry[0]}: {${values.map(e => `${JSON.stringify(e)}: ${importMapping.get(nodes[e].type)}`).join(', ')}},`;
@@ -158,16 +205,40 @@ ${Object.entries(scriptNames).map(entry => {
     }).join("\n")}
 	};
 
-${Object.values(props).map(typeOutputForProp).join('\n')}
+${Object.values(props).map(typeOutputForProp).join('\n\n')}
 }
 
 export default Comp;
 `;
 };
+function makeCommentSafe(c) {
+    return c.replaceAll('*/', '').split('\n').join('\n\t* ');
+}
 function typeOutputForProp(prop) {
-    return `	/**
+    const comments = (prop.comments && prop.comments.length > 0) ? '\n\t* ' + prop.comments.map(makeCommentSafe).join('\n\t*\n\t* ') + '\n\t* ' : '';
+    return `	/**${comments}
 	* @zprop
-	* ${prop.default && `@zdefault ${JSON.stringify(prop.default)}`}
+	* ${prop.default ? `@zdefault ${JSON.stringify(prop.default)}` : ''}
 	*/
 	public ${prop.name}: Observable<${outputForType(prop.type, true)}>;`;
 }
+function typeOutputForConstructorProp(prop) {
+    const comments = (prop.comments && prop.comments.length > 0) ? '\n\t* ' + prop.comments.map(makeCommentSafe).join('\n\t*\n\t* ') + '\n\t* ' : '';
+    return `	/**${comments}
+	* @zprop
+	* ${prop.default && `@zdefault ${JSON.stringify(prop.default)}`}
+	*/
+	${prop.name}: ${outputForType(prop.type, true)};`;
+}
+export function getSafeKeyName(n) {
+    if (n.length === 0)
+        return '_';
+    let scriptname = n.replace(' ', '_');
+    scriptname = scriptname.replace('-', '_');
+    scriptname = scriptname.replace('.', '_');
+    scriptname = scriptname.replace(/[^a-zA-Z0-9_]/g, '');
+    if (scriptname.match(/^[0-9]/)) {
+        scriptname = 'n' + scriptname;
+    }
+    return scriptname;
+}

package/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { EntityPropOverride } from "./interfaces";
 export interface BaseType {
     comments?: string[];
     typeHint?: TypeHint;
@@ -69,10 +70,18 @@ export interface Prop {
     groupPriority?: number;
     values?: Values[];
 }
+export interface DefaultChild {
+    label: string;
+    type: string;
+    initialProps: {
+        [id: string]: any;
+    };
+}
+export type ComponentInfoType = "component" | "behavior" | "context";
 export interface ComponentInfo {
     name: string;
     file: string;
-    type: "component" | "behavior";
+    type: ComponentInfoType;
     isDefault?: boolean;
     constructorProps: {
         [id: string]: Prop;
@@ -86,10 +95,23 @@ export interface ComponentInfo {
     tags: string[];
     allowedChildren: string[];
     allowedParents?: string[];
+    defaultChildren?: DefaultChild[];
+}
+export interface ValueInfo {
+    name: string;
+    file: string;
+    isDefault?: boolean;
+    type: Type;
+    comments?: string[];
+}
+export interface SourceFileTypeInfo {
+    components: {
+        [id: string]: ComponentInfo;
+    };
+    values: {
+        [id: string]: ValueInfo;
+    };
 }
-export type SourceFileTypeInfo = {
-    [id: string]: ComponentInfo;
-};
 export type TypeInfoByFileName = {
     [id: string]: SourceFileTypeInfo;
 };
@@ -105,3 +127,8 @@ export interface TemplateInfo {
 export declare function symbolPathFromFilename(f: string): string;
 export declare function isValidValueForType(def: any, t: Type, allowUndefined?: boolean): boolean;
 export declare function outputForType(t: Type, alwaysBasic?: boolean): string;
+export declare function overridesAreCompatible(a: {
+    [path: string]: EntityPropOverride;
+}, b: {
+    [path: string]: EntityPropOverride;
+}): boolean;

package/lib/types.js

@@ -1,3 +1,5 @@
+import { EntityPropOverrideType } from "./interfaces";
+import { getSafeKeyName } from "./selectors";
 export var TypeHint;
 (function (TypeHint) {
     TypeHint["proportion"] = "proportion";
@@ -291,6 +293,9 @@ function getBasicType(t) {
         case 'array':
             return outputForType(t.child) + '[]';
         case 'tuple':
+            if (Array.isArray(t.names) && t.names.length === t.children.length) {
+                return `[${t.children.map((c, indx) => `${getSafeKeyName(t.names[indx])}: ${outputForType(c)}`).join(', ')}]`;
+            }
             return `[${t.children.map(c => outputForType(c)).join(', ')}]`;
         case 'unknown':
             return 'any';
@@ -310,3 +315,59 @@ function getBasicType(t) {
             return 'Event';
     }
 }
+export function overridesAreCompatible(a, b) {
+    const bkeys = new Set(Object.keys(b));
+    for (const [p, obj] of Object.entries(a)) {
+        if (!b[p])
+            return false;
+        if (!overrideAreCompatible(obj, b[p]))
+            return false;
+        bkeys.delete(p);
+    }
+    if (bkeys.size > 0)
+        return false;
+    return true;
+}
+function overrideAreCompatible(a, b) {
+    if (a && b) {
+        if (a.type !== b.type)
+            return false;
+        if (a.entityPropPath.length !== b.entityPropPath.length)
+            return false;
+        if (a.entityPropIsConstructor !== b.entityPropIsConstructor)
+            return false;
+        for (let i = 0; i < a.entityPropPath.length; i++) {
+            if (a.entityPropPath[i] !== b.entityPropPath[i])
+                return false;
+        }
+        switch (a.type) {
+            case EntityPropOverrideType.ComponentProp: {
+                const bt = b;
+                if (a.isConstructorProp !== bt.isConstructorProp)
+                    return false;
+                if (a.propName !== bt.propName)
+                    return false;
+                return true;
+            }
+            case EntityPropOverrideType.ContextValue: {
+                const bt = b;
+                if (a.imp !== bt.imp)
+                    return false;
+                if (a.val !== bt.val)
+                    return false;
+                return true;
+            }
+            case EntityPropOverrideType.Import: {
+                const bt = b;
+                if (a.imp !== bt.imp)
+                    return false;
+                return true;
+            }
+        }
+    }
+    if (!a && b)
+        return false;
+    if (a && !b)
+        return false;
+    return true;
+}

package/lib/zcomponent.d.ts

@@ -1,5 +1,6 @@
 import { Component, ComponentChildren, ConstructorProps } from './component';
 import { ContextManager, Context } from './context';
+import { Entity } from './entity';
 import { ZComponentData } from './interfaces';
 export interface ZComponentOptions {
     data: ZComponentData;
@@ -35,21 +36,25 @@ export declare class ZComponent<RootType = any> extends Component<RootType> {
     nodes: {
         [id: string]: Component | Component[];
     };
-    entityByID: Map<string, any>;
-    entityByLabel: Map<string, any>;
+    entityByID: Map<string, Entity>;
+    entityByLabel: Map<string, Entity>;
     private _constructedResolve;
     constructed: Promise<void>;
     isConstructed: boolean;
     private _nodesById;
     private _behaviorsToInitialize;
+    private _constructorPropOverridesByEntityID;
     constructor(contextManager: ContextManager, constructorProps: ConstructorProps, _opts: ZComponentOptions);
     private _constructorForNode;
     private _constructorForBehavior;
     private _inflateBehaviors;
     private _wrapBehaviors;
     notifyPropsChanged(entries: Map<string, Set<string>>): void;
+    private _initializeOverrides;
+    private _initializeConstructorPropOverrides;
     private _initializeComponentProps;
     private _setEntityProp;
+    private _setEntityPropPath;
     _getNodeById(id: string): Component | undefined;
     dispose(): never;
 }

package/lib/zcomponent.js

@@ -4,6 +4,7 @@ import { Context } from './context';
 import { isDesignTime } from './contexts/environmentcontext';
 import { TagContext } from './contexts/tagcontext';
 import { computeBehaviorHierarchy, computeNodeHierarchy } from './data';
+import { EntityPropOverrideType } from './interfaces';
 import { Observable } from './observable';
 import { setCurrentZComponentConstruction } from './zcomponentconstruction';
 export class ZComponentContext extends Context {
@@ -26,8 +27,10 @@ export class ZComponent extends Component {
         this.isConstructed = false;
         this._nodesById = new Map();
         this._behaviorsToInitialize = [];
+        this._constructorPropOverridesByEntityID = new Map();
         const contextManagerForChildren = contextManager.forkMultiple([ZComponentContext, { zcomponent: this }], [TagContext, {}])[0];
         this.id = this._opts.data.id;
+        this._initializeConstructorPropOverrides();
         const rootConstructor = this._constructorForNode(this._opts.data.root);
         if (rootConstructor) {
             this.constructChildren([
@@ -36,6 +39,7 @@ export class ZComponent extends Component {
         }
         this._inflateBehaviors();
         this._initializeComponentProps();
+        this._initializeOverrides();
         this.isConstructed = true;
         this._constructedResolve();
     }
@@ -65,6 +69,7 @@ export class ZComponent extends Component {
                     ...constructorProps,
                     ...(that._opts.data.entityConstructorProps?.[nodeId] ?? {}),
                     ...(that._opts.constructorPropReplacement?.[nodeId] ?? {}),
+                    ...(that._constructorPropOverridesByEntityID.get(nodeId) ?? {}),
                     children
                 };
                 setCurrentZComponentConstruction(that);
@@ -145,6 +150,7 @@ export class ZComponent extends Component {
                     ...constructorProps,
                     ...(that._opts.data.entityConstructorProps?.[behaviorId] ?? {}),
                     ...(that._opts.constructorPropReplacement?.[behaviorId] ?? {}),
+                    ...(that._constructorPropOverridesByEntityID.get(behaviorId) ?? {}),
                 };
                 setCurrentZComponentConstruction(that);
                 super(contextManager, instance, constructorProps);
@@ -205,26 +211,84 @@ export class ZComponent extends Component {
             }
         }
     }
-    _initializeComponentProps() {
-        const componentProps = this._opts.data.propEntityOverrides ?? {};
-        for (const [prop, entry] of Object.entries(componentProps)) {
-            const propInfo = this._opts.data.props[prop];
-            const entries = Object.entries(entry).map(e => [e[0], Object.keys(e[1])]);
-            this[prop] = new Observable(propInfo?.default, v => {
-                for (const e of entries) {
-                    const entity = this.entityByID.get(e[0]);
-                    if (!entity)
-                        continue;
-                    for (const overriddenProp of e[1]) {
-                        try {
-                            this._setEntityProp(entity, overriddenProp, v);
-                        }
-                        catch (err) {
-                            console.log('Warning - unable to set prop', overriddenProp, v);
+    _initializeOverrides() {
+        const overrides = this._opts.data.entityPropOverrides ?? {};
+        for (const override of Object.values(overrides)) {
+            const entity = this.entityByID.get(override.entityID);
+            if (!entity)
+                continue;
+            try {
+                switch (override.type) {
+                    case EntityPropOverrideType.Import: {
+                        const v = this._opts.importMapping[override.imp]?.();
+                        if (!v)
+                            continue;
+                        if (v instanceof Observable)
+                            v.withValue(val => this._setEntityPropPath(entity, override.entityPropPath, val));
+                        else
+                            this._setEntityPropPath(entity, override.entityPropPath, v);
+                        break;
+                    }
+                    case EntityPropOverrideType.ContextValue: {
+                        const ctx = this._opts.importMapping[override.imp]?.();
+                        const ctxInstance = entity.contextManager.getOrThrow(ctx);
+                        const v = ctxInstance[override.val];
+                        if (!v)
+                            continue;
+                        if (v instanceof Observable)
+                            v.withValue(val => this._setEntityPropPath(entity, override.entityPropPath, val));
+                        else
+                            this._setEntityPropPath(entity, override.entityPropPath, v);
+                        break;
+                    }
+                    case EntityPropOverrideType.ComponentProp: {
+                        if (override.isConstructorProp) {
+                            const prop = this._opts.data.constructorProps?.[override.propName];
+                            if (!prop)
+                                break;
+                            const val = this.constructorProps[override.propName] ?? prop.default;
+                            if (val !== undefined)
+                                this._setEntityPropPath(entity, override.entityPropPath, val);
+                            break;
                         }
+                        const v = this[override.propName];
+                        if (!v)
+                            continue;
+                        if (v instanceof Observable)
+                            v.withValue(val => this._setEntityPropPath(entity, override.entityPropPath, val));
+                        else
+                            this._setEntityPropPath(entity, override.entityPropPath, v);
+                        break;
                     }
                 }
-            });
+            }
+            catch (err) {
+                console.log('Unable to set entity prop override', err);
+            }
+        }
+    }
+    _initializeConstructorPropOverrides() {
+        for (const entry of Object.values(this._opts.data.entityPropOverrides ?? {})) {
+            if (entry.type !== EntityPropOverrideType.ComponentProp)
+                continue;
+            if (!entry.isConstructorProp)
+                continue;
+            if (entry.entityPropPath.length !== 1)
+                continue;
+            const obj = this._constructorPropOverridesByEntityID.get(entry.entityID) ?? Object.create(null);
+            this._constructorPropOverridesByEntityID.set(entry.entityID, obj);
+            const prop = this._opts.data.constructorProps?.[entry.propName];
+            if (!prop)
+                continue;
+            const val = this.constructorProps[entry.propName] ?? prop.default;
+            if (val !== undefined)
+                obj[entry.entityPropPath[0]] = val;
+        }
+    }
+    _initializeComponentProps() {
+        const componentProps = this._opts.data.props ?? {};
+        for (const prop of Object.values(componentProps)) {
+            this[prop.name] = new Observable(prop.default);
         }
     }
     _setEntityProp(entity, prop, v) {
@@ -233,6 +297,22 @@ export class ZComponent extends Component {
         else
             entity[prop] = v;
     }
+    _setEntityPropPath(entity, propPath, v) {
+        if (propPath.length < 1)
+            return;
+        const prop = propPath[0];
+        let parent = entity;
+        let currentKey = prop;
+        if (entity[prop] instanceof Observable) {
+            parent = entity[prop];
+            currentKey = 'value';
+        }
+        for (let i = 1; i < propPath.length; i++) {
+            parent = parent[currentKey];
+            currentKey = propPath[i];
+        }
+        parent[currentKey] = v;
+    }
     _getNodeById(id) {
         return this._nodesById.get(id);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomponent/core",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -30,10 +30,11 @@
     "@types/ua-parser-js": "^0.7.36",
     "parcel": "^2.8.2",
     "typescript": "^4.9.4",
-    "ua-parser-js": "^1.0.2"
+    "ua-parser-js": "^1.0.33"
   },
   "zexports": [
     "./lib/components/**/*",
-    "./lib/behaviors/**/*"
+    "./lib/behaviors/**/*",
+    "./lib/contexts/**/*"
   ]
 }