@base-framework/base 3.9.7 → 3.9.8

package/dist/types/modules/animations/animation.d.ts

@@ -29,6 +29,13 @@ export class Animation {
      * @returns {void}
      */
     addMovement(property: any): void;
+    /**
+     * Step every movement of the animation.
+     *
+     * @param {number} delta - The eased progress of the animation (0-1).
+     * @returns {void}
+     */
+    step(delta: number): void;
     /**
      * Setup the movements for the animation.
      *

package/dist/types/modules/component/state-helper.d.ts

@@ -18,6 +18,14 @@ export class StateHelper {
      * @type {Array<any>} remoteStates
      */
     remoteStates: Array<any>;
+    /**
+     * Actions that registered a callBack on the local target.
+     * The subscription token has to be kept or the callBack can
+     * never be released.
+     *
+     * @type {Array<any>} callBackStates
+     */
+    callBackStates: Array<any>;
     /**
      * This will add states to a state.
      *
@@ -60,6 +68,14 @@ export class StateHelper {
      * @returns {void}
      */
     removeRemoteStates(state: object): void;
+    /**
+     * This will release the action callBacks registered on the
+     * local target.
+     *
+     * @param {object} state
+     * @returns {void}
+     */
+    removeLocalStates(state: object): void;
     /**
      * This will remove the actions.
      *
@@ -81,17 +97,17 @@ export class StateHelper {
      * @param {object} target
      * @param {string} actionEvent
      * @param {string} remoteTargetId
-     * @returns {string}
+     * @returns {number} The link token.
      */
-    bindRemoteState(target: object, actionEvent: string, remoteTargetId: string): string;
+    bindRemoteState(target: object, actionEvent: string, remoteTargetId: string): number;
     /**
      * This will unbind a remote state.
      *
      * @param {object} target
-     * @param {string} token
+     * @param {number} token
      * @return {void}
      */
-    unbindRemoteState(target: object, token: string): void;
+    unbindRemoteState(target: object, token: number): void;
     /**
      * This will add the states to the target.
      *
@@ -106,7 +122,7 @@ export class StateHelper {
      *
      * @param {object} target
      * @param {object} action
-     * @returns {string|null}
+     * @returns {number|null}
      */
-    addAction(target: object, action: object): string | null;
+    addAction(target: object, action: object): number | null;
 }

package/dist/types/modules/data/types/basic-data.d.ts

