@flashist/appframework 0.0.267 → 0.0.268

package/src/state/data/DeepKeyTypings.d.ts

@@ -0,0 +1,25 @@
+type Writable<T, O> = T extends O ? T : {
+    [P in keyof T as IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, P>]: T[P];
+};
+type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
+type Cleanup<T> = 0 extends (1 & T) ? unknown : T extends readonly any[] ? (Exclude<keyof T, keyof any[]> extends never ? {
+    [k: `${number}`]: T[number];
+} : Omit<T, keyof any[]>) : T;
+type PrefixKeys<V, K extends PropertyKey, O> = V extends O ? {
+    [P in K]: V;
+} : V extends object ? {
+    [P in keyof V as `${Extract<K, string | number>}.${Extract<P, string | number>}`]: V[P];
+} : {
+    [P in K]: V;
+};
+type ValueOf<T> = T[keyof T];
+export type Flatten<T, O = never> = Writable<Cleanup<T>, O> extends infer U ? U extends O ? U : U extends object ? ValueOf<{
+    [K in keyof U]-?: (x: PrefixKeys<Flatten<U[K], O>, K, O>) => void;
+}> | ((x: U) => void) extends (x: infer I) => void ? {
+    [K in keyof I]: I[K];
+} : never : U : never;
+export {};

package/src/state/data/DeepKeyTypings.js

