@zcomponent/core 1.14.1-beta → 1.14.3-beta

package/lib/animation/animation.d.ts

@@ -34,7 +34,7 @@ export declare class Animation {
     private _spotlightLayer?;
     timeSource: (() => number) | undefined;
     private _entityPaths;
-    private _defaultValues;
+    private _defaultValuesByPath;
     /** @internal */
     _pendingEvents: {
         evt: AnimationEvents;
@@ -49,17 +49,15 @@ export declare class Animation {
     removeLayer(l: Layer): void;
     initialize(): void;
     tick(): void;
-    registerEntityPath(path: string, entity: any, pathParts: (string | number)[]): void;
+    registerEntityProperty(path: string, entity: any, property: string | number): void;
     evaluateTouchedPaths(paths: string[], t?: number): void;
-    private _evaluateLayer;
     get spotlightLayer(): Layer | undefined;
     set spotlightLayer(l: Layer | undefined);
     clearCachedDefault(entityID: string, prop: string): void;
     private _emitPendingEvents;
-    private _resolvePath;
     start(): void;
 }
 export interface EntityPath {
     entity: any;
-    pathParts: (string | number)[];
+    property: string | number;
 }

package/lib/animation/animation.js

@@ -22,7 +22,7 @@ export class Animation {
         this.hasLayers = new Observable(false);
         this._layers = [];
         this._entityPaths = new Map();
-        this._defaultValues = new Map();
+        this._defaultValuesByPath = new Map();
         /** @internal */
         this._pendingEvents = [];
     }
@@ -87,7 +87,7 @@ export class Animation {
     tick() {
         if (!this._initialize)
             return;
-        const t = this.timeSource?.() ?? performance.now();
+        const t = Math.floor(this.timeSource?.() ?? performance.now());
         const touchedPaths = [];
         if (this._spotlightLayer) {
             this._spotlightLayer.tick(t, touchedPaths);
@@ -100,66 +100,40 @@ export class Animation {
         this.evaluateTouchedPaths(touchedPaths, t);
         this.onTick.emit();
     }
-    registerEntityPath(path, entity, pathParts) {
-        this._entityPaths.set(path, { entity, pathParts });
+    registerEntityProperty(path, entity, property) {
+        this._entityPaths.set(path, { entity, property });
     }
     evaluateTouchedPaths(paths, t) {
         if (!this._initialize)
             return;
-        t = t ?? this.timeSource?.() ?? performance.now();
+        t = t ?? Math.floor(this.timeSource?.() ?? performance.now());
         const unique = new Set([...paths]);
         const uniqueAsArray = unique.values();
-        const resolvedPaths = [...uniqueAsArray].map(entry => this._resolvePath(entry));
-        for (const entry of resolvedPaths) {
-            if (!entry)
+        for (const entry of uniqueAsArray) {
+            const entityPath = this._entityPaths.get(entry);
+            if (!entityPath)
                 continue;
-            let byEntity = this._defaultValues.get(entry[0]);
-            if (!byEntity) {
-                byEntity = new Map();
-                this._defaultValues.set(entry[0], byEntity);
+            const prop = entityPath.entity[entityPath.property];
+            const propIsObservable = prop instanceof Observable;
+            let def = this._defaultValuesByPath.get(entry);
+            if (!def) {
+                const val = propIsObservable ? prop.value : prop;
+                def = new Observable(val);
+                this._defaultValuesByPath.set(entry, def);
             }
-            let observable = byEntity.get(entry[1][0]);
-            if (!observable) {
-                let val = entry[0][entry[1][0]];
-                if (val instanceof Observable)
-                    val = val.value;
-                observable = new Observable(val);
-                byEntity.set(entry[1][0], observable);
+            let val = def.value;
+            for (const layer of this._layers) {
+                if (!layer.influencedPaths.has(entry))
+                    continue;
+                val = layer.computePathProperty(t, entry, val);
             }
-            entry[2] = observable;
-        }
-        // Reset our working values to default
-        for (const p of resolvedPaths) {
-            if (p?.[2])
-                p[2].value = undefined;
-        }
-        if (this._spotlightLayer)
-            this._evaluateLayer(t, this._spotlightLayer, resolvedPaths);
-        else {
-            for (const layer of this._layers)
-                this._evaluateLayer(t, layer, resolvedPaths);
-        }
-        for (const entry of resolvedPaths) {
-            if (!entry?.[2])
-                continue;
-            if (entry[0][entry[1][0]] instanceof Observable)
-                entry[0][entry[1][0]].value = entry[2].value;
+            if (propIsObservable)
+                prop.value = val;
             else
-                entry[0][entry[1][0]] = entry[2].value;
+                entityPath.entity[entityPath.property] = val;
         }
         this._emitPendingEvents();
     }
-    _evaluateLayer(t, layer, paths) {
-        for (const p of paths) {
-            if (!p?.[2])
-                continue;
-            if (!layer.influencedPaths.has(p[3]))
-                continue;
-            let val = getResolved(p[2], p[1]);
-            val = layer.computePathProperty(t, p[3], val);
-            setResolved(p[2], p[1], val);
-        }
-    }
     get spotlightLayer() {
         return this._spotlightLayer;
     }
@@ -181,11 +155,7 @@ export class Animation {
             this.hasLayers.value = hasLayers;
     }
     clearCachedDefault(entityID, prop) {
-        const prefix = entityID + '.' + prop;
-        for (const entityPath of this._defaultValues.keys()) {
-            if (entityPath.indexOf(prefix) === 0)
-                this._defaultValues.delete(entityPath);
-        }
+        this._defaultValuesByPath.delete(entityID + '.' + prop);
     }
     _emitPendingEvents() {
         while (this._pendingEvents.length > 0) {
@@ -195,12 +165,6 @@ export class Animation {
             this[entry.evt].emit(...entry.args);
         }
     }
-    _resolvePath(p) {
-        const path = this._entityPaths.get(p);
-        if (!path || path.pathParts.length === 0)
-            return;
-        return [path.entity, path.pathParts, undefined, p];
-    }
     start() {
         for (const layer of this._layers) {
             for (const clip of Object.values(layer.clips)) {
@@ -210,18 +174,3 @@ export class Animation {
         }
     }
 }
-function getResolved(o, pathParts) {
-    let current = o.value;
-    for (let i = 1; i < pathParts.length; i++)
-        current = current[pathParts[i]];
-    return current;
-}
-function setResolved(o, pathParts, val) {
-    let target = o;
-    let key = 'value';
-    for (let i = 1; i < pathParts.length; i++) {
-        target = target[key];
-        key = pathParts[i];
-    }
-    target[key] = val;
-}

package/lib/animation/layerclip.js

@@ -99,7 +99,7 @@ export class LayerClip {
         return t1 - t;
     }
     _getTime() {
-        return this.timeSource?.() ?? this.animation?.timeSource?.() ?? performance.now();
+        return Math.floor(this.timeSource?.() ?? this.animation.timeSource?.() ?? performance.now());
     }
     queue(opts) {
         this.layer.queue(this, opts);

package/lib/animation/tracks/propertytrack.d.ts

@@ -7,6 +7,7 @@ export declare class PropertyTrack extends Track {
     private _entity;
     path: string;
     private _property;
+    private _path;
     private _keyframes;
     private _keyframesById;
     private _keyframesDirty;
@@ -30,4 +31,5 @@ export declare class PropertyTrack extends Track {
     get sortedWeights(): Keyframe[];
     getFadeLengthForPath(path: string): number;
     computePathProperty(t: number, p: string, valueBefore: any, parentWeight?: number): any;
+    private _computePathProperty;
 }

package/lib/animation/tracks/propertytrack.js

@@ -1,5 +1,7 @@
+import { Observable } from '../../observable';
 import { addBlend, interpolate } from '../interpolate';
 import { resolveKeyframes, resolveKeyframeValue, Track } from './track';
+const _scratch = new Observable(undefined);
 export class PropertyTrack extends Track {
     constructor(anim, _entityID, _entity, property, id) {
         super(anim, id);
@@ -12,13 +14,17 @@ export class PropertyTrack extends Track {
         this._weightsById = {};
         this._weightsDirty = false;
         this.blend = 'overlay';
-        if (Array.isArray(property))
+        if (Array.isArray(property)) {
+            this._property = property[0];
+            this._path = property.slice(1);
+        }
+        else {
             this._property = property;
-        else
-            this._property = [property];
-        this.path = [this._entityID, ...this._property].join('.');
+            this._path = [];
+        }
+        this.path = this._entityID + '.' + this._property;
         this.influencedPaths = [this.path];
-        anim.registerEntityPath(this.path, this._entity, this._property);
+        anim.registerEntityProperty(this.path, _entity, this._property);
     }
     addKeyframe(k) {
         this._keyframesById[k.id] = k;
@@ -59,6 +65,18 @@ export class PropertyTrack extends Track {
         return this.fadeParameters?.time ?? 0;
     }
     computePathProperty(t, p, valueBefore, parentWeight) {
+        if (this._path.length === 0) {
+            return this._computePathProperty(t, p, valueBefore, parentWeight);
+        }
+        else {
+            _scratch.value = valueBefore;
+            const v = _scratch.getValueAtPath(this._path);
+            const computed = this._computePathProperty(t, p, v, parentWeight);
+            _scratch.setValueAtPath(this._path, computed);
+            return _scratch.value;
+        }
+    }
+    _computePathProperty(t, p, valueBefore, parentWeight) {
         const keyframes = this.sortedKeyframes;
         const [before, after] = resolveKeyframes(keyframes, t);
         if (!before)

package/lib/contexts/gesturecontext.d.ts

@@ -0,0 +1,58 @@
+import { Context, ContextManager, Event, Observable } from '../index';
+export declare enum GestureMode {
+    ScaleOnly = "Scale Only",
+    RotateOnly = "Rotate Only",
+    ScaleRotate = "Scale Rotate"
+}
+interface ConstructionProps {
+    /**
+     * The HTML element to which touch event listeners are attached.
+     * Defaults to canvas.
+     */
+    element?: HTMLElement;
+}
+/** @zcontext */
+export declare class GestureContext extends Context<ConstructionProps> {
+    private element;
+    private canScale;
+    private gestureMode;
+    private canRotate;
+    private initialDistance;
+    private initialAngle;
+    private oneFingerRotateMode;
+    private initialTouchX;
+    rotation: Observable<number, never>;
+    scale: Observable<number, never>;
+    onRotate: Event<[number]>;
+    onScale: Event<[number]>;
+    /**
+     * Defaults to true.
+     */
+    enabled: Observable<boolean, never>;
+    /**
+     * Defaults to 0.5;
+     */
+    minScale: number;
+    /**
+     * Defaults to 2.
+     */
+    maxScale: number;
+    /**
+     * Defaults to 1.
+     */
+    rotationSensitivity: number;
+    constructor(contextManager: ContextManager, constructorProps: ConstructionProps);
+    private onTouchStart;
+    private onTouchMove;
+    private handleOneFingerRotate;
+    private handleTwoFingerGestures;
+    private handleScale;
+    private handleRotate;
+    private onTouchEnd;
+    private getDistanceBetweenTouches;
+    private getAngleBetweenTouches;
+    private attachEventListeners;
+    private detachEventListeners;
+    dispose(): never;
+}
+export {};

package/lib/contexts/gesturecontext.js

@@ -0,0 +1,140 @@
+import { Context, Event, Observable, useCanvas } from '../index';
+export var GestureMode;
+(function (GestureMode) {
+    GestureMode["ScaleOnly"] = "Scale Only";
+    GestureMode["RotateOnly"] = "Rotate Only";
+    GestureMode["ScaleRotate"] = "Scale Rotate";
+})(GestureMode || (GestureMode = {}));
+/** @zcontext */
+export class GestureContext extends Context {
+    constructor(contextManager, constructorProps) {
+        super(contextManager, constructorProps);
+        this.canScale = true;
+        this.gestureMode = GestureMode.ScaleRotate;
+        this.canRotate = true;
+        this.initialDistance = null;
+        this.initialAngle = null;
+        this.oneFingerRotateMode = true;
+        this.initialTouchX = null;
+        this.rotation = new Observable(0);
+        this.scale = new Observable(0);
+        this.onRotate = new Event();
+        this.onScale = new Event();
+        /**
+         * Defaults to true.
+         */
+        this.enabled = new Observable(true);
+        /**
+         * Defaults to 0.5;
+         */
+        this.minScale = 0.5;
+        /**
+         * Defaults to 2.
+         */
+        this.maxScale = 2;
+        /**
+         * Defaults to 1.
+         */
+        this.rotationSensitivity = 1;
+        this.onTouchStart = (event) => {
+            if (this.oneFingerRotateMode && event.touches.length === 1) {
+                this.initialTouchX = event.touches[0].pageX;
+            }
+            else if (event.touches.length === 2) {
+                this.initialDistance = this.getDistanceBetweenTouches(event.touches);
+                this.initialAngle = this.getAngleBetweenTouches(event.touches);
+            }
+        };
+        this.onTouchMove = (event) => {
+            switch (this.gestureMode) {
+                case GestureMode.ScaleOnly:
+                    if (event.touches.length === 2) {
+                        this.handleScale(event);
+                    }
+                    break;
+                case GestureMode.RotateOnly:
+                    if (this.oneFingerRotateMode && event.touches.length === 1) {
+                        this.handleOneFingerRotate(event);
+                    }
+                    else if (event.touches.length === 2) {
+                        this.handleRotate(event);
+                    }
+                    break;
+                case GestureMode.ScaleRotate:
+                    if (this.oneFingerRotateMode && event.touches.length === 1) {
+                        this.handleOneFingerRotate(event);
+                    }
+                    else if (event.touches.length === 2) {
+                        this.handleTwoFingerGestures(event);
+                    }
+                    break;
+            }
+        };
+        this.onTouchEnd = (event) => {
+            this.initialDistance = null;
+            this.initialAngle = null;
+        };
+        this.element = constructorProps.element ?? useCanvas(contextManager);
+        this.enabled.addListener(enabled => {
+            if (enabled) {
+                this.attachEventListeners();
+            }
+            else {
+                this.detachEventListeners();
+            }
+        }, undefined, true);
+    }
+    handleOneFingerRotate(event) {
+        if (this.initialTouchX !== null) {
+            const currentTouchX = event.touches[0].pageX;
+            const rotateAmount = (currentTouchX - this.initialTouchX) * this.rotationSensitivity;
+            this.onRotate.emit(rotateAmount);
+            this.rotation.value = rotateAmount;
+        }
+    }
+    handleTwoFingerGestures(event) {
+        this.handleScale(event);
+        this.handleRotate(event);
+    }
+    handleScale(event) {
+        if (this.canScale && this.initialDistance !== null) {
+            const currentDistance = this.getDistanceBetweenTouches(event.touches);
+            let scaleAmount = currentDistance / this.initialDistance;
+            scaleAmount = Math.max(this.minScale, Math.min(scaleAmount, this.maxScale));
+            this.onScale.emit(scaleAmount);
+            this.scale.value = scaleAmount;
+        }
+    }
+    handleRotate(event) {
+        if (this.canRotate && this.initialAngle !== null) {
+            const currentAngle = this.getAngleBetweenTouches(event.touches);
+            const rotateAmount = currentAngle - this.initialAngle;
+            this.onRotate.emit(-rotateAmount);
+            this.rotation.value = -rotateAmount;
+        }
+    }
+    getDistanceBetweenTouches(touches) {
+        const dx = touches[0].pageX - touches[1].pageX;
+        const dy = touches[0].pageY - touches[1].pageY;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    getAngleBetweenTouches(touches) {
+        const dx = touches[1].pageX - touches[0].pageX;
+        const dy = touches[1].pageY - touches[0].pageY;
+        return (Math.atan2(dy, dx) * 180) / Math.PI;
+    }
+    attachEventListeners() {
+        this.element.addEventListener('touchstart', this.onTouchStart, { passive: true });
+        this.element.addEventListener('touchmove', this.onTouchMove, { passive: true });
+        this.element.addEventListener('touchend', this.onTouchEnd);
+    }
+    detachEventListeners() {
+        this.element.removeEventListener('touchstart', this.onTouchStart);
+        this.element.removeEventListener('touchmove', this.onTouchMove);
+        this.element.removeEventListener('touchend', this.onTouchEnd);
+    }
+    dispose() {
+        this.detachEventListeners();
+        return super.dispose();
+    }
+}

package/lib/contexts/orientationcontext.d.ts

@@ -0,0 +1,51 @@
+import { ContextManager, Context } from '../context';
+import { Event } from '../event';
+import { Observable } from '../observable';
+export declare enum Orientation {
+    Portrait = "portrait",
+    Landscape = "landscape",
+    PortraitSecondary = "portrait-secondary",
+    LandscapeSecondary = "landscape-secondary"
+}
+/**
+ * @zcontext
+ */
+export declare class OrientationContext extends Context {
+    /**
+     * @zui
+     */
+    readonly isPortrait: Observable<boolean>;
+    /**
+     * @zui
+     */
+    readonly isLandscape: Observable<boolean>;
+    /**
+     * @zui
+     */
+    readonly isPortraitSecondary: Observable<boolean>;
+    /**
+     * @zui
+     */
+    readonly isLandscapeSecondary: Observable<boolean>;
+    readonly onOrientationChange: Event<[Orientation]>;
+    readonly orientation: Observable<Orientation>;
+    readonly onPortrait: Event<[void]>;
+    readonly onLandscape: Event<[void]>;
+    readonly onPortraitSecondary: Event<[void]>;
+    readonly onLandscapeSecondary: Event<[void]>;
+    constructor(contextManager: ContextManager);
+    private attachListeners;
+    private _onOrientationChange;
+    private orientationChangeHandler;
+    private getOrientation;
+    private getOrientationFromScreen;
+    private getOrientationFromWindow;
+    private getOrientationFromDimensions;
+    dispose: () => never;
+}
+export declare function useOnOrientationChange(mgr: ContextManager): Event<[Orientation]>;
+export declare function getOrientation(mgr: ContextManager): Orientation;
+export declare function isPortrait(mgr: ContextManager): boolean;
+export declare function isLandscape(mgr: ContextManager): boolean;
+export declare function isPortraitSecondary(mgr: ContextManager): boolean;
+export declare function isLandscapeSecondary(mgr: ContextManager): boolean;

package/lib/contexts/orientationcontext.js

@@ -0,0 +1,124 @@
+import { Context } from '../context';
+import { Event } from '../event';
+import { Observable } from '../observable';
+export var Orientation;
+(function (Orientation) {
+    Orientation["Portrait"] = "portrait";
+    Orientation["Landscape"] = "landscape";
+    Orientation["PortraitSecondary"] = "portrait-secondary";
+    Orientation["LandscapeSecondary"] = "landscape-secondary";
+})(Orientation || (Orientation = {}));
+/**
+ * @zcontext
+ */
+export class OrientationContext extends Context {
+    constructor(contextManager) {
+        super(contextManager, {});
+        this.onOrientationChange = new Event();
+        this.onPortrait = new Event();
+        this.onLandscape = new Event();
+        this.onPortraitSecondary = new Event();
+        this.onLandscapeSecondary = new Event();
+        this.attachListeners = () => {
+            this.orientation.addListener(this._onOrientationChange);
+            window.addEventListener('resize', this.orientationChangeHandler);
+            if ('orientation' in screen && screen.orientation) {
+                screen.orientation.addEventListener('change', this.orientationChangeHandler);
+            }
+        };
+        this._onOrientationChange = (orientation) => {
+            this.onOrientationChange.emit(orientation);
+            this.isPortrait.value = orientation === Orientation.Portrait;
+            this.isLandscape.value = orientation === Orientation.Landscape;
+            this.isPortraitSecondary.value = orientation === Orientation.PortraitSecondary;
+            this.isLandscapeSecondary.value = orientation === Orientation.LandscapeSecondary;
+            switch (orientation) {
+                case Orientation.Portrait:
+                    this.onPortrait.emit();
+                    break;
+                case Orientation.Landscape:
+                    this.onLandscape.emit();
+                    break;
+                case Orientation.PortraitSecondary:
+                    this.onPortraitSecondary.emit();
+                    break;
+                case Orientation.LandscapeSecondary:
+                    this.onLandscapeSecondary.emit();
+                    break;
+            }
+        };
+        this.orientationChangeHandler = () => {
+            const newOrientation = this.getOrientation();
+            if (this.orientation.value === newOrientation)
+                return;
+            this.orientation.value = newOrientation;
+        };
+        this.dispose = () => {
+            window.removeEventListener('resize', this.orientationChangeHandler);
+            if ('orientation' in screen && screen.orientation)
+                screen.orientation.removeEventListener('change', this.orientationChangeHandler);
+            this.orientation.removeListener(this._onOrientationChange);
+            return super.dispose();
+        };
+        const currentOrientation = this.getOrientation();
+        this.orientation = new Observable(currentOrientation);
+        this.isPortrait = new Observable(currentOrientation === Orientation.Portrait);
+        this.isLandscape = new Observable(currentOrientation === Orientation.Landscape);
+        this.isPortraitSecondary = new Observable(currentOrientation === Orientation.PortraitSecondary);
+        this.isLandscapeSecondary = new Observable(currentOrientation === Orientation.LandscapeSecondary);
+        this.attachListeners();
+    }
+    getOrientation() {
+        const orientation = this.getOrientationFromScreen() ?? this.getOrientationFromWindow() ?? this.getOrientationFromDimensions();
+        return orientation;
+    }
+    getOrientationFromScreen() {
+        const orientationType = screen?.orientation?.type;
+        if (orientationType) {
+            if (orientationType.includes('portrait')) {
+                return orientationType.includes('secondary') ? Orientation.PortraitSecondary : Orientation.Portrait;
+            }
+            else {
+                return orientationType.includes('secondary') ? Orientation.LandscapeSecondary : Orientation.Landscape;
+            }
+        }
+        return null;
+    }
+    getOrientationFromWindow() {
+        const windowOrientation = window?.orientation;
+        if (typeof windowOrientation === 'number') {
+            switch (windowOrientation) {
+                case 0:
+                    return Orientation.Portrait;
+                case 90:
+                    return Orientation.Landscape;
+                case 180:
+                    return Orientation.PortraitSecondary;
+                case -90:
+                    return Orientation.LandscapeSecondary;
+            }
+        }
+        return null;
+    }
+    getOrientationFromDimensions() {
+        return window.innerWidth > window.innerHeight ? Orientation.Landscape : Orientation.Portrait;
+    }
+}
+export function useOnOrientationChange(mgr) {
+    return mgr.get(OrientationContext).onOrientationChange;
+}
+export function getOrientation(mgr) {
+    return mgr.get(OrientationContext).orientation.value;
+}
+export function isPortrait(mgr) {
+    return mgr.get(OrientationContext).isPortrait.value;
+}
+export function isLandscape(mgr) {
+    return mgr.get(OrientationContext).isLandscape.value;
+}
+export function isPortraitSecondary(mgr) {
+    return mgr.get(OrientationContext).isPortraitSecondary.value;
+}
+export function isLandscapeSecondary(mgr) {
+    return mgr.get(OrientationContext).isLandscapeSecondary.value;
+}

package/lib/observable.d.ts

@@ -56,5 +56,7 @@ export declare class Observable<Type = never, TypeInternal extends any[] | [] |
     set value(v: Resolved<Type, TypeInternal> | undefined);
     addListener(fn: (v: Resolved<Type, TypeInternal>) => void, priority?: number, callImmediately?: boolean): void;
     private _emitValue;
+    setValueAtPath(path: (string | number)[], val: any): void;
+    getValueAtPath(path: (string | number)[]): any;
 }
 export {};

package/lib/observable.js

@@ -113,6 +113,21 @@ export class Observable extends Emitter {
     _emitValue() {
         this._emit(this._value.proxy);
     }
+    setValueAtPath(path, val) {
+        let target = this;
+        let key = 'value';
+        for (let i = 0; i < path.length; i++) {
+            target = target[key];
+            key = path[i];
+        }
+        target[key] = val;
+    }
+    getValueAtPath(path) {
+        let current = this.value;
+        for (let i = 0; i < path.length; i++)
+            current = current[path[i]];
+        return current;
+    }
 }
 function clone(a, deep) {
     if (!deep) {

package/lib/types.d.ts

@@ -83,7 +83,9 @@ export declare enum TypeHint {
     'angle-radians' = "angle-radians",
     'time-seconds' = "time-seconds",
     'time-milliseconds' = "time-milliseconds",
-    'time-hertz' = "time-hertz"
+    'time-hertz' = "time-hertz",
+    'emailaddress' = "emailaddress",
+    'url' = "url"
 }
 export declare enum ValuesType {
     'files' = "files",

package/lib/types.js

@@ -31,6 +31,8 @@ export var TypeHint;
     TypeHint["time-seconds"] = "time-seconds";
     TypeHint["time-milliseconds"] = "time-milliseconds";
     TypeHint["time-hertz"] = "time-hertz";
+    TypeHint["emailaddress"] = "emailaddress";
+    TypeHint["url"] = "url";
 })(TypeHint || (TypeHint = {}));
 export var ValuesType;
 (function (ValuesType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomponent/core",
-  "version": "1.14.1-beta",
+  "version": "1.14.3-beta",
   "description": "The core component model and built-in functionality for Mattercraft.",
   "main": "index.js",
   "types": "index.d.ts",