@@ -58,11 +58,20 @@ export class BasicData {
      */
     _refreshState: boolean;
     /**
-     * @type {object} links
-     * @default {}
+     * Link records keyed by subscription token.
+     *
+     * Tokens are the numbers handed out by the event sub, so both
+     * sides of a link pair must key and read this map with a
+     * number. A stringified token would delete nothing.
+     *
+     * @type {Map<number, {data: object, attr: string, pair: number}>} links
      * @protected
      */
-    protected links: object;
+    protected links: Map<number, {
+        data: object;
+        attr: string;
+        pair: number;
+    }>;
     /**
      * @type {string} dataTypeId
      */
@@ -137,7 +146,8 @@ export class BasicData {
      */
     getDataId(): string;
     /**
-     * This is a placeholder.
+     * This will release every subscription and link the data
+     * source holds.
      *
      * @returns {void}
      */
@@ -347,41 +357,47 @@ export class BasicData {
      * @param {object} data
      * @param {string|object} attr
      * @param {string} alias
-     * @returns {string|array}
+     * @returns {number|Array<number>}
      */
-    link(data: object, attr: string | object, alias: string, ...args: any[]): string | any[];
+    link(data: object, attr: string | object, alias: string, ...args: any[]): number | Array<number>;
     /**
      * This will link a remote data source by property.
      *
      * @param {object} data
      * @param {string} attr
      * @param {string} [alias]
-     * @returns {string}
+     * @returns {number} The subscription token.
      */
-    remoteLink(data: object, attr: string, alias?: string): string;
+    remoteLink(data: object, attr: string, alias?: string): number;
     /**
-     * This will add a link token to the links array.
+     * This will add a link token to the links map.
      *
-     * @param {string} token
+     * The attr name is what makes the link removable: subscriptions
+     * are registered per attr message, so a record without one can
+     * only be forgotten, not unsubscribed.
+     *
+     * @param {number} token
      * @param {object} data
+     * @param {string} [attr]
+     * @param {number} [pair] The token of the opposite direction.
      * @returns {void}
      */
-    addLink(token: string, data: object): void;
+    addLink(token: number, data: object, attr?: string, pair?: number): void;
     /**
      * This will remove a link or all links if no token is provided.
      *
-     * @param {string|null} [token=null]
+     * @param {number|null} [token=null]
      * @returns {void}
      */
-    unlink(token?: string | null): void;
+    unlink(token?: number | null): void;
     /**
      * This will remove the linked subscription.
      *
-     * @param {string} token
+     * @param {number} token
      * @param {boolean} [removeFromLinks=true]
      * @returns {void}
      */
-    removeLink(token: string, removeFromLinks?: boolean): void;
+    removeLink(token: number, removeFromLinks?: boolean): void;
     isData: boolean;
 }
 import { DataPubSub } from '../../data-binder/data-pub-sub.js';

package/dist/types/modules/data/types/deep-data/data-utils.d.ts

@@ -25,18 +25,4 @@ export namespace DataUtils {
      */
     function getSegments(str: string): Array<any> | null;
 }
-/**
- * Simple LRU Cache implementation for caching parsed path segments.
- * Caches up to 1000 most recently used paths (~50KB memory overhead).
- *
- * @class
- */
-declare class LRUCache {
-    constructor(maxSize?: number);
-    cache: Map<any, any>;
-    maxSize: number;
-    get(key: any): any;
-    set(key: any, value: any): void;
-    clear(): void;
-}
-export {};
+import { LRUCache } from '../../../../shared/lru-cache.js';

package/dist/types/modules/data-binder/data-pub-sub.d.ts

@@ -83,6 +83,31 @@ export class DataPubSub {
      * @protected
      */
     protected flushCallbacks: Array<Function>;
+    /**
+     * The message currently being delivered, used to spot a
+     * subscriber that re-publishes its own message.
+     *
+     * @type {string|null}
+     * @protected
+     */
+    protected deliveringMessage: string | null;
+    /**
+     * Messages whose own subscribers re-published them during the
+     * current flush cycle. Allocated only when it happens.
+     *
+     * @type {Set<string>|null}
+     * @protected
+     */
+    protected reentrantMessages: Set<string> | null;
+    /**
+     * When true, publishes are dropped instead of queued. Set
+     * while the flush breaker drains the surviving updates so the
+     * runaway cascade cannot restart.
+     *
+     * @type {boolean}
+     * @protected
+     */
+    protected suppressQueue: boolean;
     /**
      * This will get a subscriber array.
      *
@@ -183,6 +208,19 @@ export class DataPubSub {
      * @returns {void}
      */
     flush(): void;
+    /**
+     * Stop a runaway cascade without discarding the updates that
+     * were only queued alongside it.
+     *
+     * Dropping the whole queue loses the last value of every
+     * unrelated message. Only the self-republishing messages are
+     * dropped; the rest are delivered once with queueing suppressed,
+     * which guarantees the loop cannot restart.
+     *
+     * @protected
+     * @returns {void}
+     */
+    protected _breakCascade(): void;
     /**
      * Resolve all pending flush completion promises and execute callbacks.
      *

package/dist/types/modules/router/utils.d.ts

@@ -6,4 +6,15 @@ export namespace Utils {
      * @returns {string}
      */
     function removeSlashes(uri: string): string;
+    /**
+     * This will get the pathname style uri from a hash url.
+     *
+     * The hashchange event reports absolute urls, but route patterns
+     * are anchored against the uri that `Router.getPath()` produces
+     * for hash routing, which is the hash without its '#'.
+     *
+     * @param {string} url
+     * @returns {string}
+     */
+    function getHashUri(url: string): string;
 }

package/dist/types/modules/state/state-tracker.d.ts

@@ -13,6 +13,19 @@ export class StateTracker {
      * @private
      */
     private static targets;
+    /**
+     * The number of owners that have attached to each target.
+     *
+     * Targets are keyed by the owning component's unique instance id,
+     * so without a release path the map grows by one entry per mount
+     * and never shrinks. Counting owners keeps ids that are shared on
+     * purpose (a `stateTargetId` override) alive until the last one
+     * detaches.
+     *
+     * @type {Map<string, number>} ownerCounts
+     * @private
+     */
+    private static ownerCounts;
     /**
      * This will restore a state target.
      *
@@ -28,6 +41,35 @@ export class StateTracker {
      * @returns {StateTarget}
      */
     static getTarget(id: string): StateTarget;
+    /**
+     * This will get the state target and claim ownership of it.
+     *
+     * Every attach must be paired with a detach or the target is
+     * retained for the life of the page.
+     *
+     * @param {string} id
+     * @returns {StateTarget}
+     */
+    static attach(id: string): StateTarget;
+    /**
+     * This will record an owner of a target.
+     *
+     * @protected
+     * @param {string} id
+     * @returns {void}
+     */
+    protected static addOwner(id: string): void;
+    /**
+     * This will release an owner of a state target. The target is
+     * reset and dropped once the last owner detaches.
+     *
+     * Ids that were never attached (targets created on demand by
+     * getTarget, e.g. app level states) are left alone.
+     *
+     * @param {string} id
+     * @returns {void}
+     */
+    static detach(id: string): void;
     /**
      * This will get the state of an action.
      *
@@ -60,10 +102,10 @@ export class StateTracker {
      *
      * @param {string} targetId
      * @param {string} action
-     * @param {string} [token]
+     * @param {number} [token]
      * @returns {void}
      */
-    static removeAction(targetId: string, action: string, token?: string): void;
+    static removeAction(targetId: string, action: string, token?: number): void;
     /**
      * This will add a new subscriber to the action.
      *
@@ -78,19 +120,19 @@ export class StateTracker {
      *
      * @param {string} targetId
      * @param {string} action
-     * @param {string} token
+     * @param {number} token
      * @returns {void}
      */
-    static off(targetId: string, action: string, token: string): void;
+    static off(targetId: string, action: string, token: number): void;
     /**
      * This will remove a target or action or callBack.
      *
      * @param {string} targetId
      * @param {string} [action]
-     * @param {string} [token]
+     * @param {number} [token]
      * @returns {void}
      */
-    static remove(targetId: string, action?: string, token?: string): void;
+    static remove(targetId: string, action?: string, token?: number): void;
     /**
      * This will set the action state.
      *

package/dist/types/shared/lru-cache.d.ts

@@ -0,0 +1,77 @@
+/**
+ * LRUCache
+ *
+ * A bounded cache with least-recently-used eviction, used to keep
+ * the module level parse/lookup caches from growing for the life of
+ * the page.
+ *
+ * Recency is the Map's own insertion order: re-inserting a key moves
+ * it to the end, so the first key returned by the iterator is always
+ * the least recently used one.
+ *
+ * @class
+ */
+export class LRUCache {
+    /**
+     * This will create an LRU cache.
+     *
+     * @constructor
+     * @param {number} [maxSize=1000]
+     */
+    constructor(maxSize?: number);
+    /**
+     * @type {Map<*, *>} cache
+     * @protected
+     */
+    protected cache: Map<any, any>;
+    /**
+     * @type {number} maxSize
+     */
+    maxSize: number;
+    /**
+     * The most recently used key. Reads of the hottest key are by
+     * far the common case, and comparing against this avoids the
+     * delete/set pair that promotion would otherwise cost.
+     *
+     * @type {*} lastKey
+     * @protected
+     */
+    protected lastKey: any;
+    /**
+     * This will get a value and promote the key to most recently
+     * used.
+     *
+     * @param {*} key
+     * @returns {*} The value or undefined when not cached.
+     */
+    get(key: any): any;
+    /**
+     * This will check if a key is cached without promoting it.
+     *
+     * @param {*} key
+     * @returns {boolean}
+     */
+    has(key: any): boolean;
+    /**
+     * This will add a value and promote the key to most recently
+     * used, evicting the least recently used key when over capacity.
+     *
+     * @param {*} key
+     * @param {*} value
+     * @returns {void}
+     */
+    set(key: any, value: any): void;
+    /**
+     * This will remove a key.
+     *
+     * @param {*} key
+     * @returns {void}
+     */
+    delete(key: any): void;
+    /**
+     * This will empty the cache.
+     *
+     * @returns {void}
+     */
+    clear(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@base-framework/base",
-	"version": "3.9.7",
+	"version": "3.9.8",
 	"description": "This is a javascript framework.",
 	"main": "./dist/base.js",
 	"module": "./dist/base.js",