@@ -0,0 +1,144 @@
+export {};
+// function lookup<T, K extends keyof Flatten<T>>(obj: T, key: K): Flatten<T>[K];
+// function lookup(obj: any, key: string) {
+//     const i = key.indexOf(".");
+//     return (i < 0) ? obj[key] : (lookup as any)(obj[key.substring(0, i)], key.substring(i + 1));
+// }
+/*
+// TRY #2: EXAMPLES OF USING
+
+// function shortLookup<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(obj: ObjectType, key: DeepKeyType, value: ValueType): void {
+function shortLookup<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>>(obj: ObjectType = {} as any, key: DeepKeyType, value: Flatten<ObjectType>[DeepKeyType]): void {
+    // const i = key.indexOf(".");
+    // return (i < 0) ? obj[key] : (lookup as any)(obj[key.substring(0, i)], key.substring(i + 1));
+}
+
+function myLookup<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(obj: ObjectType, deepKey: DeepKeyType, value: ValueType): void;
+function myLookup(obj: any, deepKey: string, value: any) {
+}
+
+function myLookupOneInstance<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(obj: ObjectType, deepKey: DeepKeyType, value: ValueType): void {
+}
+
+// function myLookup2<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType, obj: ObjectType): void;
+function myLookup2<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType, obj: ObjectType = {} as ObjectType) {
+}
+
+// function myLookupWithoutObj<ObjectType extends object, DeepKeyType extends keyof Flatten<ObjectType> = keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType] = Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType): void;
+function myLookupWithoutObj<ObjectType extends object, DeepKeyType extends keyof Flatten<ObjectType> = keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType] = Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType) {
+}
+
+// type FooType = {
+//     a: [number, { b: string }, number]
+//     c: {
+//         d: {
+//             e: number
+//         }
+//     }
+// }
+const foo = {
+    a: [1, { b: "two" }, 3] as [number, { b: string }, number],
+    c: { d: { e: 1 } }
+}
+type FooType = typeof foo;
+
+lookup(foo, "a.1.b").toUpperCase() // TWO
+myLookup(foo, "a.1.b", 20).toUpperCase() // TWO
+myLookup(foo, "a.0", 20);
+myLookup(foo, "a.0", "20");
+
+myLookupOneInstance(foo, "c", 20);
+myLookupOneInstance(null as FooType, "a.0", 20);
+
+shortLookup({} as FooType, "a.0", "20");
+shortLookup({} as FooType, "a.0", 20);
+
+myLookup2("a.0", "2", foo);
+myLookup2<FooType, keyof Flatten<FooType>, Flatten<FooType>[keyof Flatten<FooType>]>("a.0", "20");
+myLookup2("a.0", 20);
+myLookup2<FooType>(foo, "a", "20");
+myLookup2<FooType>(foo, "a.0", 20);
+myLookupWithoutObj<FooType>("c.e", 20);
+myLookupWithoutObj<FooType, keyof Flatten<FooType>, Flatten<FooType>[keyof Flatten<FooType>]>("a.0", 20);
+myLookupWithoutObj<FooType, keyof Flatten<FooType>, Flatten<FooType>[keyof Flatten<FooType>]>("a.0", "20");
+myLookupWithoutObj<FooType>("a.0", "20");
+myLookupWithoutObj<FooType>("a.1", "20");
+
+*/
+// function lookupWithReturn<ValueType>(obj: any, key: string, value: ValueType): typeof value {
+//     const i = key.indexOf(".");
+//     return (i < 0) ? obj[key] : (lookup as any)(obj[key.substring(0, i)], key.substring(i + 1));
+// }
+// lookupWithReturn(foo, "a.0", 20)
+// lookupWithReturn(foo, "a.0", "20")
+// // lookupWithReturn(foo, "a.0", false)
+// try {
+//     console.log(lookup(foo, "c.d.e")) // oops, error, can't necessarily look that up
+// } catch (e) {
+//     console.log(e); // maybe obj is undefined
+// }
+/*
+==== FIRST DRAFT: works, but not perfect, cuz gets list of split properties and can't get a.0 as an index for array elements ====
+
+type Join<K, P> = K extends string | number ?
+    P extends string | number ?
+    `${K}${"" extends P ? "" : "."}${P}`
+    : never : never;
+
+
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...0[]]
+
+type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ?
+    { [K in keyof T]-?: K extends string | number ?
+        `${K}` | Join<K, Paths<T[K], Prev[D]>>
+        : never
+    }[keyof T] : ""
+
+type Leaves<T, D extends number = 10> = [D] extends [never] ? never : T extends object ?
+    { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T] : "";
+
+
+// type NestedObjectType = {
+//     a: string;
+//     b: string;
+//     nest: {
+//         c: string;
+//     };
+//     otherNest: {
+//         otherNest: {
+//             c: string;
+//         }
+//     };
+// };
+
+interface Tree {
+    left: Tree,
+    right: Tree,
+    data: string
+}
+
+// type TreeLeaves = Leaves<Tree>; // sorry, compiler 💻⌛😫
+// type TreeLeaves = "data" | "left.data" | "right.data" | "left.left.data" |
+// "left.right.data" | "right.left.data" | "right.right.data" | "left.left.left.data" |
+// "left.left.right.data" | "left.right.left.data" | ... 1012 more ... |
+// "right.right.right.right.right.right.right.right.right.data"
+
+type TreeLeaves = Leaves<Tree, 100>;
+// type TreeLeaves =  "data" | "left.data" | "right.data" | "left.left.data" |
+// "left.right.data" | "right.left.data" | "right.right.data"
+
+// type NestedObjectPaths = Paths<NestedObjectType>;
+// type NestedObjectPaths = "a" | "b" | "nest" | "otherNest" | "nest.c" | "otherNest.c"
+// type NestedObjectLeaves = Leaves<NestedObjectType>
+// type NestedObjectLeaves = "a" | "b" | "nest.c" | "otherNest.c"
+
+export type ObjectSingleNestedPathType<T extends object> = Paths<T>;
+export type ObjectNestedPathsType<T extends object> = Array<Paths<T>>
+
+// const test: MyGenericType<NestedObjectType> = {
+//     keys: ["a", "nest.c", "otherNest.otherNest"]
+// }
+
+*/ 
+//# sourceMappingURL=DeepKeyTypings.js.map

package/src/state/data/DeepKeyTypings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepKeyTypings.js","sourceRoot":"","sources":["../../../../src/state/data/DeepKeyTypings.ts"],"names":[],"mappings":";AA4BA,iFAAiF;AACjF,2CAA2C;AAC3C,kCAAkC;AAClC,mGAAmG;AACnG,IAAI;AAGJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DE;AAGF,gGAAgG;AAChG,kCAAkC;AAClC,mGAAmG;AACnG,IAAI;AACJ,mCAAmC;AACnC,qCAAqC;AACrC,yCAAyC;AAEzC,QAAQ;AACR,uFAAuF;AACvF,gBAAgB;AAChB,gDAAgD;AAChD,IAAI;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DE"}

package/src/state/data/DeepPartialTypings.d.ts

