@zcomponent/core 1.14.3 → 1.16.0-beta

package/lib/contexts/globaltagcontext.d.ts

@@ -1,5 +1,17 @@
-import { Component } from "../component";
-import { Context } from "../context";
+import { Component } from '../component';
+import { Context } from '../context';
+import { Event } from '../event';
+/**
+ * Manages the association between global tags and components.
+ * @zcontext
+ */
 export declare class GlobalTagContext extends Context {
+    /**
+     * A map storing the relationship between global tags and sets of components.
+     */
     readonly componentsByGlobalTag: Map<string, Set<Component<any, import("../component").ConstructorProps>>>;
+    /**
+     * An event that's emitted when the set of components that constitute a tag changes.
+     */
+    readonly onTagChange: Event<[string]>;
 }

package/lib/contexts/globaltagcontext.js

@@ -1,7 +1,19 @@
-import { Context } from "../context";
+import { Context } from '../context';
+import { Event } from '../event';
+/**
+ * Manages the association between global tags and components.
+ * @zcontext
+ */
 export class GlobalTagContext extends Context {
     constructor() {
         super(...arguments);
+        /**
+         * A map storing the relationship between global tags and sets of components.
+         */
         this.componentsByGlobalTag = new Map();
+        /**
+         * An event that's emitted when the set of components that constitute a tag changes.
+         */
+        this.onTagChange = new Event();
     }
 }

package/lib/contexts/loadcontext.d.ts

