mftsccs-browser 2.2.39-beta → 2.2.41-beta

package/dist/types/Api/GetConnections/GetConnectionsByTypesApi.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from "../../app";
+import { GetConnectionsByTypes } from "../../DataStructures/ConnectionByType/GetConnectionsByType";
+export declare function GetConnectionsByApiTypes(connectionTypes: GetConnectionsByTypes): Promise<Connection[]>;

package/dist/types/DataStructures/BinaryTree.d.ts

@@ -1,13 +1,77 @@
 import { Concept } from "../DataStructures/Concept";
 import { Node } from "./Node";
+/**
+ * BinaryTree — In-memory concept store keyed by numeric concept ID.
+ *
+ * Backed by a Map<number, Concept> for O(1) lookups, inserts, and deletes.
+ * Also maintains the BinaryCharacterTree (character-indexed) on every insert
+ * so character-based search continues to work.
+ *
+ * All public method signatures are preserved for backward compatibility.
+ * getNodeFromTree returns a { key, value } wrapper so callers that access
+ * node.value continue to work without changes.
+ */
 export declare class BinaryTree {
+    /** Sentinel root — non-null when the map has data, null when empty. */
     static root: Node | null;
-    static addNodeToTree(node: Node): Node | undefined;
+    /** Primary data store: concept ID → Concept object */
+    private static conceptMap;
+    /**
+     * Low-level add — stores the node's key/value in the Map.
+     * Kept for API compatibility (called internally by addConceptToTree).
+     * @param node - Node with numeric key and Concept value
+     */
+    static addNodeToTree(node: Node): void;
+    /**
+     * Polls until IdentifierFlags.isDataLoaded is true (max 25 seconds).
+     * Used by callers that need to wait for the initial IndexedDB load to finish.
+     */
     static waitForDataToLoad(): Promise<unknown>;
+    /** Recursive polling helper for waitForDataToLoad */
     static checkFlag(resolve: any): any;
+    /**
+     * Adds a concept to both the ID map and the character tree.
+     *
+     * The character tree (BinaryCharacterTree) is still an AVL tree because
+     * it supports character-based search which is out of scope for this refactor.
+     *
+     * @param concept - The Concept to store
+     */
     static addConceptToTree(concept: Concept): void;
+    /**
+     * Retrieves a concept by ID from the Map.
+     *
+     * Returns a { key, value } wrapper matching the Node shape that callers expect.
+     * Callers access the returned object's .value property to get the Concept.
+     *
+     * @param id - The concept ID to look up
+     * @returns Node-like wrapper with .value = Concept, or null if not found
+     */
     static getNodeFromTree(id: number): Promise<Node | null>;
+    /**
+     * Removes a concept by ID. Dispatches an event before deletion
+     * so listeners (e.g. UI components) can react to the removal.
+     *
+     * @param id - The concept ID to remove
+     */
     static removeNodeFromTree(id: number): Promise<void>;
-    static getConceptListFromIds(ids: number[], connectionArray: Concept[], remainingIds: any): Promise<void>;
+    /**
+     * Bulk concept retrieval by ID list.
+     *
+     * For each ID found in the Map, pushes the Concept into conceptArray
+     * and removes the ID from the ids array. IDs remaining in the array
+     * after this call are "not found" and will be fetched from the backend.
+     *
+     * Performance: O(k) where k = ids.length (was O(N) full tree traversal).
+     *
+     * @param ids - Array of concept IDs to look up (mutated: found IDs are spliced out)
+     * @param conceptArray - Output array (mutated: found Concepts are pushed)
+     * @param remainingIds - Not used directly but kept for API compatibility
+     */
+    static getConceptListFromIds(ids: number[], conceptArray: Concept[], remainingIds: any): Promise<void>;
+    /**
+     * Returns the total number of concepts stored.
+     * @returns Number of concepts in the Map
+     */
     static countNumberOfNodes(): number;
 }

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionBinaryTree.d.ts