@@ -0,0 +1,83 @@
+import { BuiltIns } from "./DeepReadableTypings";
+/**
+@see DeepPartial
+*/
+export type DeepPartialOptions = {
+    /**
+    Whether to affect the individual elements of arrays and tuples.
+
+    @default false
+    */
+    readonly recurseIntoArrays?: boolean;
+};
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {DeepPartial} from 'type-fest';
+
+const settings: Settings = {
+    textEditor: {
+        fontSize: 14;
+        fontColor: '#000000';
+        fontWeight: 400;
+    }
+    autocomplete: false;
+    autosave: true;
+};
+
+const applySavedSettings = (savedSettings: DeepPartial<Settings>) => {
+    return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {DeepPartial} from 'type-fest';
+
+interface Settings {
+    languages: string[];
+}
+
+const partialSettings: DeepPartial<Settings, {recurseIntoArrays: true}> = {
+    languages: [undefined]
+};
+```
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type DeepPartial<T, Options extends DeepPartialOptions = {}> = T extends BuiltIns ? T : T extends Map<infer KeyType, infer ValueType> ? DeepPartialMap<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? DeepPartialSet<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? DeepPartialReadonlyMap<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? DeepPartialReadonlySet<ItemType, Options> : T extends ((...arguments_: any[]) => unknown) ? T | undefined : T extends object ? T extends ReadonlyArray<infer ItemType> ? Options['recurseIntoArrays'] extends true ? ItemType[] extends T ? readonly ItemType[] extends T ? ReadonlyArray<DeepPartial<ItemType | undefined, Options>> : Array<DeepPartial<ItemType | undefined, Options>> : DeepPartialObject<T, Options> : T : DeepPartialObject<T, Options> : unknown;
+/**
+Same as `DeepPartial`, but accepts only `Map`s and as inputs. Internal helper for `DeepPartial`.
+*/
+type DeepPartialMap<KeyType, ValueType, Options extends DeepPartialOptions> = {} & Map<DeepPartial<KeyType, Options>, DeepPartial<ValueType, Options>>;
+/**
+Same as `DeepPartial`, but accepts only `Set`s as inputs. Internal helper for `DeepPartial`.
+*/
+type DeepPartialSet<T, Options extends DeepPartialOptions> = {} & Set<DeepPartial<T, Options>>;
+/**
+Same as `DeepPartial`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `DeepPartial`.
+*/
+type DeepPartialReadonlyMap<KeyType, ValueType, Options extends DeepPartialOptions> = {} & ReadonlyMap<DeepPartial<KeyType, Options>, DeepPartial<ValueType, Options>>;
+/**
+Same as `DeepPartial`, but accepts only `ReadonlySet`s as inputs. Internal helper for `DeepPartial`.
+*/
+type DeepPartialReadonlySet<T, Options extends DeepPartialOptions> = {} & ReadonlySet<DeepPartial<T, Options>>;
+/**
+Same as `DeepPartial`, but accepts only `object`s as inputs. Internal helper for `DeepPartial`.
+*/
+type DeepPartialObject<ObjectType extends object, Options extends DeepPartialOptions> = {
+    [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType], Options>;
+};
+export {};

package/src/state/data/DeepPartialTypings.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DeepPartialTypings.js.map

package/src/state/data/DeepPartialTypings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepPartialTypings.js","sourceRoot":"","sources":["../../../../src/state/data/DeepPartialTypings.ts"],"names":[],"mappings":""}

package/src/state/data/DeepReadableTypings.d.ts

@@ -0,0 +1,58 @@
+export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+    (...arguments_: infer A): unknown;
+    (...arguments_: any[]): unknown;
+} ? unknown[] extends A ? false : true : false;
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type BuiltIns = Primitive | Date | RegExp;
+/**
+Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
+
+This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+    "foo": ["bar"]
+}
+
+// main.ts
+import type {DeepReadonly} from 'type-fest';
+import dataJson = require('./data.json');
+
+const data: DeepReadonly<typeof dataJson> = dataJson;
+
+export default data;
+
+// test.ts
+import data from './main';
+
+data.foo.push('bar');
+//=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
+```
+
+Note that types containing overloaded functions are not made deeply readonly due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type DeepReadonly<T> = T extends BuiltIns ? T : T extends (...arguments_: any[]) => unknown ? {} extends DeepReadonlyObject<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & DeepReadonlyObject<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? DeepReadonlyMap<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? DeepReadonlySet<ItemType> : T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [infer U, ...infer V] ? readonly [DeepReadonly<U>, ...DeepReadonly<V>] : T extends readonly [...infer U, infer V] ? readonly [...DeepReadonly<U>, DeepReadonly<V>] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<DeepReadonly<ItemType>> : T extends object ? DeepReadonlyObject<T> : unknown;
+/**
+Same as `DeepReadonly`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `DeepReadonly`.
+*/
+type DeepReadonlyMap<KeyType, ValueType> = {} & Readonly<ReadonlyMap<DeepReadonly<KeyType>, DeepReadonly<ValueType>>>;
+/**
+Same as `DeepReadonly`, but accepts only `ReadonlySet`s as inputs. Internal helper for `DeepReadonly`.
+*/
+type DeepReadonlySet<ItemType> = {} & Readonly<ReadonlySet<DeepReadonly<ItemType>>>;
+/**
+Same as `DeepReadonly`, but accepts only `object`s as inputs. Internal helper for `DeepReadonly`.
+*/
+type DeepReadonlyObject<ObjectType extends object> = {
+    readonly [KeyType in keyof ObjectType]: DeepReadonly<ObjectType[KeyType]>;
+};
+export {};

package/src/state/data/DeepReadableTypings.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DeepReadableTypings.js.map

package/src/state/data/DeepReadableTypings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepReadableTypings.js","sourceRoot":"","sources":["../../../../src/state/data/DeepReadableTypings.ts"],"names":[],"mappings":""}

package/src/state/data/IAppStateChangeConfigVO.d.ts

@@ -0,0 +1,8 @@
+import { AppStateChangeType } from "./AppStateChangeType";
+export interface IAppStateChangeConfigVO<ValueType extends any = any, ArrayType = ValueType & Array<any>> {
+    changeType: AppStateChangeType;
+    value?: Partial<ValueType>;
+    elements?: ArrayType;
+    start?: number;
+    deleteCount?: number;
+}

package/src/state/data/IAppStateChangeConfigVO.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAppStateChangeConfigVO.js.map

package/src/state/data/IAppStateChangeConfigVO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAppStateChangeConfigVO.js","sourceRoot":"","sources":["../../../../src/state/data/IAppStateChangeConfigVO.ts"],"names":[],"mappings":""}

package/src/state/data/IChangeWrapper.d.ts

@@ -0,0 +1,4 @@
+import { Flatten } from "./DeepKeyTypings";
+export interface IChangeWrapper<WrapperStateType, WrapperDeepKeyType extends keyof Flatten<WrapperStateType, never> = keyof Flatten<WrapperStateType, never>> {
+    (wrapperKey: WrapperDeepKeyType, value: Partial<Flatten<WrapperStateType, never>[WrapperDeepKeyType]>): void;
+}

package/src/state/data/IChangeWrapper.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IChangeWrapper.js.map

package/src/state/data/IChangeWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IChangeWrapper.js","sourceRoot":"","sources":["../../../../src/state/data/IChangeWrapper.ts"],"names":[],"mappings":""}

package/src/state/data/IPreChangeHook.d.ts

@@ -0,0 +1,5 @@
+import { Flatten } from "./DeepKeyTypings";
+import { IAppStateChangeConfigVO } from "./IAppStateChangeConfigVO";
+export interface IPreChangeHook extends Function {
+    <StateType, DeepKeyType extends keyof Flatten<StateType>>(stateForTypings: StateType, deepKey: DeepKeyType, changeConfig: IAppStateChangeConfigVO): void;
+}

package/src/state/data/IPreChangeHook.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IPreChangeHook.js.map

package/src/state/data/IPreChangeHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPreChangeHook.js","sourceRoot":"","sources":["../../../../src/state/data/IPreChangeHook.ts"],"names":[],"mappings":""}

package/src/state/tools/AppStateDeepKeyTools.d.ts

@@ -0,0 +1,6 @@
+import { IAppStateChangeConfigVO } from "../../../index";
+import { IDeepKeyHelperVO } from "./INestedPathHelperVO";
+export declare class AppStateDeepKeyTools {
+    static prepareDeepKeyHelperData(deepKey: string, config?: IAppStateChangeConfigVO): IDeepKeyHelperVO;
+    static splitDeepKeyIntoEvents(deepKey: string): IDeepKeyHelperVO;
+}

package/src/state/tools/AppStateDeepKeyTools.js

@@ -0,0 +1,70 @@
+import { ObjectTools } from "@flashist/fcore";
+export class AppStateDeepKeyTools {
+    static prepareDeepKeyHelperData(deepKey, config = null) {
+        const result = {
+            splitDeepKeyParts: [],
+            dispatchingChangePaths: [],
+            dispatchingChangePathsMap: {}
+        };
+        let tempTotalPath = "";
+        const splitPaths = deepKey.split(".");
+        for (let singleSplitPath of splitPaths) {
+            result.splitDeepKeyParts.push(singleSplitPath);
+            if (tempTotalPath) {
+                tempTotalPath += ".";
+            }
+            tempTotalPath += singleSplitPath;
+            result.dispatchingChangePaths.push(tempTotalPath);
+            result.dispatchingChangePathsMap[tempTotalPath] = true;
+        }
+        if (config) {
+            if (!ObjectTools.isSimpleType(config.value)) {
+                const getComplexValueKeyPaths = (value, valueDeepKey) => {
+                    let result = [valueDeepKey];
+                    if (!ObjectTools.isSimpleType(value)) {
+                        const keys = Object.keys(value);
+                        for (let singleKey of keys) {
+                            const singlePropValue = value[singleKey];
+                            const singleKeyDeepKeyPaths = getComplexValueKeyPaths(singlePropValue, `${valueDeepKey}.${singleKey}`);
+                            result.push(...singleKeyDeepKeyPaths);
+                        }
+                    }
+                    return result;
+                };
+                const valueDeepKeyPaths = getComplexValueKeyPaths(config.value, deepKey);
+                for (let singleValueDeepKeyPath of valueDeepKeyPaths) {
+                    // tempTotalPath += "." + singleValueDeepKeyPath;
+                    // result.dispatchingChangePaths.push(tempTotalPath);
+                    const singleValueHelper = AppStateDeepKeyTools.splitDeepKeyIntoEvents(singleValueDeepKeyPath);
+                    for (let singleSplitDispatchingPart of singleValueHelper.dispatchingChangePaths) {
+                        if (!result.dispatchingChangePathsMap[singleSplitDispatchingPart]) {
+                            result.dispatchingChangePathsMap[singleSplitDispatchingPart] = true;
+                            result.dispatchingChangePaths.push(singleSplitDispatchingPart);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    static splitDeepKeyIntoEvents(deepKey) {
+        const result = {
+            splitDeepKeyParts: [],
+            dispatchingChangePaths: [],
+            dispatchingChangePathsMap: {}
+        };
+        let tempTotalPath = "";
+        const splitPaths = deepKey.split(".");
+        for (let singleSplitPath of splitPaths) {
+            result.splitDeepKeyParts.push(singleSplitPath);
+            if (tempTotalPath) {
+                tempTotalPath += ".";
+            }
+            tempTotalPath += singleSplitPath;
+            result.dispatchingChangePaths.push(tempTotalPath);
+            result.dispatchingChangePathsMap[tempTotalPath] = true;
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=AppStateDeepKeyTools.js.map

package/src/state/tools/AppStateDeepKeyTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppStateDeepKeyTools.js","sourceRoot":"","sources":["../../../../src/state/tools/AppStateDeepKeyTools.ts"],"names":[],"mappings":"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"}

package/src/state/tools/AppStateEventChangeTools.d.ts

@@ -0,0 +1,3 @@
+export declare class AppStateEventChangeTools {
+    static getChangeEvent(path: string | number | symbol): string;
+}

package/src/state/tools/AppStateEventChangeTools.js

@@ -0,0 +1,9 @@
+export class AppStateEventChangeTools {
+    // static getAppStateChangeEventName(deepKey: string): string {
+    //     return AppStateEventChangeTools.getChangeEvent(deepKey);
+    // }
+    static getChangeEvent(path) {
+        return `appStateChange:${path.toString()}`;
+    }
+}
+//# sourceMappingURL=AppStateEventChangeTools.js.map

package/src/state/tools/AppStateEventChangeTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppStateEventChangeTools.js","sourceRoot":"","sources":["../../../../src/state/tools/AppStateEventChangeTools.ts"],"names":[],"mappings":"AAGA,MAAM,OAAO,wBAAwB;IACjC,+DAA+D;IAC/D,+DAA+D;IAC/D,IAAI;IAEJ,MAAM,CAAC,cAAc,CAAC,IAA8B;QAChD,OAAO,kBAAkB,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC/C,CAAC;CACJ"}

package/src/state/tools/INestedPathHelperVO.d.ts

@@ -0,0 +1,5 @@
+export interface IDeepKeyHelperVO {
+    splitDeepKeyParts: string[];
+    dispatchingChangePaths: string[];
+    dispatchingChangePathsMap: Record<string, boolean>;
+}

package/src/state/tools/INestedPathHelperVO.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=INestedPathHelperVO.js.map

package/src/state/tools/INestedPathHelperVO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"INestedPathHelperVO.js","sourceRoot":"","sources":["../../../../src/state/tools/INestedPathHelperVO.ts"],"names":[],"mappings":""}

package/src/strategy/managers/BaseStrategyManager.d.ts

@@ -0,0 +1,15 @@
+import { BaseAppManager } from "../../base/managers/BaseAppManager";
+import { BaseStrategyModel } from "../models/BaseStrategyModel";
+import { BaseStrategy } from "../strategies/BaseStrategy";
+export declare abstract class BaseStrategyManager<StrategyType extends BaseStrategy = BaseStrategy, StrategyModelType extends BaseStrategyModel<StrategyType> = BaseStrategyModel<StrategyType>> extends BaseAppManager {
+    protected strategyModel: StrategyModelType;
+    protected lastActiveStrategy: StrategyType;
+    /**
+     * It's supposed, that there is an external common-purpose model,
+     * which provides some data (e.g. the ID of an active item),
+     * and based on this data the manager should make the decision,
+     * about which specific id for a strategy should be used.
+     */
+    protected abstract findIdForCurrentStrategy(): string;
+    protected commitStrategyData(): void;
+}

package/src/strategy/managers/BaseStrategyManager.js

@@ -0,0 +1,17 @@
+import { BaseAppManager } from "../../base/managers/BaseAppManager";
+export class BaseStrategyManager extends BaseAppManager {
+    commitStrategyData() {
+        const newToolStrategy = this.strategyModel.getStrategyById(this.findIdForCurrentStrategy());
+        if (this.lastActiveStrategy === newToolStrategy) {
+            return;
+        }
+        if (this.lastActiveStrategy) {
+            this.lastActiveStrategy.deactivate();
+        }
+        this.lastActiveStrategy = newToolStrategy;
+        if (this.lastActiveStrategy) {
+            this.lastActiveStrategy.activate();
+        }
+    }
+}
+//# sourceMappingURL=BaseStrategyManager.js.map

package/src/strategy/managers/BaseStrategyManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseStrategyManager.js","sourceRoot":"","sources":["../../../../src/strategy/managers/BaseStrategyManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,oCAAoC,CAAC;AAIlE,MAAM,OAAgB,mBAGhB,SAAQ,cAAc;IAad,kBAAkB;QACxB,MAAM,eAAe,GAAiB,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,CAAC;QAC1G,IAAI,IAAI,CAAC,kBAAkB,KAAK,eAAe,EAAE,CAAC;YAC9C,OAAO;QACX,CAAC;QAED,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,CAAC;QACzC,CAAC;QAED,IAAI,CAAC,kBAAkB,GAAG,eAAe,CAAC;QAC1C,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;QACvC,CAAC;IACL,CAAC;CAEJ"}

package/src/strategy/models/BaseStrategyModel.d.ts

@@ -0,0 +1,12 @@
+import { AssociativeArray } from "@flashist/fcore";
+import { BaseAppModel } from "../../base/models/BaseAppModel";
+import { BaseStrategy } from "../strategies/BaseStrategy";
+export declare class BaseStrategyModel<StrategyType extends BaseStrategy = BaseStrategy> extends BaseAppModel {
+    protected strategyToIdMap: AssociativeArray<StrategyType>;
+    private _strategyId;
+    addStrategy(strategy: StrategyType, id: string): void;
+    removeStrategy(id: string): void;
+    getStrategyById(id: string): StrategyType;
+    get strategyId(): string;
+    set strategyId(value: string);
+}

package/src/strategy/models/BaseStrategyModel.js

@@ -0,0 +1,31 @@
+import { AssociativeArray } from "@flashist/fcore";
+import { BaseAppModel } from "../../base/models/BaseAppModel";
+export class BaseStrategyModel extends BaseAppModel {
+    constructor() {
+        super(...arguments);
+        this.strategyToIdMap = new AssociativeArray();
+        this._strategyId = "";
+    }
+    addStrategy(strategy, id) {
+        this.strategyToIdMap.push(strategy, id);
+    }
+    removeStrategy(id) {
+        this.strategyToIdMap.removeByKey(id);
+    }
+    getStrategyById(id) {
+        if (!this.strategyToIdMap.containsKey(id)) {
+            console.log("BaseStrategyModel | getStrategyForId __ WARNING! Can't find strategy for id: ", id);
+        }
+        return this.strategyToIdMap.getItem(id);
+    }
+    get strategyId() {
+        return this._strategyId;
+    }
+    set strategyId(value) {
+        if (value === this._strategyId) {
+            return;
+        }
+        this._strategyId = value;
+    }
+}
+//# sourceMappingURL=BaseStrategyModel.js.map

package/src/strategy/models/BaseStrategyModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseStrategyModel.js","sourceRoot":"","sources":["../../../../src/strategy/models/BaseStrategyModel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AAG5D,MAAM,OAAO,iBAAoE,SAAQ,YAAY;IAArG;;QAEc,oBAAe,GAAmC,IAAI,gBAAgB,EAAgB,CAAC;QAEzF,gBAAW,GAAW,EAAE,CAAC;IA8BrC,CAAC;IA5BU,WAAW,CAAC,QAAsB,EAAE,EAAU;QACjD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEM,cAAc,CAAC,EAAU;QAC5B,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IACzC,CAAC;IAEM,eAAe,CAAC,EAAU;QAC7B,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC;YACxC,OAAO,CAAC,GAAG,CAAC,+EAA+E,EAAE,EAAE,CAAC,CAAC;QACrG,CAAC;QAED,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC5C,CAAC;IAGD,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAI,UAAU,CAAC,KAAa;QACxB,IAAI,KAAK,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC;YAC7B,OAAO;QACX,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC7B,CAAC;CACJ"}

package/src/strategy/strategies/BaseStrategy.d.ts

@@ -0,0 +1,6 @@
+import { BaseObjectWithGlobalDispatcher } from "../../base/BaseObjectWithGlobalDispatcher";
+export declare abstract class BaseStrategy extends BaseObjectWithGlobalDispatcher {
+    protected static cache: BaseStrategy[];
+    activate(): void;
+    deactivate(): void;
+}

package/src/strategy/strategies/BaseStrategy.js

@@ -0,0 +1,17 @@
+import { ArrayTools, Logger } from "@flashist/fcore";
+import { BaseObjectWithGlobalDispatcher } from "../../base/BaseObjectWithGlobalDispatcher";
+export class BaseStrategy extends BaseObjectWithGlobalDispatcher {
+    activate() {
+        Logger.log("BaseStrategy | activate __ this: ", this);
+        if (BaseStrategy.cache.indexOf(this) == -1) {
+            BaseStrategy.cache.push(this);
+        }
+    }
+    ;
+    deactivate() {
+        this.eventListenerHelper.removeAllListeners();
+        ArrayTools.removeItem(BaseStrategy.cache, this);
+    }
+}
+BaseStrategy.cache = [];
+//# sourceMappingURL=BaseStrategy.js.map

package/src/strategy/strategies/BaseStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseStrategy.js","sourceRoot":"","sources":["../../../../src/strategy/strategies/BaseStrategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,MAAM,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAC,8BAA8B,EAAC,MAAM,2CAA2C,CAAC;AAEzF,MAAM,OAAgB,YAAa,SAAQ,8BAA8B;IAIrE,QAAQ;QACJ,MAAM,CAAC,GAAG,CAAC,mCAAmC,EAAE,IAAI,CAAC,CAAC;QAEtD,IAAI,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YACzC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;IACL,CAAC;IAAA,CAAC;IAEF,UAAU;QACN,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,CAAC;QAE9C,UAAU,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;;AAdgB,kBAAK,GAAmB,EAAE,CAAC"}

package/src/time/TimeModule.d.ts

@@ -0,0 +1,4 @@
+import { BaseAppModule } from "../base/modules/BaseAppModule";
+export declare class TimeModule extends BaseAppModule {
+    init(): void;
+}