tungsten 0.2.1 → 0.2.3

package/dist/Store/InternalStoreSchema.d.ts

@@ -0,0 +1,7 @@
+import type { MatchedRouteInfo } from '../Servers/MatchedRouteInfo.js';
+export declare class InternalStoreSchema {
+    location: string;
+    matchedRouteInfo: MatchedRouteInfo;
+    constructor(location: string, matchedRouteInfo: MatchedRouteInfo);
+}
+//# sourceMappingURL=InternalStoreSchema.d.ts.map

package/dist/Store/InternalStoreSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InternalStoreSchema.d.ts","sourceRoot":"","sources":["../../src/Store/InternalStoreSchema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,qBAAa,mBAAmB;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,EAAE,gBAAgB,CAAA;gBACtB,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;CAInE"}

package/dist/Store/InternalStoreSchema.js

@@ -0,0 +1,11 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export class InternalStoreSchema {
+  constructor(location, matchedRouteInfo) {
+    _defineProperty(this, "location", void 0);
+    _defineProperty(this, "matchedRouteInfo", void 0);
+    this.location = location;
+    this.matchedRouteInfo = matchedRouteInfo;
+  }
+}

package/dist/Store/ServerDataLoading.d.ts

@@ -0,0 +1,4 @@
+export type ServerDataLoading = {
+    value: boolean;
+};
+//# sourceMappingURL=ServerDataLoading.d.ts.map

package/dist/Store/ServerDataLoading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerDataLoading.d.ts","sourceRoot":"","sources":["../../src/Store/ServerDataLoading.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,CAAA"}

package/dist/Store/ServerDataLoading.js

@@ -0,0 +1 @@
+export {};

package/dist/Store/Store.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Store.d.ts.map

package/dist/Store/Store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../src/Store/Store.ts"],"names":[],"mappings":""}

package/dist/Store/Store.js