@@ -1,13 +1,81 @@
 import { Connection } from "../../DataStructures/Connection";
 import { ConnectionNode } from "./ConnectionNode";
+/**
+ * ConnectionBinaryTree — In-memory connection store keyed by numeric connection ID.
+ *
+ * Backed by a Map<number, Connection> for O(1) lookups, inserts, and deletes.
+ * The secondary index trees (ConnectionTypeTree, ConnectionOfTheTree) are
+ * managed separately by ConnectionData and remain unchanged.
+ *
+ * All public method signatures are preserved for backward compatibility.
+ * getNodeFromTree returns a { key, value } wrapper so callers that access
+ * node.value continue to work without changes.
+ */
 export declare class ConnectionBinaryTree {
+    /** Sentinel root — non-null when the map has data, null when empty. */
     static connectionroot: ConnectionNode | null;
-    static addNodeToTree(node: ConnectionNode): ConnectionNode | undefined;
+    /** Primary data store: connection ID → Connection object */
+    private static connectionMap;
+    /**
+     * Low-level add — stores the node's key/value in the Map.
+     * Kept for API compatibility.
+     * @param node - ConnectionNode with numeric key and Connection value
+     */
+    static addNodeToTree(node: ConnectionNode): void;
+    /**
+     * Adds a connection to the Map and dispatches an event for the
+     * owning concept so UI listeners can react.
+     *
+     * The dispatchIdEvent(ofTheConceptId) was previously fired inside
+     * ConnectionNode.addNode when the node was placed into a null slot.
+     * We only fire it for new connections (not overwrites) to preserve
+     * the original behavior.
+     *
+     * @param connection - The Connection to store
+     */
     static addConnectionToTree(connection: Connection): void;
-    static traverse(): number | undefined;
+    /**
+     * Returns the total number of connections stored.
+     * @returns Number of connections in the Map
+     */
+    static traverse(): number;
+    /**
+     * Polls until IdentifierFlags.isConnectionLoaded is true (max 25 seconds).
+     * Used by callers that need to wait for the initial IndexedDB load to finish.
+     */
     static waitForDataToLoad(): Promise<unknown>;
+    /** Recursive polling helper for waitForDataToLoad */
     static checkFlag(resolve: any): any;
+    /**
+     * Removes a connection by ID. Dispatches an event for the owning concept
+     * before deletion so listeners can react to the removal.
+     *
+     * @param id - The connection ID to remove
+     */
     static removeNodeFromTree(id: number): Promise<void>;
+    /**
+     * Retrieves a connection by ID from the Map.
+     *
+     * Returns a { key, value } wrapper matching the ConnectionNode shape.
+     * Also increments the connection's count field for access tracking
+     * (preserving the original ConnectionNode.getFromNode behavior).
+     *
+     * @param id - The connection ID to look up
+     * @returns ConnectionNode-like wrapper with .value = Connection, or null/undefined
+     */
     static getNodeFromTree(id: number): Promise<ConnectionNode | null | undefined>;
+    /**
+     * Bulk connection retrieval by ID list.
+     *
+     * For each ID found in the Map, pushes the Connection into connectionArray
+     * and removes the ID from the ids array. IDs remaining after this call
+     * are "not found" and will be fetched from the backend.
+     *
+     * Performance: O(k) where k = ids.length (was O(N) full tree traversal).
+     *
+     * @param ids - Array of connection IDs to look up (mutated: found IDs are spliced out)
+     * @param connectionArray - Output array (mutated: found Connections are pushed)
+     * @param remainingIds - Not used directly but kept for API compatibility
+     */
     static getConnectionListFromIds(ids: number[], connectionArray: Connection[], remainingIds: any): Promise<void>;
 }

package/dist/types/DataStructures/ConnectionByType/GetConnectionsByType.d.ts

@@ -0,0 +1,4 @@
+export declare class GetConnectionsByTypes {
+    ofTheConceptId: number;
+    connectionTypes: string[];
+}

package/dist/types/DataStructures/PwaStorageManager.d.ts

