@zcomponent/core 1.29.0 → 2.0.0-alpha.2

package/lib/contexts/orientationcontext.js

@@ -1,52 +1,141 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
 import { Context } from '../context';
+import { zUI } from '../decorators';
 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 = {}));
+export const Orientation = {
+    Portrait: 'portrait',
+    Landscape: 'landscape',
+    PortraitSecondary: 'portrait-secondary',
+    LandscapeSecondary: 'landscape-secondary',
+};
+Object.freeze(Orientation);
 /**
  * Manages and tracks orientation changes in the application context.
  * @zcontext
  */
-export class OrientationContext extends Context {
-    /**
-     * Creates an instance of OrientationContext.
-     * @param contextManager - The current ContextManager
-     */
-    constructor(contextManager) {
-        super(contextManager, {});
+let OrientationContext = (() => {
+    let _classSuper = Context;
+    let _isPortrait_decorators;
+    let _isPortrait_initializers = [];
+    let _isPortrait_extraInitializers = [];
+    let _isLandscape_decorators;
+    let _isLandscape_initializers = [];
+    let _isLandscape_extraInitializers = [];
+    let _isPortraitSecondary_decorators;
+    let _isPortraitSecondary_initializers = [];
+    let _isPortraitSecondary_extraInitializers = [];
+    let _isLandscapeSecondary_decorators;
+    let _isLandscapeSecondary_initializers = [];
+    let _isLandscapeSecondary_extraInitializers = [];
+    return class OrientationContext extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _isPortrait_decorators = [zUI()];
+            _isLandscape_decorators = [zUI()];
+            _isPortraitSecondary_decorators = [zUI()];
+            _isLandscapeSecondary_decorators = [zUI()];
+            __esDecorate(null, null, _isPortrait_decorators, { kind: "field", name: "isPortrait", static: false, private: false, access: { has: obj => "isPortrait" in obj, get: obj => obj.isPortrait, set: (obj, value) => { obj.isPortrait = value; } }, metadata: _metadata }, _isPortrait_initializers, _isPortrait_extraInitializers);
+            __esDecorate(null, null, _isLandscape_decorators, { kind: "field", name: "isLandscape", static: false, private: false, access: { has: obj => "isLandscape" in obj, get: obj => obj.isLandscape, set: (obj, value) => { obj.isLandscape = value; } }, metadata: _metadata }, _isLandscape_initializers, _isLandscape_extraInitializers);
+            __esDecorate(null, null, _isPortraitSecondary_decorators, { kind: "field", name: "isPortraitSecondary", static: false, private: false, access: { has: obj => "isPortraitSecondary" in obj, get: obj => obj.isPortraitSecondary, set: (obj, value) => { obj.isPortraitSecondary = value; } }, metadata: _metadata }, _isPortraitSecondary_initializers, _isPortraitSecondary_extraInitializers);
+            __esDecorate(null, null, _isLandscapeSecondary_decorators, { kind: "field", name: "isLandscapeSecondary", static: false, private: false, access: { has: obj => "isLandscapeSecondary" in obj, get: obj => obj.isLandscapeSecondary, set: (obj, value) => { obj.isLandscapeSecondary = value; } }, metadata: _metadata }, _isLandscapeSecondary_initializers, _isLandscapeSecondary_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * Observable indicating whether the current orientation is portrait.
+         */
+        isPortrait = __runInitializers(this, _isPortrait_initializers, void 0);
+        /**
+         * Observable indicating whether the current orientation is landscape.
+         */
+        isLandscape = (__runInitializers(this, _isPortrait_extraInitializers), __runInitializers(this, _isLandscape_initializers, void 0));
+        /**
+         * Observable indicating whether the current orientation is secondary portrait.
+         */
+        isPortraitSecondary = (__runInitializers(this, _isLandscape_extraInitializers), __runInitializers(this, _isPortraitSecondary_initializers, void 0));
+        /**
+         * Observable indicating whether the current orientation is secondary landscape.
+         */
+        isLandscapeSecondary = (__runInitializers(this, _isPortraitSecondary_extraInitializers), __runInitializers(this, _isLandscapeSecondary_initializers, void 0));
+        /**
+         * Observable representing the current orientation.
+         */
+        orientation = __runInitializers(this, _isLandscapeSecondary_extraInitializers);
         /**
          * Event triggered when the orientation changes to portrait.
          */
-        this.onPortrait = new Event();
+        onPortrait = new Event();
         /**
          * Event triggered when the orientation changes to landscape.
          */
-        this.onLandscape = new Event();
+        onLandscape = new Event();
         /**
          * Event triggered when the orientation changes to secondary portrait.
          */
-        this.onPortraitSecondary = new Event();
+        onPortraitSecondary = new Event();
         /**
          * Event triggered when the orientation changes to secondary landscape.
          */
-        this.onLandscapeSecondary = new Event();
+        onLandscapeSecondary = new Event();
         /**
          * Event triggered when there is any orientation change.
          */
-        this.onOrientationChange = new Event();
-        this.attachListeners = () => {
+        onOrientationChange = new Event();
+        /**
+         * Creates an instance of OrientationContext.
+         * @param contextManager - The current ContextManager
+         */
+        constructor(contextManager) {
+            super(contextManager, {});
+            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();
+        }
+        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) => {
+        _onOrientationChange = (orientation) => {
             this.onOrientationChange.emit(orientation);
             this.isPortrait.value = orientation === Orientation.Portrait;
             this.isLandscape.value = orientation === Orientation.Landscape;
@@ -67,63 +156,57 @@ export class OrientationContext extends Context {
                     break;
             }
         };
-        this.orientationChangeHandler = () => {
+        orientationChangeHandler = () => {
             const newOrientation = this.getOrientation();
             if (this.orientation.value === newOrientation)
                 return;
             this.orientation.value = newOrientation;
         };
-        this.dispose = () => {
+        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;
+        }
+        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 { OrientationContext };
 /**
  * Returns an observable that notifies when the orientation changes.
  * @param mgr The ContextManager instance to access the OrientationContext.

package/lib/contexts/rootcomponentscontext.d.ts

@@ -0,0 +1,16 @@
+import { Component, ConstructorForComponent, ConstructorPropsOfComponent } from '../component';
+import { Context } from '../context';
+export declare class RootComponentsContext extends Context {
+    rootComponent: Component | undefined;
+    private _topLevelComponents;
+    private _topLevelComponentOwners;
+    /**
+     * @default false
+     */
+    private _suppressCleanup;
+    constructAndReplaceRootComponent<T extends Component>(_constructor: ConstructorForComponent<T>, constructorProps: ConstructorPropsOfComponent<T>): T;
+    replaceRootComponent<T extends Component>(newRoot: T): T;
+    lockTopLevelComponent<T extends Component>(_constructor: ConstructorForComponent<T>, constructorProps: ConstructorPropsOfComponent<T>, owner: any): T;
+    unlockTopLevelComponent<T extends Component>(_constructor: ConstructorForComponent<T>, owner: any): void;
+    private _cleanup;
+}

package/lib/contexts/rootcomponentscontext.js

@@ -0,0 +1,65 @@
+import { Context } from '../context';
+export class RootComponentsContext extends Context {
+    rootComponent;
+    _topLevelComponents = new Map();
+    _topLevelComponentOwners = new Map();
+    /**
+     * @default false
+     */
+    _suppressCleanup = false;
+    constructAndReplaceRootComponent(_constructor, constructorProps) {
+        this._suppressCleanup = true;
+        if (this.rootComponent) {
+            this.rootComponent.dispose();
+        }
+        const newRoot = new _constructor(this.contextManager, constructorProps);
+        this.rootComponent = newRoot;
+        this._suppressCleanup = false;
+        this._cleanup();
+        return newRoot;
+    }
+    replaceRootComponent(newRoot) {
+        if (this.rootComponent) {
+            this.rootComponent.dispose();
+        }
+        this.rootComponent = newRoot;
+        return newRoot;
+    }
+    lockTopLevelComponent(_constructor, constructorProps, owner) {
+        let existing = this._topLevelComponents.get(_constructor);
+        if (!existing) {
+            existing = new _constructor(this.contextManager, constructorProps);
+            existing.connectElements();
+            this._topLevelComponents.set(_constructor, existing);
+        }
+        const owners = this._topLevelComponentOwners.get(_constructor) ?? new Set();
+        owners.add(owner);
+        this._topLevelComponentOwners.set(_constructor, owners);
+        return existing;
+    }
+    unlockTopLevelComponent(_constructor, owner) {
+        const owners = this._topLevelComponentOwners.get(_constructor);
+        if (!owners || !owners.has(owner)) {
+            return;
+        }
+        owners.delete(owner);
+        this._cleanup();
+    }
+    _cleanup() {
+        if (this._suppressCleanup)
+            return;
+        for (const [_constructor, owners] of this._topLevelComponentOwners.entries()) {
+            if (owners.size === 0) {
+                try {
+                    const component = this._topLevelComponents.get(_constructor);
+                    component?.dispose();
+                }
+                catch (err) {
+                    console.error('Error disposing top-level component:', err);
+                }
+                this._topLevelComponents.delete(_constructor);
+                this._topLevelComponentOwners.delete(_constructor);
+            }
+        }
+    }
+}

package/lib/contexts/snapshotContext.d.ts

@@ -7,17 +7,14 @@ import { Observable } from '../observable';
 export declare class SnapshotContext extends Context {
     /**
      * Observable holding the current canvas image data URL.
-     * @zui
      */
     readonly canvasImage: Observable<string, never>;
     /**
      * Observable indicating whether the Share API is supported in the current environment.
-     * @zui
      */
     readonly shareAPISupported: Observable<boolean, never>;
     /**
      * Observable determining if the current canvas content can be shared.
-     * @zui
      */
     readonly canShare: Observable<boolean, never>;
     /**

package/lib/contexts/snapshotContext.js

@@ -1,61 +1,116 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
 import { Context } from '../context';
+import { zUI } from '../decorators';
 import { Observable } from '../observable';
 /**
  * Context containing snapshot information.
  * @zcontext
  *  */
-export class SnapshotContext extends Context {
-    /**
-     * Creates an instance of SnapshotContext.
-     * @param contextManager - The current ContextManager
-     */
-    constructor(contextManager) {
-        super(contextManager, {});
+let SnapshotContext = (() => {
+    let _classSuper = Context;
+    let _canvasImage_decorators;
+    let _canvasImage_initializers = [];
+    let _canvasImage_extraInitializers = [];
+    let _shareAPISupported_decorators;
+    let _shareAPISupported_initializers = [];
+    let _shareAPISupported_extraInitializers = [];
+    let _canShare_decorators;
+    let _canShare_initializers = [];
+    let _canShare_extraInitializers = [];
+    return class SnapshotContext extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _canvasImage_decorators = [zUI()];
+            _shareAPISupported_decorators = [zUI()];
+            _canShare_decorators = [zUI()];
+            __esDecorate(null, null, _canvasImage_decorators, { kind: "field", name: "canvasImage", static: false, private: false, access: { has: obj => "canvasImage" in obj, get: obj => obj.canvasImage, set: (obj, value) => { obj.canvasImage = value; } }, metadata: _metadata }, _canvasImage_initializers, _canvasImage_extraInitializers);
+            __esDecorate(null, null, _shareAPISupported_decorators, { kind: "field", name: "shareAPISupported", static: false, private: false, access: { has: obj => "shareAPISupported" in obj, get: obj => obj.shareAPISupported, set: (obj, value) => { obj.shareAPISupported = value; } }, metadata: _metadata }, _shareAPISupported_initializers, _shareAPISupported_extraInitializers);
+            __esDecorate(null, null, _canShare_decorators, { kind: "field", name: "canShare", static: false, private: false, access: { has: obj => "canShare" in obj, get: obj => obj.canShare, set: (obj, value) => { obj.canShare = value; } }, metadata: _metadata }, _canShare_initializers, _canShare_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
         /**
          * Observable holding the current canvas image data URL.
-         * @zui
          */
-        this.canvasImage = new Observable('');
+        canvasImage = __runInitializers(this, _canvasImage_initializers, new Observable(''));
         /**
          * Observable indicating whether the Share API is supported in the current environment.
-         * @zui
          */
-        this.shareAPISupported = new Observable('share' in navigator);
+        shareAPISupported = (__runInitializers(this, _canvasImage_extraInitializers), __runInitializers(this, _shareAPISupported_initializers, new Observable('share' in navigator)));
         /**
          * Observable determining if the current canvas content can be shared.
-         * @zui
          */
-        this.canShare = new Observable(false);
+        canShare = (__runInitializers(this, _shareAPISupported_extraInitializers), __runInitializers(this, _canShare_initializers, new Observable(false)));
         /**
          * Observable containing the canvas image as a File object.
          */
-        this.canvasFile = new Observable(null);
+        canvasFile = (__runInitializers(this, _canShare_extraInitializers), new Observable(null));
         /**
          * Observable storing the file name for the snapshot.
          * Updates the file upon change.
          */
-        this.fileName = new Observable('canvas', fileName => this.updateFile());
+        fileName = new Observable('canvas', fileName => this.updateFile());
         /**
          * Observable holding the text content to be shared with the snapshot.
          */
-        this.text = new Observable('Check this out!');
+        text = new Observable('Check this out!');
         /**
          * Observable containing the title for the snapshot.
          */
-        this.title = new Observable('Canvas');
+        title = new Observable('Canvas');
         /**
          * Observable storing the file type for the snapshot (e.g., 'image/png').
          * Updates the file upon change.
          */
-        this.fileType = new Observable('image/png', fileType => this.updateFile());
+        fileType = new Observable('image/png', fileType => this.updateFile());
         /**
          * Observable representing the quality setting of the snapshot image.
          */
-        this.quality = new Observable(0.92);
+        quality = new Observable(0.92);
+        /**
+         * Creates an instance of SnapshotContext.
+         * @param contextManager - The current ContextManager
+         */
+        constructor(contextManager) {
+            super(contextManager, {});
+            this.canvasImage.addListener(this.updateFile);
+        }
         /**
          * Converts the canvas image to a file.
          */
-        this.updateFile = async () => {
+        updateFile = async () => {
             if (!this.canvasImage.value)
                 return;
             const response = await fetch(this.canvasImage.value);
@@ -69,9 +124,9 @@ export class SnapshotContext extends Context {
             });
             this.canvasFile.value = file;
         };
-        this.canvasImage.addListener(this.updateFile);
-    }
-}
+    };
+})();
+export { SnapshotContext };
 /**
  * Retrieves the current canvas image as a data URL.
  * @param ctx The ContextManager instance to access the SnapshotContext.

package/lib/contexts/tagcontext.d.ts

@@ -1,5 +1,5 @@
 import { Component } from '../component';
-import { ContextManager, Context } from '../context';
+import { Context, ContextManager } from '../context';
 import { Event } from '../event';
 /**
  * Manages and tracks tags associated with components.
@@ -9,11 +9,11 @@ export declare class TagContext extends Context {
     /**
      * A map storing the relationship between components and their associated tags.
      */
-    readonly tagsByComponent: Map<Component<any, import("../component").ConstructorProps>, Set<string>>;
+    readonly tagsByComponent: Map<Component<any, import("..").ConstructorProps>, Set<string>>;
     /**
      * A map storing the relationship between local tags and their associated components.
      */
-    readonly componentsByLocalTag: Map<string, Set<Component<any, import("../component").ConstructorProps>>>;
+    readonly componentsByLocalTag: Map<string, Set<Component<any, import("..").ConstructorProps>>>;
     /**
      * An event that's emitted when the set of components that constitute a tag changes.
      */
@@ -57,11 +57,11 @@ export declare class TagContext extends Context {
  * @param tag The tag to search for.
  * @returns A set of components associated with the specified tag.
  */
-export declare function getComponentsByTag(mgr: ContextManager, tag: string): Set<Component<any, import("../component").ConstructorProps>>;
+export declare function getComponentsByTag(mgr: ContextManager, tag: string): Set<Component<any, import("..").ConstructorProps>>;
 /**
  * Retrieves components associated with a list of tags.
  * @param mgr The ContextManager instance to access the TagContext.
  * @param tags An array of tags to search for.
  * @returns A set of components associated with the specified tags.
  */
-export declare function getComponentsByTags(mgr: ContextManager, tags: string[]): Set<Component<any, import("../component").ConstructorProps>>;
+export declare function getComponentsByTags(mgr: ContextManager, tags: string[]): Set<Component<any, import("..").ConstructorProps>>;

package/lib/contexts/tagcontext.js

@@ -6,26 +6,26 @@ import { GlobalTagContext } from './globaltagcontext';
  * @zcontext
  */
 export class TagContext extends Context {
+    /**
+     * A map storing the relationship between components and their associated tags.
+     */
+    tagsByComponent = new Map();
+    /**
+     * A map storing the relationship between local tags and their associated components.
+     */
+    componentsByLocalTag = new Map();
+    /**
+     * An event that's emitted when the set of components that constitute a tag changes.
+     */
+    onTagChange = new Event();
+    _global = this.contextManager.get(GlobalTagContext);
     constructor(contextManager) {
         super(contextManager, {});
-        /**
-         * A map storing the relationship between components and their associated tags.
-         */
-        this.tagsByComponent = new Map();
-        /**
-         * A map storing the relationship between local tags and their associated components.
-         */
-        this.componentsByLocalTag = new Map();
-        /**
-         * An event that's emitted when the set of components that constitute a tag changes.
-         */
-        this.onTagChange = new Event();
-        this._global = this.contextManager.get(GlobalTagContext);
-        this._globalTagChange = (tag) => {
-            this.onTagChange.emit(tag);
-        };
         this._global.onTagChange.addListener(this._globalTagChange);
     }
+    _globalTagChange = (tag) => {
+        this.onTagChange.emit(tag);
+    };
     /**
      * Registers a component with specified tags.
      * Updates both local and global tag maps accordingly.

package/lib/contexts/textalertcontext.d.ts

@@ -1,4 +1,4 @@
-import { ContextManager, Context } from '../context';
+import { Context, ContextManager } from '../context';
 /**
  * Manages the display of text alerts.
  * @zcontext
@@ -12,10 +12,6 @@ export declare class TextAlertContext extends Context {
     constructor(contextManager: ContextManager);
     /**
      * Displays a text alert with specified options.
-     * @zprop
-     * @param txt The text content for the alert.
-     * @param options Optional configuration for the text alert appearance and behavior.
-     * @returns An object that allows for manually closing the text alert
      */
     showTextAlert(txt: string, options?: TextAlertOptions): {
         close: () => void;

package/lib/contexts/textalertcontext.js

@@ -5,13 +5,13 @@ import { useOverlay } from './canvascontext';
  * @zcontext
  */
 export class TextAlertContext extends Context {
+    _container = document.createElement('div');
     /**
      * Creates an instance of TextAlertContext.
      * @param contextManager - The current ContextManager
      */
     constructor(contextManager) {
         super(contextManager, {});
-        this._container = document.createElement('div');
         this._container.classList.add('zcomponent-textalert-container');
         useOverlay(contextManager).addListener(val => {
             val.appendChild(this._container);
@@ -19,10 +19,6 @@ export class TextAlertContext extends Context {
     }
     /**
      * Displays a text alert with specified options.
-     * @zprop
-     * @param txt The text content for the alert.
-     * @param options Optional configuration for the text alert appearance and behavior.
-     * @returns An object that allows for manually closing the text alert
      */
     showTextAlert(txt, options) {
         const entry = document.createElement('div');

package/lib/contexts/usereventcontext.d.ts

@@ -1,4 +1,4 @@
-import { ContextManager, Context } from '../context';
+import { Context, ContextManager } from '../context';
 import { Event as EventClass } from '../event';
 import { Observable } from '../observable';
 /**