@@ -0,0 +1,439 @@
+export {};
+/*
+import type { GenericObject } from '../GenericObject.type.js'
+import { warn } from '../output.js'
+import { isDev } from '../isDev.js'
+import { TungstenComponent } from '../TungstenComponent.jsx'
+import { FunctionComponent } from '../FunctionComponent.js'
+import { TungstenError } from '../TungstenError.js'
+import { IsObject } from '../IsObject.js'
+
+export default function objectCopy<T extends GenericObject>(obj: T): T {
+    return structuredClone(obj)
+    // const newObject: { [key: string]: any } = {}
+    // const keys = Object.keys(obj)
+    // for (let i = 0; i < keys.length; i++) {
+    //     const key = keys[i]
+    //     if (typeof obj[key] === 'object' && obj[key] !== null) {
+    //         newObject[key] = objectCopy(obj[key])
+    //     } else {
+    //         newObject[key] = obj[key]
+    //     }
+    // }
+    // return newObject
+}
+
+function objectDeepFreeze<T extends GenericObject>(object: T): T {
+    if (! Object.isFrozen(object)) {
+        Object.freeze(object)
+        Object.getOwnPropertyNames(object).forEach(prop => {
+            const v = object[prop]
+            return (typeof v === 'object' && v !== null)
+                ? objectDeepFreeze(v as GenericObject)
+                : v
+        })
+    }
+    return object
+
+
+    // if ( object && typeof object === 'object' && ! Object.isFrozen(object) ) {
+    //     Object.freeze(object)
+    //     Object.getOwnPropertyNames(object).forEach(prop => objectDeepFreeze(object[prop]))
+    // }
+    // return object
+}
+
+function log(...texts: any[]) {
+    console.log(...texts) // eslint-disable-line no-console
+}
+
+// function debug(texts) {
+//     console.log(...texts)
+// }
+
+
+// function isClassComponent(component) {
+//     return (
+//         typeof component === 'function'
+//         && !!component.prototype.isReactComponent
+//     )
+// }
+
+// function isFunctionComponent(component) {
+//     return (
+//         typeof component === 'function'
+//         && String(component).includes('return React.createElement')
+//     )
+// }
+
+// function isReactComponent(component) {
+//     return (
+//         isClassComponent(component)
+//         || isFunctionComponent(component)
+//     )
+// }
+
+
+// cyclic safe
+// function deepFreeze(obj)  {
+//     if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
+//         Object.freeze(obj)
+//         Object.getOwnPropertyNames(obj).forEach(prop => deepFreeze(obj[prop]))
+//     }
+//     return obj
+// }
+
+const moduleName = 'Store'
+
+export type SetWithFunction = <T>(currentValue: T) => T
+
+export type ProcessorFunctionUntyped = (message: unknown) => unknown
+export type ProcessorFunctionTyped = <M, R>(message: M) => R
+export type ProcessorFunction = ProcessorFunctionUntyped | ProcessorFunctionTyped
+
+export type ReducerObject = {
+    key: string
+    reducer: ReducerFunction
+}
+export type ReducerFunctionUntyped = ((current: unknown, message: unknown) => unknown)
+| ((current: unknown, message: unknown, reducerName: string) => unknown)
+| ((current: unknown, message: unknown, reducerName: string, key: string) => unknown)
+export type ReducerFunctionTyped = (<T, M>(current: T, message: M) => T)
+| (<T, M>(current: T, message: M, reducerName: string) => T)
+| (<T, M>(current: T, message: M, reducerName: string, key: string) => T)
+export type ReducerFunction = ReducerFunctionUntyped | ReducerFunctionTyped
+
+export type FunctionComponentSubscribeCallbackFunction = (key: string, value: unknown) => any
+
+export class Store {
+    data: Record<string, unknown> = {}
+    subscribers: Record<string, TungstenComponent<any, any>[]> = {}
+    functionComponentSubscribers: Record<string, FunctionComponentSubscribeCallbackFunction[]> = {}
+    processors: Record<string, ProcessorFunction> = {}
+    reducers: Record<string, ReducerObject> = {}
+    create(key: string, defaultValue: unknown) {
+        if ( (key in this.data) ) {
+            if (isDev) log('create error data key already exists')
+            return undefined
+        }
+        // clone it to avoid messing with the original
+        // and freeze it to prevent subscribers messing with it
+        // Object.deepFreeze(objectCopy(defaultValue))
+
+        // do we need to freeze it?
+
+        this.set(key, defaultValue)
+        return defaultValue
+    }
+    set(key: string, value: unknown) {
+        //console.log('store setting ' + key + ' to ' + value)
+        // clone it to avoid messing with the original
+        // and freeze it to prevent subscribers messing with it
+        //const clone = Object.deepFreeze(objectCopy(value))
+        //if (this.data[key] !== clone) {
+        //this.data[key] = clone
+        this.data[key] = value
+        this.push(key) // notify
+        return value
+        //}
+    }
+    setWith(key: string, func: SetWithFunction) {
+        const value = func(this.data[key])
+        this.set(key, value)
+        return value
+    }
+    setLater(key: string, value: unknown): Promise<void> {
+        return new Promise( resolve => setTimeout(
+            () => { this.set(key, value); resolve() },
+            0
+        ) )
+    }
+    setNowPushLater(key: string, value: unknown): Promise<void> | void {
+        // clone it to avoid messing with the original
+        // and freeze it to prevent subscribers messing with it
+        const toSave = (IsObject(value)) ? objectCopy(value) : value
+        //const clone = objectDeepFreeze(objectCopy(value))
+        //if (this.data[key] !== toSave) {
+        this.data[key] = toSave
+        return new Promise(resolve =>  setTimeout(
+            () => { this.push(key); resolve() },
+            0
+        ))
+        //}
+    }
+    increment(key: string, amount = 1) {
+        const n = this.data[key]
+        if ( typeof n !== 'number' ) {
+            throw new TungstenError(`Store.increment() error: data for ${key} is not a number. Is type ${typeof n} instead`)
+        }
+        this.data[key] = n + amount
+        this.push(key)
+    }
+    incr(key: string, amount: number) {
+        this.increment(key, amount)
+    }
+    decrement(key: string, amount = 1) {
+        const n = this.data[key]
+        if (typeof n !== 'number') {
+            throw new TungstenError(`Store.increment() error: data for ${key} is not a number. Is type ${typeof n} instead`)
+        }
+        this.data[key] = n - amount
+        this.push(key)
+    }
+    decr(key: string, amount: number) {
+        this.decrement(key, amount)
+    }
+    multiply(key: string, amount: number) {
+        const n = this.data[key]
+        if (typeof n !== 'number') {
+            throw new TungstenError(`Store.increment() error: data for ${key} is not a number. Is type ${typeof n} instead`)
+        }
+        this.data[key] = n * amount
+        this.push(key)
+    }
+    mult(key: string, amount: number) {
+        this.multiply(key, amount)
+    }
+    divide(key: string, amount: number) {
+        const n = this.data[key]
+        if (typeof n !== 'number') {
+            throw new TungstenError(`Store.increment() error: data for ${key} is not a number. Is type ${typeof n} instead`)
+        }
+        this.data[key] = n / amount
+        this.push(key)
+    }
+    div(key: string, amount: number) {
+        this.divide(key, amount)
+    }
+    concat(key: string, string: unknown) {
+        const s = this.data[key]
+        if (isDev && typeof s !== 'string') {
+            throw new TungstenError(`Store.increment() error: data for ${key} is not a string. Is type ${typeof s} instead`)
+        }
+        this.data[key] = String(s) + String(string)
+        this.push(key)
+    }
+    arrayConcat(key: string, array: unknown[]) {
+        const a = this.data[key]
+        if (!Array.isArray(a)) {
+            throw new TungstenError(`Store.increment() error: data for ${key} is not an array. Is type ${typeof a} instead`)
+        }
+        this.data[key] = a.concat(array)
+        this.push(key)
+    }
+    assign(key: string, object: GenericObject) {
+        const o = this.data[key]
+        if (IsObject(o)) {
+            throw new TungstenError(`Store.increment() error: data for ${key} is not an object. Is type ${typeof o} instead`)
+        }
+        Object.assign(this.data[key] as GenericObject, object) // eslint-disable-line no-type-assertion/no-type-assertion -- TS won't let me typecheck within this.data
+        this.push(key)
+    }
+    push(key: string) {
+        //console.log('store is pushing an update for ' + key)
+        // class based components
+        if ( (key in this.subscribers) ) {
+            for (const subscriber of this.subscribers[key]) {
+                if ( ! subscriber ) continue // try to check the component is valid
+                if ( ! ('__queueUpdate' in subscriber) ) continue // try to check the component is valid
+                
+                // could fail if the user has mucked with component.storeData
+                // perhaps we should build the whole data object - would it get expensive?
+                //switch shouldUpdate func could go here
+                let update = true
+                if (subscriber.shouldStoreComponentUpdate !== undefined) {
+                    update = subscriber.shouldStoreComponentUpdate(
+                        // subscriber.props,
+                        // subscriber.state,
+                        // {
+                        //     [key]: this.data[key]
+                        // }
+                        key,
+                        this.data[key]
+                    )
+                }
+
+                //console.log(`should update ${subscriber.constructor.name}?`, update)
+                
+                                    // subscriber should have initialised storeData
+                subscriber.storeData![key] = this.data[key]
+                if (update) {
+                    //console.log(`force update on ${subscriber.constructor.name}`)
+                    subscriber.__queueUpdate()
+                }
+            }
+        }
+        /// functional components
+        if ( (key in this.functionComponentSubscribers) ) {
+            for (const callback of this.functionComponentSubscribers[key]) {
+                callback(key, this.data[key])
+            }
+        }
+    }
+    get(key: string): unknown {
+        return this.data[key]
+    }
+    sync(component: TungstenComponent<any, any, any, any>, key: string): unknown {
+        if ( ! this.subscribed(component, key) ) {
+            this.subscribe(component, key)
+        }
+        return this.data[key]
+    }
+    exists(key: string): boolean {
+        return (key in this.data)
+    }
+    delete(key: string): void {
+        //unsubscribe all
+        delete this.subscribers[key]
+        delete this.data[key]
+    }
+    subscribed(component: TungstenComponent<any, any, any, any>, key: string): boolean {
+        if ( ! (key in this.subscribers) ) return false
+        return this.subscribers[key].includes(component)
+    }
+    subscribe(component: TungstenComponent<any, any, any, any>, key: string) {
+        //console.log(`store subscribing ${component.constructor.name} to ${key}`)
+        // check component is a react el?
+
+        // we can remove this check, and just let components subscribe
+        // but we need to push on create
+        // if ( ! (key in this.data) ) {
+        //     if (isDev) log(`${moduleName} Subscribe Error, key ${key} does not exist in the store`)
+        //     return
+        // }
+
+        if (component.storeData === undefined) component.storeData = {}
+        component.storeData[key] = this.data[key]
+
+        if ( ! (key in this.subscribers) ) this.subscribers[key] = []
+        if ( this.subscribers[key].includes(component) ) {
+            if (isDev) log(`${moduleName} Subscribe Error`
+                + `, this component (${(component.constructor as any).displayName || (component.constructor as any).tagName || component.constructor.name})`
+                + ` is already subscribed to key ${key}!`)
+            return
+        }
+        this.subscribers[key].push(component)
+    }
+    unsubscribe(component: TungstenComponent<any, any, any, any>, key: string) {
+        // check component is a react el?
+        if ( ! (key in this.data) ) {
+            if (isDev) log(`${moduleName} Unsubscribe Error, key ${key} does not exist in the store`)
+            return
+        }
+        // the error message of this would be wrong if we create subscribers array by default rather than on first subscription
+        if ( ! (key in this.subscribers) ) {
+            if (isDev) log(`${moduleName} Unsubscribe Error, key ${key} has not been subscribed to`)
+            return
+        }
+        const index = this.subscribers[key].indexOf(component)
+        if (index === 1) {
+            if (isDev) log(`${moduleName} Unsubscribe Warning, this component is not subscribed to key ${key}`)
+            return
+        }
+        this.subscribers[key].splice(index, 1)
+    }
+    fcSubscribe(key: string, callback: FunctionComponentSubscribeCallbackFunction) {
+        if ( ! (key in this.data) ) {
+            if (isDev) log(`${moduleName} Functional Subscribe Error, key ${key} does not exist in the store`)
+            return
+        }
+        if ( ! (key in this.functionComponentSubscribers) ) this.functionComponentSubscribers[key] = []
+        this.functionComponentSubscribers[key].push(callback)
+    }
+    addProcessor(key: string, processor: ProcessorFunction) {
+        if ( key in this.processors ) {
+            warn(`Store addProcessor() warning: key ${key} already exists in processors`)
+        }
+        this.processors[key] = processor
+    }
+    addProcessors(processors: Record<string, ProcessorFunction>) {
+        for (const key in processors) {
+            this.addProcessor(key, processors[key])
+        }
+    }
+    processorExists(key: string) {
+        return key in this.processors
+    }
+    process(processorName: string, message: GenericObject) {
+        if ( ! (processorName in this.processors) ) {
+            if (isDev) log(`${moduleName} Process Error, the processor ${processorName} does not exist`)
+            return undefined
+        }
+        return (this.processors[processorName].bind(this))(message, processorName)
+    }
+    addReducer(key: string, reducer: ReducerObject) {
+        if ( key in this.reducers ) {
+            warn(`Store addReducer() warning: key ${key} already exists in reducers`)
+        }
+        this.reducers[key] = reducer
+    }
+    addReducers(reducers: Record<string, ReducerObject>) {
+        for (const key in reducers) {
+            this.addReducer(key, reducers[key])
+        }
+    }
+    reducerExists(key: string) {
+        return key in this.reducers
+    }
+    reduce(reducerName: string, message: GenericObject) {
+        if ( ! (reducerName in this.reducers) ) {
+            if (isDev) log(`${moduleName} Reduce Error, the reducer ${reducerName} does not exist`)
+            return undefined
+        }
+        const reducers = this.reducers[reducerName]
+        const key = reducers.key
+        if ( ! this.exists(key) ) {
+            if (isDev) log(`${moduleName} Reduce Error, the key "${key}" does not exist in the store. Taking no action`)
+            return undefined
+        }
+        const newValue = reducers.reducer(this.get(key), message, reducerName, key)
+        this.set(key, newValue)
+        return newValue
+    }
+    insert(key: string, data: GenericObject) {
+        if ( ! (key in this.data) ) {
+            if (isDev) log(`${moduleName} Insert Warning, the key ${key} did not exist. Initialising it as a blank object`)
+            this.data[key] = {}
+        }
+        const o = this.data[key]
+        if (!IsObject(o)) {
+            throw new TungstenError(`${moduleName} insert() error. The data for ${key} is not an object. Found ${typeof o}`)
+        }
+        for (const k in data) {
+            // o is a pointer
+            o[k] = data[k]
+        }
+        
+        // let newValue = {}
+        // if ( key in this.data ) newValue = objectCopy(this.get(key))
+        // else if (isDev) log(
+        //     `${moduleName} Insert Warning, the key ${key} did not exist. Initialising it as a blank object`
+        // )
+       
+        // this.set('key', newValue)
+        // return newValue
+        
+    }
+    exportData() {
+        return this.data || {}
+    }
+    export() {
+        return JSON.stringify(this.data || {})
+    }
+    import(jsonData: string) {
+        //console.log('json data', jsonData)
+        this.importJs( JSON.parse(jsonData) )
+    }
+    importJs(newData: GenericObject) {
+        if (Object.keys(this.data).length > 0) {
+            if (isDev) warn(`${moduleName} importJs() Warning, data is being overwritten. Did you import too late?`)
+        }
+        this.data = {}
+        for (const key in newData) {
+            const d = newData[key]
+            this.data[key] = (IsObject(d)) ? objectDeepFreeze(objectCopy(d)) : d
+        }
+        //console.log('data after export', this.data)
+    }
+}
+*/