@@ -0,0 +1,25 @@
+import { Concept } from "./Concept";
+import { Connection } from "./Connection";
+/**
+ * Manages localStorage persistence for PWA mode.
+ *
+ * Strategy:
+ * - Reads: always from memory (BinaryTree), never from localStorage at runtime
+ * - Writes: batched and deferred to avoid blocking the main thread
+ * - Startup: bulk load from localStorage into memory once
+ */
+export declare class PwaStorageManager {
+    private static CONCEPT_PREFIX;
+    private static CONNECTION_PREFIX;
+    private static writeQueue;
+    private static deleteQueue;
+    private static flushTimer;
+    private static scheduleFlush;
+    static saveConcept(concept: Concept): void;
+    static saveConnection(connection: Connection): void;
+    static removeConcept(id: number): void;
+    static removeConnection(id: number): void;
+    static loadAllConcepts(): Concept[];
+    static loadAllConnections(): Connection[];
+    static clearAll(): void;
+}

package/dist/types/DataStructures/Search/FreeschemaQuery.d.ts

@@ -20,4 +20,5 @@ export declare class FreeschemaQuery {
     isSecure: boolean;
     includeInFilter: boolean;
     isOldConnectionType: boolean;
+    cache: boolean;
 }

package/dist/types/DataStructures/Security/SecureStorage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Encrypts and stores a profile object in localStorage.
+ * Uses AES-GCM with a browser-bound derived key so the ciphertext
+ * is not portable to other origins or browsers.
+ */
+export declare function saveProfile(profile: Record<string, any>): Promise<void>;
+/**
+ * Decrypts and returns the stored profile, or null if absent/tampered.
+ */
+export declare function loadProfile(): Promise<Record<string, any> | null>;
+/**
+ * Removes the stored profile.
+ */
+export declare function clearProfile(): void;

package/dist/types/DataStructures/Security/TokenStorage.d.ts

@@ -1,5 +1,23 @@
 export declare class TokenStorage {
     static BearerAccessToken: string;
+    static refreshToken: string;
     static sessionId: number;
+    /** In-memory cache of the decrypted profile — populated by saveUserProfile or hydrateProfile */
+    static profileCache: Record<string, any> | null;
     static setSession(sessionId: any): void;
+    /**
+     * Stores user profile securely (encrypted in sessionStorage)
+     * and keeps the token in memory for API calls.
+     * Also populates profileCache so getUserDetails() works synchronously.
+     */
+    static saveUserProfile(signinResponse: any): Promise<boolean>;
+    /**
+     * Call once at app startup (e.g. in init()) to decrypt the stored profile
+     * into memory so that getUserDetails() can read it synchronously.
+     */
+    static hydrateProfile(): Promise<void>;
+    /**
+     * Clears all stored credentials and profile data.
+     */
+    static logout(): void;
 }

package/dist/types/Database/CacheDatabase.d.ts