@@ -28,15 +28,35 @@ import { Observable } from '../observable';
  *
  * @zcontext */
 export declare class LoadContext extends Context {
-    /** @zui */
+    /**
+     * Observable indicating whether the root component's construction is complete.
+     * This is typically set to true immediately after the root component and its children are constructed.
+     * @zui
+     */
     readonly isConstructed: Observable<boolean, never>;
-    /** @zui */
+    /**
+     * Observable indicating whether all loadable processes have completed.
+     * This is true when all assets and dependencies required for the experience are fully loaded.
+     * @zui
+     */
     readonly isLoaded: Observable<boolean, never>;
-    /** @zui */
+    /**
+     * Observable indicating whether the experience has started.
+     * This becomes true at the point where the experience transitions from loading to active interaction.
+     * @zui
+     */
     readonly isStarted: Observable<boolean, never>;
-    /** @zui */
+    /**
+     * Observable indicating whether the experience has been launched.
+     * This is set to true typically when the user interacts with a splash screen or an initial launch button.
+     * @zui
+     */
     readonly isLaunched: Observable<boolean, never>;
-    /** @zui */
+    /**
+     * Observable representing the progress percentage of loadable processes.
+     * This provides a numerical value representing the completion percentage of all loading operations.
+     * @zui
+     */
     readonly progressPercent: Observable<number, never>;
     private _startedResolved;
     readonly started: Promise<void>;
@@ -48,27 +68,94 @@ export declare class LoadContext extends Context {
     private _startWhenLoaded;
     private _totalLoadables;
     private _loadedCount;
+    /**
+     * Start the experience.
+     */
     start(): void;
+    /**
+     * Called when the root component's constructor (and thus any recursive children) has finished.
+     */
     constructionComplete(): void;
+    /**
+     * Called when the user taps on a splash screen's 'launch' button or, in the case that there's no launch
+     */
     launch(): void;
     private _update;
+    /**
+     * Start the experience when all loadables have completed.
+     */
     startWhenLoaded(): void;
+    /**
+     * Register a loadable process.
+     */
     registerLoadable(p: Promise<any>): void;
 }
+/**
+ * Returns an observable that indicates whether the experience is loaded.
+ */
 export declare function useIsLoaded(mgr: ContextManager): Observable<boolean, never>;
+/**
+ * Returns a value that indicates whether the experience is loaded.
+ */
 export declare function isLoaded(mgr: ContextManager): boolean;
+/**
+ * Returns an observable that indicates whether the experience is started.
+ */
 export declare function useIsStarted(mgr: ContextManager): Observable<boolean, never>;
+/**
+ * Returns a value that indicates whether the experience is started.
+ */
 export declare function isStarted(mgr: ContextManager): boolean;
+/**
+ * Returns an observable that indicates whether the experience is constructed.
+ */
 export declare function useIsConstructed(mgr: ContextManager): Observable<boolean, never>;
+/**
+ * Returns a value that indicates whether the experience is constructed.
+ */
 export declare function isConstructed(mgr: ContextManager): boolean;
+/**
+ * Returns an observable that indicates whether the experience is launched.
+ */
 export declare function useIsLaunched(mgr: ContextManager): Observable<boolean, never>;
+/**
+ * Returns a value that indicates whether the experience is launched.
+ */
 export declare function isLaunched(mgr: ContextManager): boolean;
+/**
+ * Returns an observable that indicates the percentage of loadables that have completed.
+ */
 export declare function useLoadPercent(mgr: ContextManager): Observable<number, never>;
+/**
+ * Register a loadable process.
+ */
 export declare function registerLoadable(mgr: ContextManager, p: Promise<any>): void;
+/**
+ * Starts the experience.
+ */
 export declare function start(mgr: ContextManager): void;
+/**
+ * Launches the experience.
+ */
 export declare function launch(mgr: ContextManager): void;
+/**
+ * Starts the experience when all loadables have completed.
+ */
 export declare function startWhenLoaded(mgr: ContextManager): void;
+/**
+ * Returns a promise that resolves when the experience has started.
+ */
 export declare function started(mgr: ContextManager): Promise<void>;
+/**
+ *  Returns a promise that resolves when the root component's constructor (and thus any recursive children) has finished.
+ */
 export declare function constructed(mgr: ContextManager): Promise<void>;
+/**
+ * Returns a promise that resolves when the user taps on a splash screen's 'launch' button or, in the case that there's no launch
+ * button, after construction.
+ */
 export declare function launched(mgr: ContextManager): Promise<void>;
+/**
+ * Marks the root component's constructor (and thus any recursive children) as finished.
+ */
 export declare function constructionComplete(mgr: ContextManager): void;

package/lib/contexts/loadcontext.js

@@ -30,24 +30,47 @@ import { Observable } from '../observable';
 export class LoadContext extends Context {
     constructor() {
         super(...arguments);
-        /** @zui */
+        /**
+         * Observable indicating whether the root component's construction is complete.
+         * This is typically set to true immediately after the root component and its children are constructed.
+         * @zui
+         */
         this.isConstructed = new Observable(false);
-        /** @zui */
+        /**
+         * Observable indicating whether all loadable processes have completed.
+         * This is true when all assets and dependencies required for the experience are fully loaded.
+         * @zui
+         */
         this.isLoaded = new Observable(false);
-        /** @zui */
+        /**
+         * Observable indicating whether the experience has started.
+         * This becomes true at the point where the experience transitions from loading to active interaction.
+         * @zui
+         */
         this.isStarted = new Observable(false);
-        /** @zui */
+        /**
+         * Observable indicating whether the experience has been launched.
+         * This is set to true typically when the user interacts with a splash screen or an initial launch button.
+         * @zui
+         */
         this.isLaunched = new Observable(false);
-        /** @zui */
+        /**
+         * Observable representing the progress percentage of loadable processes.
+         * This provides a numerical value representing the completion percentage of all loading operations.
+         * @zui
+         */
         this.progressPercent = new Observable(0);
-        this.started = new Promise(resolve => this._startedResolved = resolve);
-        this.constructed = new Promise(resolve => this._constructedResolved = resolve);
-        this.launched = new Promise(resolve => this._launchedResolved = resolve);
+        this.started = new Promise(resolve => (this._startedResolved = resolve));
+        this.constructed = new Promise(resolve => (this._constructedResolved = resolve));
+        this.launched = new Promise(resolve => (this._launchedResolved = resolve));
         this._loadables = new Set();
         this._startWhenLoaded = false;
         this._totalLoadables = 0;
         this._loadedCount = 0;
     }
+    /**
+     * Start the experience.
+     */
     start() {
         if (this.isStarted.value)
             return;
@@ -56,17 +79,23 @@ export class LoadContext extends Context {
         this.isStarted.value = true;
         this._startedResolved?.();
     }
+    /**
+     * Called when the root component's constructor (and thus any recursive children) has finished.
+     */
     constructionComplete() {
         if (this.isConstructed.value)
             return;
         this.isConstructed.value = true;
         this._constructedResolved();
     }
+    /**
+     * Called when the user taps on a splash screen's 'launch' button or, in the case that there's no launch
+     */
     launch() {
         if (this.isLaunched.value)
             return;
         if (document.body)
-            document.body.classList.add("zcomponent-launched");
+            document.body.classList.add('zcomponent-launched');
         this.isLaunched.value = true;
         this._launchedResolved();
     }
@@ -79,17 +108,23 @@ export class LoadContext extends Context {
         if (this._loadables.size === 0 && this.isLoaded.value === false) {
             this.isLoaded.value = true;
             if (document.body)
-                document.body.classList.add("zcomponent-loaded");
+                document.body.classList.add('zcomponent-loaded');
         }
-        this.progressPercent.value = this.isLoaded.value ? 100 : (100 * this._loadedCount / this._totalLoadables);
+        this.progressPercent.value = this.isLoaded.value ? 100 : (100 * this._loadedCount) / this._totalLoadables;
         if (this._startWhenLoaded && this.isLoaded.value && !this.isStarted.value) {
             this.start();
         }
     }
+    /**
+     * Start the experience when all loadables have completed.
+     */
     startWhenLoaded() {
         this._startWhenLoaded = true;
         this._update();
     }
+    /**
+     * Register a loadable process.
+     */
     registerLoadable(p) {
         if (this.disposed)
             return;
@@ -105,54 +140,106 @@ export class LoadContext extends Context {
         this._update();
     }
 }
+/**
+ * Returns an observable that indicates whether the experience is loaded.
+ */
 export function useIsLoaded(mgr) {
     return mgr.get(LoadContext).isLoaded;
 }
+/**
+ * Returns a value that indicates whether the experience is loaded.
+ */
 export function isLoaded(mgr) {
     return mgr.get(LoadContext).isLoaded.value;
 }
+/**
+ * Returns an observable that indicates whether the experience is started.
+ */
 export function useIsStarted(mgr) {
     return mgr.get(LoadContext).isStarted;
 }
+/**
+ * Returns a value that indicates whether the experience is started.
+ */
 export function isStarted(mgr) {
     return mgr.get(LoadContext).isStarted.value;
 }
+/**
+ * Returns an observable that indicates whether the experience is constructed.
+ */
 export function useIsConstructed(mgr) {
     return mgr.get(LoadContext).isConstructed;
 }
+/**
+ * Returns a value that indicates whether the experience is constructed.
+ */
 export function isConstructed(mgr) {
     return mgr.get(LoadContext).isConstructed.value;
 }
+/**
+ * Returns an observable that indicates whether the experience is launched.
+ */
 export function useIsLaunched(mgr) {
     return mgr.get(LoadContext).isLaunched;
 }
+/**
+ * Returns a value that indicates whether the experience is launched.
+ */
 export function isLaunched(mgr) {
     return mgr.get(LoadContext).isLaunched.value;
 }
+/**
+ * Returns an observable that indicates the percentage of loadables that have completed.
+ */
 export function useLoadPercent(mgr) {
     return mgr.get(LoadContext).progressPercent;
 }
+/**
+ * Register a loadable process.
+ */
 export function registerLoadable(mgr, p) {
     return mgr.get(LoadContext).registerLoadable(p);
 }
+/**
+ * Starts the experience.
+ */
 export function start(mgr) {
     return mgr.get(LoadContext).start();
 }
+/**
+ * Launches the experience.
+ */
 export function launch(mgr) {
     return mgr.get(LoadContext).launch();
 }
+/**
+ * Starts the experience when all loadables have completed.
+ */
 export function startWhenLoaded(mgr) {
     return mgr.get(LoadContext).startWhenLoaded();
 }
+/**
+ * Returns a promise that resolves when the experience has started.
+ */
 export function started(mgr) {
     return mgr.get(LoadContext).started;
 }
+/**
+ *  Returns a promise that resolves when the root component's constructor (and thus any recursive children) has finished.
+ */
 export function constructed(mgr) {
     return mgr.get(LoadContext).constructed;
 }
+/**
+ * Returns a promise that resolves when the user taps on a splash screen's 'launch' button or, in the case that there's no launch
+ * button, after construction.
+ */
 export function launched(mgr) {
     return mgr.get(LoadContext).launched;
 }
+/**
+ * Marks the root component's constructor (and thus any recursive children) as finished.
+ */
 export function constructionComplete(mgr) {
     return mgr.get(LoadContext).constructionComplete();
 }

package/lib/contexts/orientationcontext.d.ts

@@ -8,31 +8,58 @@ export declare enum Orientation {
     LandscapeSecondary = "landscape-secondary"
 }
 /**
+ * Manages and tracks orientation changes in the application context.
  * @zcontext
  */
 export declare class OrientationContext extends Context {
     /**
+     * Observable indicating whether the current orientation is portrait.
      * @zui
      */
     readonly isPortrait: Observable<boolean>;
     /**
+     * Observable indicating whether the current orientation is landscape.
      * @zui
      */
     readonly isLandscape: Observable<boolean>;
     /**
+     * Observable indicating whether the current orientation is secondary portrait.
      * @zui
      */
     readonly isPortraitSecondary: Observable<boolean>;
     /**
+     * Observable indicating whether the current orientation is secondary landscape.
      * @zui
      */
     readonly isLandscapeSecondary: Observable<boolean>;
-    readonly onOrientationChange: Event<[Orientation]>;
+    /**
+     * Observable representing the current orientation.
+     */
     readonly orientation: Observable<Orientation>;
+    /**
+     * Event triggered when the orientation changes to portrait.
+     */
     readonly onPortrait: Event<[void]>;
+    /**
+     * Event triggered when the orientation changes to landscape.
+     */
     readonly onLandscape: Event<[void]>;
+    /**
+     * Event triggered when the orientation changes to secondary portrait.
+     */
     readonly onPortraitSecondary: Event<[void]>;
+    /**
+     * Event triggered when the orientation changes to secondary landscape.
+     */
     readonly onLandscapeSecondary: Event<[void]>;
+    /**
+     * Event triggered when there is any orientation change.
+     */
+    readonly onOrientationChange: Event<[Orientation]>;
+    /**
+     * Creates an instance of OrientationContext.
+     * @param contextManager - The current ContextManager
+     */
     constructor(contextManager: ContextManager);
     private attachListeners;
     private _onOrientationChange;
@@ -43,9 +70,39 @@ export declare class OrientationContext extends Context {
     private getOrientationFromDimensions;
     dispose: () => never;
 }
+/**
+ * Returns an observable that notifies when the orientation changes.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns Observable for orientation change events.
+ */
 export declare function useOnOrientationChange(mgr: ContextManager): Event<[Orientation]>;
+/**
+ * Retrieves the current orientation value.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns The current orientation as an Orientation enum value.
+ */
 export declare function getOrientation(mgr: ContextManager): Orientation;
+/**
+ * Determines if the current orientation is portrait.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is portrait, false otherwise.
+ */
 export declare function isPortrait(mgr: ContextManager): boolean;
+/**
+ * Determines if the current orientation is landscape.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is landscape, false otherwise.
+ */
 export declare function isLandscape(mgr: ContextManager): boolean;
+/**
+ * Determines if the current orientation is secondary portrait.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is secondary portrait, false otherwise.
+ */
 export declare function isPortraitSecondary(mgr: ContextManager): boolean;
+/**
+ * Determines if the current orientation is secondary landscape.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is secondary landscape, false otherwise.
+ */
 export declare function isLandscapeSecondary(mgr: ContextManager): boolean;

package/lib/contexts/orientationcontext.js

@@ -9,16 +9,36 @@ export var Orientation;
     Orientation["LandscapeSecondary"] = "landscape-secondary";
 })(Orientation || (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, {});
-        this.onOrientationChange = new Event();
+        /**
+         * Event triggered when the orientation changes to portrait.
+         */
         this.onPortrait = new Event();
+        /**
+         * Event triggered when the orientation changes to landscape.
+         */
         this.onLandscape = new Event();
+        /**
+         * Event triggered when the orientation changes to secondary portrait.
+         */
         this.onPortraitSecondary = new Event();
+        /**
+         * Event triggered when the orientation changes to secondary landscape.
+         */
         this.onLandscapeSecondary = new Event();
+        /**
+         * Event triggered when there is any orientation change.
+         */
+        this.onOrientationChange = new Event();
         this.attachListeners = () => {
             this.orientation.addListener(this._onOrientationChange);
             window.addEventListener('resize', this.orientationChangeHandler);
@@ -104,21 +124,51 @@ export class OrientationContext extends Context {
         return window.innerWidth > window.innerHeight ? Orientation.Landscape : Orientation.Portrait;
     }
 }
+/**
+ * Returns an observable that notifies when the orientation changes.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns Observable for orientation change events.
+ */
 export function useOnOrientationChange(mgr) {
     return mgr.get(OrientationContext).onOrientationChange;
 }
+/**
+ * Retrieves the current orientation value.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns The current orientation as an Orientation enum value.
+ */
 export function getOrientation(mgr) {
     return mgr.get(OrientationContext).orientation.value;
 }
+/**
+ * Determines if the current orientation is portrait.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is portrait, false otherwise.
+ */
 export function isPortrait(mgr) {
     return mgr.get(OrientationContext).isPortrait.value;
 }
+/**
+ * Determines if the current orientation is landscape.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is landscape, false otherwise.
+ */
 export function isLandscape(mgr) {
     return mgr.get(OrientationContext).isLandscape.value;
 }
+/**
+ * Determines if the current orientation is secondary portrait.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is secondary portrait, false otherwise.
+ */
 export function isPortraitSecondary(mgr) {
     return mgr.get(OrientationContext).isPortraitSecondary.value;
 }
+/**
+ * Determines if the current orientation is secondary landscape.
+ * @param mgr The ContextManager instance to access the OrientationContext.
+ * @returns True if the orientation is secondary landscape, false otherwise.
+ */
 export function isLandscapeSecondary(mgr) {
     return mgr.get(OrientationContext).isLandscapeSecondary.value;
 }