package/dist/Store/StoreProxyInterface.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StoreProxyInterface.d.ts.map

package/dist/Store/StoreProxyInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoreProxyInterface.d.ts","sourceRoot":"","sources":["../../src/Store/StoreProxyInterface.ts"],"names":[],"mappings":""}

package/dist/Store/StoreProxyInterface.js

@@ -0,0 +1,48 @@
+export {};
+/*
+
+import { GenericObject } from '../GenericObject.type.js'
+import { Json } from '../Json.type.js'
+import type { FunctionComponentSubscribeCallbackFunction, ProcessorFunction, ReducerObject, SetWithFunction } from './Store.js'
+
+//const moduleName = "Store Interface"
+
+export interface StoreProxyInterface {
+    create(key: string, defaultValue: unknown): any
+    set(key: string, value: unknown): any
+    setWith(key: string, func: SetWithFunction): any
+    setLater(key: string, value: unknown): Promise<void>
+    setNowPushLater(key: string, value: unknown): Promise<void> | void
+    increment(key: string, amount: number): void
+    incr(key: string, amount: number): void
+    decrement(key: string, amount: number): void
+    decr(key: string, amount: number): void
+    multiply(key: string, amount: number): void
+    mult(key: string, amount: number): void
+    divide(key: string, amount: number): void
+    div(key: string, amount: number): void
+    concat(key: string, string: string): void
+    arrayConcat(key: string, array: unknown[]): void
+    assign(key: string, object: GenericObject): void
+    push(key: string): void
+    get(key: string): any
+    sync(key: string): any
+    exists(key: string): boolean
+    delete(key: string): void
+    subscribed(key: string): boolean
+    subscribe(key: string): void
+    unsubscribe(key: string): void
+    fcSubscribe(key: string, callback: FunctionComponentSubscribeCallbackFunction): void
+    addProcessor(key: string, processor: ProcessorFunction): void
+    addProcessors(processors: Record<string, ProcessorFunction>): void
+    process(processorName: string, message: any): (key: string, value: any) => any
+    addReducer(key: string, reducer: ReducerObject): void
+    addReducers(reducers: Record<string, ReducerObject>): void
+    reduce(reducerName: string, message: any): any
+    insert(key: string, data: object): any
+    exportData(): object
+    export(): string
+    import(jsonData: Json): void
+    importJs(newData: GenericObject): void
+}
+*/