@@ -0,0 +1,57 @@
+/** Names of the four object stores */
+declare const STORE_WIDGET = "widgetCache";
+declare const STORE_LATEST = "latestWidgetCache";
+declare const STORE_RECENT = "recentWidgetCache";
+declare const STORE_QUERY = "queryCache";
+/**
+ * Opens (or returns the already-opened) cache database.
+ *
+ * The database name includes the API base URL and application identifier so that
+ * different environments/applications each get their own isolated cache store,
+ * matching the naming convention used by the main database in indexeddb.ts.
+ *
+ * @returns Promise resolving to the IDBDatabase instance
+ */
+export declare function openCacheDatabase(): Promise<IDBDatabase>;
+/**
+ * Retrieves a single record from the specified store by key.
+ *
+ * @param storeName - The object store to read from
+ * @param key - The key to look up (number for widget stores, string for queryCache)
+ * @returns The stored value, or null if not found
+ */
+export declare function cacheGet(storeName: string, key: IDBValidKey): Promise<any | null>;
+/**
+ * Writes a record to the specified store (insert or update).
+ *
+ * For stores with in-line keys (widget stores), the key is read from the object's
+ * "id" field. For the queryCache store (out-of-line keys), pass the key explicitly.
+ *
+ * @param storeName - The object store to write to
+ * @param value - The value to store
+ * @param key - Optional explicit key (required for queryCache which has no keyPath)
+ */
+export declare function cachePut(storeName: string, value: any, key?: IDBValidKey): Promise<void>;
+/**
+ * Deletes a single record from the specified store by key.
+ *
+ * @param storeName - The object store to delete from
+ * @param key - The key of the record to delete
+ */
+export declare function cacheDelete(storeName: string, key: IDBValidKey): Promise<void>;
+/**
+ * Clears ALL records from the specified store.
+ *
+ * @param storeName - The object store to clear
+ */
+export declare function cacheClear(storeName: string): Promise<void>;
+/**
+ * Retrieves ALL records from the specified store.
+ * Used during init() to load persisted cache data into memory.
+ *
+ * @param storeName - The object store to read from
+ * @returns Array of all stored records
+ */
+export declare function cacheGetAll(storeName: string): Promise<any[]>;
+/** Export store name constants so callers don't need magic strings */
+export { STORE_WIDGET, STORE_LATEST, STORE_RECENT, STORE_QUERY };

package/dist/types/Database/indexeddb.d.ts

@@ -1,14 +1,19 @@
 import { SettingData } from "../DataStructures/SettingData";
 /**
- * This class will help us store the indexdb  reference in memory and not go back to index db.
+ * This class will help us store the indexdb reference in memory and not go back to index db.
  */
 export declare class IndexDb {
     static db: IDBDatabase;
 }
 /**
+ * Opens the FreeSchema IndexedDB database (or returns the cached instance).
  *
- * @param databaseName not required actually. This is not used you can pass anything.
- * @returns a promise that either resolves or rejects opening the database.
+ * - Returns the cached db reference immediately if already open.
+ * - Deduplicates concurrent calls — only one indexedDB.open() runs at a time.
+ * - On error, rejects without deleting the database to avoid data loss.
+ *
+ * @param databaseName kept for backward compatibility (not used in db name)
+ * @returns a promise resolving to the IDBDatabase instance
  */
 export declare function openDatabase(databaseName: string): Promise<IDBDatabase>;
 /**

package/dist/types/Services/CacheClear.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Clears all application caches (both in-memory and IndexedDB).
+ *
+ * Call this on user logout or when you need to force-refresh all cached data.
+ * Clears widget caches (standard, latest, recent) and query caches.
+ */
+export declare function clearAllCaches(): void;

package/dist/types/Services/CreateBinaryTreeFromData.d.ts

@@ -1,4 +1,5 @@
 /**
- * This function builds up the binary tree on startup from the indexdb
+ * This function builds up the binary tree on startup from the indexdb.
+ * Processes records in chunks to avoid blocking the main thread.
  */
 export default function CreateConceptBinaryTreeFromIndexDb(): Promise<void>;

package/dist/types/Services/Delete/DeleteConnectionByIdLocal.d.ts

@@ -0,0 +1 @@
+export declare function DeleteConnectionByIdLocal(toDeleteIds: number[]): void;

package/dist/types/Services/Search/DataFormat.d.ts

