@zcomponent/core 1.29.0 → 2.0.0-alpha.2

package/lib/contexts/loadcontext.js

@@ -1,4 +1,40 @@
+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 { Entity } from '../entity';
 import { Observable } from '../observable';
 /**
  * LoadContext exposes to components and behaviors key moments during the initialization of the experience,
@@ -27,113 +63,162 @@ import { Observable } from '../observable';
  *   on any 'launch' button.
  *
  * @zcontext */
-export class LoadContext extends Context {
-    constructor() {
-        super(...arguments);
+let LoadContext = (() => {
+    let _classSuper = Context;
+    let _isConstructed_decorators;
+    let _isConstructed_initializers = [];
+    let _isConstructed_extraInitializers = [];
+    let _isLoaded_decorators;
+    let _isLoaded_initializers = [];
+    let _isLoaded_extraInitializers = [];
+    let _isStarted_decorators;
+    let _isStarted_initializers = [];
+    let _isStarted_extraInitializers = [];
+    let _isLaunched_decorators;
+    let _isLaunched_initializers = [];
+    let _isLaunched_extraInitializers = [];
+    let _progressPercent_decorators;
+    let _progressPercent_initializers = [];
+    let _progressPercent_extraInitializers = [];
+    return class LoadContext extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _isConstructed_decorators = [zUI()];
+            _isLoaded_decorators = [zUI()];
+            _isStarted_decorators = [zUI()];
+            _isLaunched_decorators = [zUI()];
+            _progressPercent_decorators = [zUI()];
+            __esDecorate(null, null, _isConstructed_decorators, { kind: "field", name: "isConstructed", static: false, private: false, access: { has: obj => "isConstructed" in obj, get: obj => obj.isConstructed, set: (obj, value) => { obj.isConstructed = value; } }, metadata: _metadata }, _isConstructed_initializers, _isConstructed_extraInitializers);
+            __esDecorate(null, null, _isLoaded_decorators, { kind: "field", name: "isLoaded", static: false, private: false, access: { has: obj => "isLoaded" in obj, get: obj => obj.isLoaded, set: (obj, value) => { obj.isLoaded = value; } }, metadata: _metadata }, _isLoaded_initializers, _isLoaded_extraInitializers);
+            __esDecorate(null, null, _isStarted_decorators, { kind: "field", name: "isStarted", static: false, private: false, access: { has: obj => "isStarted" in obj, get: obj => obj.isStarted, set: (obj, value) => { obj.isStarted = value; } }, metadata: _metadata }, _isStarted_initializers, _isStarted_extraInitializers);
+            __esDecorate(null, null, _isLaunched_decorators, { kind: "field", name: "isLaunched", static: false, private: false, access: { has: obj => "isLaunched" in obj, get: obj => obj.isLaunched, set: (obj, value) => { obj.isLaunched = value; } }, metadata: _metadata }, _isLaunched_initializers, _isLaunched_extraInitializers);
+            __esDecorate(null, null, _progressPercent_decorators, { kind: "field", name: "progressPercent", static: false, private: false, access: { has: obj => "progressPercent" in obj, get: obj => obj.progressPercent, set: (obj, value) => { obj.progressPercent = value; } }, metadata: _metadata }, _progressPercent_initializers, _progressPercent_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
         /**
          * 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);
+        isConstructed = __runInitializers(this, _isConstructed_initializers, new Observable(false));
         /**
          * 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);
+        isLoaded = (__runInitializers(this, _isConstructed_extraInitializers), __runInitializers(this, _isLoaded_initializers, new Observable(false)));
         /**
          * 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);
+        isStarted = (__runInitializers(this, _isLoaded_extraInitializers), __runInitializers(this, _isStarted_initializers, new Observable(false)));
         /**
          * 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);
+        isLaunched = (__runInitializers(this, _isStarted_extraInitializers), __runInitializers(this, _isLaunched_initializers, new Observable(false)));
         /**
          * 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._loadables = new Set();
-        this._startWhenLoaded = false;
-        this._totalLoadables = 0;
-        this._loadedCount = 0;
-    }
-    /**
-     * Start the experience.
-     */
-    start() {
-        if (this.isStarted.value)
-            return;
-        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;
-        this.isLaunched.value = true;
-        this._launchedResolved();
-    }
-    _update() {
-        if (this._loadables.size > 0 && this.isLoaded.value === true) {
-            this.isLoaded.value = false;
-            this._totalLoadables = this._loadables.size;
-            this._loadedCount = 0;
+        progressPercent = (__runInitializers(this, _isLaunched_extraInitializers), __runInitializers(this, _progressPercent_initializers, new Observable(0)));
+        _startedResolved = __runInitializers(this, _progressPercent_extraInitializers);
+        started = new Promise(resolve => {
+            this._startedResolved = resolve;
+        });
+        _constructedResolved;
+        constructed = new Promise(resolve => {
+            this._constructedResolved = resolve;
+        });
+        _launchedResolved;
+        launched = new Promise(resolve => {
+            this._launchedResolved = resolve;
+        });
+        _loadables = new Set();
+        /**
+         * @default false
+         */
+        _startWhenLoaded = false;
+        /**
+         * @default 0
+         */
+        _totalLoadables = 0;
+        /**
+         * @default 0
+         */
+        _loadedCount = 0;
+        /**
+         * Start the experience.
+         */
+        start() {
+            if (this.isStarted.value)
+                return;
+            this.isStarted.value = true;
+            this._startedResolved?.();
         }
-        if (this._loadables.size === 0 && this.isLoaded.value === false) {
-            this.isLoaded.value = true;
+        /**
+         * 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();
         }
-        this.progressPercent.value = this.isLoaded.value ? 100 : (100 * this._loadedCount) / this._totalLoadables;
-        if (this._startWhenLoaded && this.isLoaded.value && !this.isStarted.value) {
-            this.start();
+        /**
+         * 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;
+            this.isLaunched.value = true;
+            this._launchedResolved();
         }
-    }
-    /**
-     * Start the experience when all loadables have completed.
-     */
-    startWhenLoaded() {
-        this._startWhenLoaded = true;
-        this._update();
-    }
-    /**
-     * Register a loadable process.
-     */
-    registerLoadable(p) {
-        if (this.disposed)
-            return;
-        this._loadables.add(p);
-        this._totalLoadables++;
-        p.finally(() => {
+        _update() {
+            if (this._loadables.size > 0 && this.isLoaded.value === true) {
+                this.isLoaded.value = false;
+                this._totalLoadables = this._loadables.size;
+                this._loadedCount = 0;
+            }
+            if (this._loadables.size === 0 && this.isLoaded.value === false) {
+                this.isLoaded.value = true;
+            }
+            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, entity) {
             if (this.disposed)
                 return;
-            this._loadedCount++;
-            this._loadables.delete(p);
+            this._loadables.add(p);
+            this._totalLoadables++;
+            let isComplete = false;
+            const complete = () => {
+                if (this.disposed)
+                    return;
+                if (isComplete)
+                    return;
+                isComplete = true;
+                this._loadedCount++;
+                this._loadables.delete(p);
+                this._update();
+            };
+            entity?.onDispose.addListener(complete);
+            p.finally(complete);
             this._update();
-        });
-        this._update();
-    }
-}
+        }
+    };
+})();
+export { LoadContext };
 /**
  * Returns an observable that indicates whether the experience is loaded.
  */
@@ -192,7 +277,7 @@ export function useLoadPercent(mgr) {
  * Register a loadable process.
  */
 export function registerLoadable(mgr, p) {
-    return mgr.get(LoadContext).registerLoadable(p);
+    return (mgr instanceof Entity ? mgr.contextManager : mgr).get(LoadContext).registerLoadable(p, mgr instanceof Entity ? mgr : undefined);
 }
 /**
  * Starts the experience.
@@ -237,3 +322,68 @@ export function launched(mgr) {
 export function constructionComplete(mgr) {
     return mgr.get(LoadContext).constructionComplete();
 }
+/**
+ * A decorator that registers its decorated function as a loadable process, and
+ * (by default) invokes it automatically once the experience has finished constructing.
+ *
+ * The loader will wait for the returned promise to resolve before hiding itself.
+ * The loadable is registered synchronously during construction so that `isLoaded`
+ * reflects the pending work from the moment the entity exists; the actual method
+ * call is deferred until after the full construction tree settles, so any fields
+ * assigned in subclass constructor bodies are available when it runs.
+ *
+ * Mirrors the structure of {@link zOnConstructed}, {@link zOnStart}, and {@link zOnLaunch};
+ * the only difference is that `zLoad` also registers the deferred work as a loadable.
+ *
+ * @param autoInvoke - If true (default), the method fires automatically after construction.
+ *                     If false, the method must be called manually but will still register as a loadable.
+ */
+export function zLoad(autoInvoke = true) {
+    return (originalMethod, context) => {
+        if (autoInvoke) {
+            context.addInitializer(function () {
+                const deferred = constructed(this.contextManager).then(() => this[context.name].call(this));
+                registerLoadable(this.contextManager, deferred);
+            });
+        }
+        return function (...args) {
+            const promise = originalMethod.call(this, ...args);
+            if (promise instanceof Promise)
+                registerLoadable(this.contextManager, promise);
+            return promise;
+        };
+    };
+}
+/**
+ * A decorator that will automatically call its decorated function when the experience has been started.
+ */
+export function zOnStart() {
+    return (originalMethod, context) => {
+        context.addInitializer(function () {
+            started(this.contextManager).then((...args) => this[context.name].call(this, ...args));
+        });
+        return originalMethod;
+    };
+}
+/**
+ * A decorator that will automatically call its decorated function when the experience has been constructed.
+ */
+export function zOnConstructed() {
+    return (originalMethod, context) => {
+        context.addInitializer(function () {
+            constructed(this.contextManager).then((...args) => this[context.name].call(this, ...args));
+        });
+        return originalMethod;
+    };
+}
+/**
+ * A decorator that will automatically call its decorated function when the experience has been launched.
+ */
+export function zOnLaunch() {
+    return (originalMethod, context) => {
+        context.addInitializer(function () {
+            launched(this.contextManager).then((...args) => this[context.name].call(this, ...args));
+        });
+        return originalMethod;
+    };
+}

package/lib/contexts/orientationcontext.d.ts

@@ -1,12 +1,14 @@
-import { ContextManager, Context } from '../context';
+import { Context, ContextManager } from '../context';
 import { Event } from '../event';
 import { Observable } from '../observable';
-export declare enum Orientation {
-    Portrait = "portrait",
-    Landscape = "landscape",
-    PortraitSecondary = "portrait-secondary",
-    LandscapeSecondary = "landscape-secondary"
-}
+import { ValueOf } from '../types';
+export declare const Orientation: {
+    readonly Portrait: "portrait";
+    readonly Landscape: "landscape";
+    readonly PortraitSecondary: "portrait-secondary";
+    readonly LandscapeSecondary: "landscape-secondary";
+};
+export type OrientationValue = ValueOf<typeof Orientation>;
 /**
  * Manages and tracks orientation changes in the application context.
  * @zcontext
@@ -14,28 +16,24 @@ export declare enum Orientation {
 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>;
     /**
      * Observable representing the current orientation.
      */
-    readonly orientation: Observable<Orientation>;
+    readonly orientation: Observable<OrientationValue>;
     /**
      * Event triggered when the orientation changes to portrait.
      */
@@ -55,7 +53,7 @@ export declare class OrientationContext extends Context {
     /**
      * Event triggered when there is any orientation change.
      */
-    readonly onOrientationChange: Event<[Orientation]>;
+    readonly onOrientationChange: Event<[OrientationValue]>;
     /**
      * Creates an instance of OrientationContext.
      * @param contextManager - The current ContextManager
@@ -75,13 +73,13 @@ export declare class OrientationContext extends Context {
  * @param mgr The ContextManager instance to access the OrientationContext.
  * @returns Observable for orientation change events.
  */
-export declare function useOnOrientationChange(mgr: ContextManager): Event<[Orientation]>;
+export declare function useOnOrientationChange(mgr: ContextManager): Event<[OrientationValue]>;
 /**
  * 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;
+export declare function getOrientation(mgr: ContextManager): OrientationValue;
 /**
  * Determines if the current orientation is portrait.
  * @param mgr The ContextManager instance to access the OrientationContext.