package/dist/Store/StoreSchemaClass.d.ts

@@ -0,0 +1,6 @@
+import type { ReqRes } from '../ReqRes.js';
+import type { MatchedRouteInfo } from '../Servers/MatchedRouteInfo.js';
+import type { GlobalData } from '../routing/registerGlobalData.js';
+export type StoreSchemaClass<StoreSchema> = new (reqRes: ReqRes | null, globalData: GlobalData, matchedRouteInfo: MatchedRouteInfo) => StoreSchema;
+export type StoreSchemaClassGeneral = new (reqRes: ReqRes | null, globalData: GlobalData, matchedRouteInfo: MatchedRouteInfo) => object;
+//# sourceMappingURL=StoreSchemaClass.d.ts.map

package/dist/Store/StoreSchemaClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoreSchemaClass.d.ts","sourceRoot":"","sources":["../../src/Store/StoreSchemaClass.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAElE,MAAM,MAAM,gBAAgB,CAAC,WAAW,IAAI,KACxC,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,gBAAgB,KACjC,WAAW,CAAA;AAEhB,MAAM,MAAM,uBAAuB,GAAG,KAClC,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,gBAAgB,KACjC,MAAM,CAAA"}

package/dist/Store/StoreSchemaClass.js

@@ -0,0 +1 @@
+export {};

package/dist/Store/StoreSubscriptions.types.d.ts

@@ -0,0 +1,6 @@
+import type { TungstenBaseComponent } from '../Components.jsx';
+import type { TrueStore } from './makeStore.js';
+import type { Key } from '../Key.js';
+export type SubscribedElements = Map<TungstenBaseComponent<any, any>, Set<Key>>;
+export type StoreSubscriptionsMap = Map<TrueStore<any>, SubscribedElements>;
+//# sourceMappingURL=StoreSubscriptions.types.d.ts.map

package/dist/Store/StoreSubscriptions.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoreSubscriptions.types.d.ts","sourceRoot":"","sources":["../../src/Store/StoreSubscriptions.types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAEpC,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;AAC/E,MAAM,MAAM,qBAAqB,GAAG,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,kBAAkB,CAAC,CAAA"}

package/dist/Store/StoreSubscriptions.types.js

@@ -0,0 +1 @@
+export {};

package/dist/Store/TypeSafeStore.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TypeSafeStore.d.ts.map

package/dist/Store/TypeSafeStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSafeStore.d.ts","sourceRoot":"","sources":["../../src/Store/TypeSafeStore.ts"],"names":[],"mappings":""}