@@ -0,0 +1,23 @@
+import { Connection } from "../../app";
+/**
+* ## Format Just-Id ##
+* this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
+* This is then passed on further for stiching.
+* @param connections
+* @param compositionData
+* @param reverse
+* @returns
+*/
+export declare function FormatFunctionDataForClean(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;
+/**
+ * ############ Format is Just Id and is used for list. ############
+ * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+ * The list format is helpful because you do not have to go over each individual query.
+ * @param connections the type connections that need (external connections) to be passed
+ * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+ * @param mainComposition this is list of  ids of the main composition that builds the tree
+ * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+ * @returns
+ */
+export declare function FormatFromConnectionsAlteredArrayExternalClean(connections: Connection[], compositionData: any[], mainComposition: number[], reverse: number[] | undefined, CountDictionary: any[]): Promise<any[]>;
+export declare function AddCount(ofTheConceptId: number, CountDictionary: any, newData: any): void;

package/dist/types/Services/User/UserFromLocalStorage.d.ts

@@ -1,6 +1,5 @@
-export declare function getUserDetails(): {
-    entity: number;
-    userConcept: number;
-    userId: number;
-    token: string;
-};
+/**
+ * Returns user details synchronously.
+ * Priority: in-memory profileCache (encrypted) → legacy localStorage("profile") fallback.
+ */
+export declare function getUserDetails(): Record<string, any>;

package/dist/types/Services/automated/auotmated-update.d.ts

@@ -0,0 +1,2 @@
+import { Concept } from "../../app";
+export declare function UpdateData(json: any, ofConcept: Concept, typeStrings?: string[]): Promise<void>;

package/dist/types/Widgets/BuilderStatefulWidget.d.ts

@@ -108,7 +108,7 @@ export declare class BuilderStatefulWidget extends StatefulWidget {
      * const userId = await widget.getUserId();
      * console.log('Current user:', userId);
      */
-    getUserId(): Promise<any>;
+    getUserId(): any;
     /**
      * Fetches a list of type values from the backend based on the widget's type.
      *

package/dist/types/Widgets/WidgetCacheManager.d.ts

@@ -1,17 +1,100 @@
+/**
+ * WidgetCacheManager — In-memory cache with IndexedDB persistence for widget data.
+ *
+ * Architecture:
+ *   - **Reads** are synchronous from in-memory Maps (fastest possible lookup).
+ *   - **Writes** update the in-memory Map immediately, then persist to IndexedDB
+ *     in the background (fire-and-forget) so data survives page reloads.
+ *   - **On startup**, `init()` loads all persisted data from IndexedDB into the Maps.
+ *
+ * This gives us the speed of in-memory access (no async overhead, no JSON.parse)
+ * with the durability of IndexedDB (no 5 MB limit, survives reloads).
+ *
+ * Three separate caches are maintained:
+ *   - **widgetMap**  — standard widget data keyed by widget ID
+ *   - **latestMap**  — latest published version keyed by origin ID
+ *   - **recentMap**  — recent published version keyed by origin ID
+ */
 export declare class WidgetCacheManager {
-    private static WIDGET_PREFIX;
-    private static LATEST_PREFIX;
-    private static RECENT_PREFIX;
+    /** In-memory cache for standard widget data */
+    private static widgetMap;
+    /** In-memory cache for latest-version widget data */
+    private static latestMap;
+    /** In-memory cache for recent-version widget data */
+    private static recentMap;
+    /**
+     * Loads all persisted widget cache data from IndexedDB into memory.
+     * Call this once during app initialization (e.g. in init() or initConceptConnection()).
+     * Safe to call multiple times — just overwrites the Maps.
+     */
+    static init(): Promise<void>;
+    /**
+     * Retrieves cached widget data by widget ID (synchronous, from memory).
+     * @param id - The widget ID to look up
+     * @returns The cached data object, or null if not cached
+     */
     static getWidget(id: number): any | null;
+    /**
+     * Stores widget data in memory and persists to IndexedDB in the background.
+     * Skips if data is identical to what's already cached (dedup guard).
+     * @param id - The widget ID
+     * @param data - The widget data object to cache
+     */
     static setWidget(id: number, data: any): void;
+    /**
+     * Removes a single widget entry from memory and IndexedDB.
+     * @param id - The widget ID to remove
+     */
+    static removeWidget(id: number): void;
+    /**
+     * Retrieves cached latest-version widget data (synchronous, from memory).
+     * @param id - The origin widget ID
+     * @returns The cached data object, or null if not cached
+     */
     static getLatest(id: number): any | null;
+    /**
+     * Stores latest-version widget data in memory and persists to IndexedDB.
+     * Skips if data is identical to what's already cached.
+     * @param id - The origin widget ID
+     * @param data - The latest widget data to cache
+     */
     static setLatest(id: number, data: any): void;
+    /**
+     * Removes a single latest-version entry from memory and IndexedDB.
+     * @param id - The origin widget ID to remove
+     */
+    static removeLatest(id: number): void;
+    /**
+     * Retrieves cached recent-version widget data (synchronous, from memory).
+     * @param id - The origin widget ID
+     * @returns The cached data object, or null if not cached
+     */
     static getRecent(id: number): any | null;
+    /**
+     * Stores recent-version widget data in memory and persists to IndexedDB.
+     * Skips if data is identical to what's already cached.
+     * @param id - The origin widget ID
+     * @param data - The recent widget data to cache
+     */
     static setRecent(id: number, data: any): void;
-    static removeWidget(id: number): void;
-    static removeLatest(id: number): void;
+    /**
+     * Removes a single recent-version entry from memory and IndexedDB.
+     * @param id - The origin widget ID to remove
+     */
     static removeRecent(id: number): void;
+    /**
+     * Clears all three widget caches from both memory and IndexedDB.
+     * Useful for cache invalidation on logout or environment switch.
+     */
     static clearAll(): void;
-    private static _get;
-    private static _set;
+    /**
+     * Checks if the new data is identical to what's already in the Map.
+     * Prevents unnecessary IndexedDB writes when data hasn't changed.
+     *
+     * @param map - The in-memory Map to check against
+     * @param id - The key to check
+     * @param data - The new data to compare
+     * @returns true if data is a duplicate (should be skipped)
+     */
+    private static _isDuplicate;
 }

package/dist/types/WrapperFunctions/DepenedencyObserver.d.ts

@@ -76,7 +76,7 @@ export declare class DependencyObserver {
      * @param errorCallback - Optional function to call when errors occur
      * @returns Result of calling the callback with current data
      */
-    subscribe(callback: any, errorCallback?: (error: Error) => void): Promise<any>;
+    subscribe(callback: any, errorCallback?: (error: Error) => void): any;
     /**
      * Executes the observable once without subscribing to updates.
      * @returns The executed data

package/dist/types/WrapperFunctions/QueryCacheManager.d.ts

@@ -1,10 +1,98 @@
+/**
+ * QueryCacheManager — In-memory cache with IndexedDB persistence for freeschema query results.
+ *
+ * Architecture:
+ *   - **Reads** (`get`) are synchronous from an in-memory Map — no async overhead.
+ *   - **Writes** (`set`) update the Map immediately, then persist to IndexedDB
+ *     in the background (fire-and-forget). Also dispatches a CustomEvent so
+ *     active subscribers (SchemaQueryObservable) can re-render with fresh data.
+ *   - **On startup**, `init()` loads all persisted query results from IndexedDB
+ *     into the Map so cached data is available from the very first read.
+ *
+ * This gives us the speed of in-memory access with the durability of IndexedDB
+ * (no 5 MB localStorage limit, survives page reloads).
+ *
+ * The stale-while-revalidate flow in FreeschemaQueryApi:
+ *   1. `get(hash)` returns cached data synchronously from memory
+ *   2. Caller returns cached data to UI immediately
+ *   3. Background fetch gets fresh data from API
+ *   4. `set(hash, fresh)` updates memory + IndexedDB + fires CustomEvent
+ *   5. Subscribers pick up the event and re-render with fresh data
+ */
 export declare class QueryCacheManager {
+    /** Prefix for CustomEvent names — ensures no collision with other window events */
     private static prefix;
+    /** In-memory cache: hash → query result data */
+    private static cacheMap;
+    /**
+     * Loads all persisted query cache data from IndexedDB into memory.
+     * Call this once during app initialization.
+     * Safe to call multiple times — just overwrites the Map.
+     */
+    static init(): Promise<void>;
+    /**
+     * Computes a SHA-256 hash of a query object for use as a cache key.
+     *
+     * The query is canonicalized by recursively sorting all object keys before
+     * hashing, so that `{a:1, b:2}` and `{b:2, a:1}` produce the same hash.
+     *
+     * @param query - The freeschema query object to hash
+     * @returns Hex-encoded SHA-256 hash string
+     */
     static getHash(query: any): Promise<string>;
+    /**
+     * Retrieves cached query results by hash key (synchronous, from memory).
+     *
+     * @param hash - The SHA-256 hash of the query (from getHash)
+     * @returns The cached result data, or null if not found
+     */
     static get(hash: string): any | null;
+    /**
+     * Stores query results in memory, persists to IndexedDB, and notifies subscribers.
+     *
+     * Includes a deduplication guard: if the new data serializes identically to
+     * what's already in memory, the write and event dispatch are both skipped.
+     * This prevents infinite revalidation loops (set → event → fetch → set → ...).
+     *
+     * @param hash - The SHA-256 hash key for this query
+     * @param data - The query result data to cache
+     */
     static set(hash: string, data: any): void;
+    /**
+     * Subscribes to cache updates for a specific query hash.
+     *
+     * Uses window CustomEvents (synchronous, in-memory) so subscribers are
+     * notified immediately when `set()` is called — no IndexedDB polling needed.
+     *
+     * @param hash - The query hash to listen for updates on
+     * @param callback - Function called with the fresh data when cache is updated
+     * @returns An unsubscribe function — call it to stop listening
+     */
     static subscribe(hash: string, callback: (data: any) => void): () => void;
+    /**
+     * Removes a single cached query result from memory and IndexedDB.
+     * @param hash - The query hash key to remove
+     */
     static remove(hash: string): void;
+    /**
+     * Clears all cached query results from memory and IndexedDB.
+     * Useful for cache invalidation on logout or environment switch.
+     */
     static clearAll(): void;
 }
+/**
+ * Computes a deterministic SHA-256 hash of any JSON-serializable object.
+ *
+ * To ensure that semantically identical objects always produce the same hash
+ * regardless of property insertion order, all object keys are recursively sorted
+ * before serialization. Arrays maintain their order (only object keys are sorted).
+ *
+ * @param obj - Any JSON-serializable value (object, array, string, number, etc.)
+ * @returns Hex-encoded SHA-256 hash string (64 characters)
+ *
+ * @example
+ * // These produce the same hash:
+ * await hashJsonObject({ a: 1, b: 2 });
+ * await hashJsonObject({ b: 2, a: 1 });
+ */
 export declare function hashJsonObject(obj: any): Promise<string>;

package/dist/types/app.d.ts

@@ -123,8 +123,10 @@ export { DeleteUser } from './Services/DeleteConcept';
 export { AccessTracker } from './AccessTracker/accessTracker';
 export { CreateConnectionBetweenEntityLocal } from './Services/CreateConnection/CreateConnectionEntity';
 export { BuildWidgetFromId } from './Widgets/WidgetBuild';
+export { clearAllCaches } from './Services/CacheClear';
 export { removeAllChildren } from './Services/Common/RemoveAllChild';
 export { getUserDetails } from './Services/User/UserFromLocalStorage';
+export { TokenStorage } from './DataStructures/Security/TokenStorage';
 export { CountInfo } from './DataStructures/Count/CountInfo';
 export { LogEvent } from './Services/Logs/LogEvent';
 export { Selector } from './Api/Prototype/Selector';
@@ -345,6 +347,7 @@ declare function init(url?: string, aiurl?: string, accessToken?: string, nodeUr
     logPackage?: boolean;
     accessTracker?: boolean;
     isTest?: boolean;
+    accessControl?: boolean;
 }, parameters?: {
     logserver?: string;
     isPwa?: boolean;

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "mftsccs-browser",
-  "version": "2.2.39-beta",
-
+  "version": "2.2.41-beta",
   "environment": "production",
   "description": "Full Pack of concept and connection system",
   "main": "dist/main.bundle.js",