effector-storage 6.1.1 → 7.0.0

package/index.d.ts

@@ -1,128 +1,97 @@
-import { Unit, Subscription, Store, Event, Effect } from 'effector'
-export { AsyncStorageConfig, asyncStorage } from './async-storage'
-export { BroadcastConfig, broadcast } from './broadcast'
-export { LocalStorageConfig, local } from './local'
-export { LogConfig, log } from './log'
-export { MemoryConfig, memory } from './memory'
-export { NilConfig, nil } from './nil'
-export { QueryConfig, query } from './query'
-export { SessionStorageConfig, session } from './session'
-export { StorageConfig, storage } from './storage'
-export { async, either, farcached } from './tools'
+import { Unit, Subscription, Store, Event, Effect } from 'effector';
+export { AsyncStorageConfig, asyncStorage } from './async-storage';
+export { BroadcastConfig, broadcast } from './broadcast';
+export { LocalStorageConfig, local } from './local';
+export { LogConfig, log } from './log';
+export { MemoryConfig, memory } from './memory';
+export { NilConfig, nil } from './nil';
+export { QueryConfig, query } from './query';
+export { SessionStorageConfig, session } from './session';
+export { StorageConfig, storage } from './storage';
+export { async, either, farcached } from './tools';
 
 interface StorageAdapter {
-  <State>(key: string, update: (raw?: any) => any): {
-    get(raw?: any, ctx?: any): State | Promise<State | undefined> | undefined
-    set(value: State, ctx?: any): void
-  }
-  keyArea?: any
-  noop?: boolean
+    <State>(key: string, update: (raw?: any) => void): {
+        get(raw?: any, ctx?: any): State | Promise<State | undefined> | undefined;
+        set(value: State, ctx?: any): void;
+    };
+    keyArea?: any;
+    noop?: boolean;
 }
 interface StorageAdapterFactory<AdapterConfig> {
-  (config?: AdapterConfig): StorageAdapter
-  factory: true
+    (config?: AdapterConfig): StorageAdapter;
+    factory: true;
 }
-type Contract<Data> =
-  | ((raw: unknown) => raw is Data)
-  | {
-      isData: (raw: unknown) => raw is Data
-      getErrorMessages: (raw: unknown) => string[]
-    }
+type Contract<Data> = ((raw: unknown) => raw is Data) | {
+    isData: (raw: unknown) => raw is Data;
+    getErrorMessages: (raw: unknown) => string[];
+};
 type Done<State> = {
-  key: string
-  keyPrefix: string
-  operation: 'set' | 'get'
-  value: State
-}
+    key: string;
+    keyPrefix: string;
+    operation: 'set' | 'get';
+    value: State;
+};
 type Fail<Err> = {
-  key: string
-  keyPrefix: string
-  operation: 'set' | 'get'
-  error: Err
-  value?: any
-}
-type Finally<State, Err> =
-  | (Done<State> & {
-      status: 'done'
-    })
-  | (Fail<Err> & {
-      status: 'fail'
-    })
+    key: string;
+    keyPrefix: string;
+    operation: 'set' | 'get';
+    error: Err;
+    value?: any;
+};
+type Finally<State, Err> = (Done<State> & {
+    status: 'done';
+}) | (Fail<Err> & {
+    status: 'fail';
+});
 interface ConfigPersist {
-  pickup?: Unit<any>
-  context?: Unit<any>
-  keyPrefix?: string
-  contract?: Contract<any>
+    pickup?: Unit<any>;
+    context?: Unit<any>;
+    keyPrefix?: string;
+    contract?: Contract<any>;
 }
 interface ConfigAdapter {
-  adapter: StorageAdapter
+    adapter: StorageAdapter;
 }
 interface ConfigAdapterFactory<AdapterConfig> {
-  adapter: StorageAdapterFactory<AdapterConfig>
+    adapter: StorageAdapterFactory<AdapterConfig>;
 }
 interface ConfigCommon<State, Err = Error> {
-  clock?: Unit<any>
-  done?: Unit<Done<State>>
-  fail?: Unit<Fail<Err>>
-  finally?: Unit<Finally<State, Err>>
-  pickup?: Unit<any>
-  context?: Unit<any>
-  key?: string
-  keyPrefix?: string
-  contract?: Contract<State | undefined>
+    clock?: Unit<any>;
+    done?: Unit<Done<State>>;
+    fail?: Unit<Fail<Err>>;
+    finally?: Unit<Finally<State, Err>>;
+    pickup?: Unit<any>;
+    context?: Unit<any>;
+    key?: string;
+    keyPrefix?: string;
+    contract?: Contract<State | undefined>;
 }
 interface ConfigJustStore<State> {
-  store: Store<State>
+    store: Store<State>;
 }
 interface ConfigJustSourceTarget<State> {
-  source: Store<State> | Event<State> | Effect<State, any, any>
-  target: Store<State> | Event<State> | Effect<State, any, any>
+    source: Store<State> | Event<State> | Effect<State, any, any>;
+    target: Store<State> | Event<State> | Effect<State, any, any>;
+}
+interface ConfigStore<State, Err = Error> extends ConfigCommon<State, Err>, ConfigJustStore<State> {
+}
+interface ConfigSourceTarget<State, Err = Error> extends ConfigCommon<State, Err>, ConfigJustSourceTarget<State> {
 }
-interface ConfigStore<State, Err = Error>
-  extends ConfigCommon<State, Err>,
-    ConfigJustStore<State> {}
-interface ConfigSourceTarget<State, Err = Error>
-  extends ConfigCommon<State, Err>,
-    ConfigJustSourceTarget<State> {}
 interface Persist {
-  <State, Err = Error>(
-    config: ConfigAdapter & ConfigSourceTarget<State, Err>
-  ): Subscription
-  <State, Err = Error>(
-    config: ConfigAdapter & ConfigStore<State, Err>
-  ): Subscription
-  <AdapterConfig, State, Err = Error>(
-    config: ConfigAdapterFactory<AdapterConfig> &
-      ConfigSourceTarget<State, Err> &
-      AdapterConfig
-  ): Subscription
-  <AdapterConfig, State, Err = Error>(
-    config: ConfigAdapterFactory<AdapterConfig> &
-      ConfigStore<State, Err> &
-      AdapterConfig
-  ): Subscription
+    <State, Err = Error>(config: ConfigAdapter & ConfigSourceTarget<State, Err>): Subscription;
+    <State, Err = Error>(config: ConfigAdapter & ConfigStore<State, Err>): Subscription;
+    <AdapterConfig, State, Err = Error>(config: ConfigAdapterFactory<AdapterConfig> & ConfigSourceTarget<State, Err> & AdapterConfig): Subscription;
+    <AdapterConfig, State, Err = Error>(config: ConfigAdapterFactory<AdapterConfig> & ConfigStore<State, Err> & AdapterConfig): Subscription;
 }
 
 /**
  * Creates custom `persist`
  */
-declare function createPersist(defaults?: ConfigPersist): Persist
+declare function createPersist(defaults?: ConfigPersist): Persist;
 /**
  * Default `persist`
  */
-declare const persist: Persist
+declare const persist: Persist;
 
-export {
-  ConfigPersist,
-  ConfigSourceTarget,
-  ConfigStore,
-  Contract,
-  Done,
-  Fail,
-  Finally,
-  Persist,
-  StorageAdapter,
-  StorageAdapterFactory,
-  createPersist,
-  persist,
-}
+export { type ConfigPersist, type ConfigSourceTarget, type ConfigStore, type Contract, type Done, type Fail, type Finally, type Persist, type StorageAdapter, type StorageAdapterFactory, createPersist, persist };

package/index.js.flow

@@ -5,21 +5,21 @@
  * @flow
  */
 
-import { Unit, Subscription, Store, Event, Effect } from 'effector'
-declare export { AsyncStorageConfig, asyncStorage } from './async-storage'
-declare export { BroadcastConfig, broadcast } from './broadcast'
-declare export { LocalStorageConfig, local } from './local'
-declare export { LogConfig, log } from './log'
-declare export { MemoryConfig, memory } from './memory'
-declare export { NilConfig, nil } from './nil'
-declare export { QueryConfig, query } from './query'
-declare export { SessionStorageConfig, session } from './session'
-declare export { StorageConfig, storage } from './storage'
-declare export { async, either, farcached } from './tools'
+import { Unit, Subscription, Store, Event, Effect } from "effector";
+declare export { AsyncStorageConfig, asyncStorage } from "./async-storage";
+declare export { BroadcastConfig, broadcast } from "./broadcast";
+declare export { LocalStorageConfig, local } from "./local";
+declare export { LogConfig, log } from "./log";
+declare export { MemoryConfig, memory } from "./memory";
+declare export { NilConfig, nil } from "./nil";
+declare export { QueryConfig, query } from "./query";
+declare export { SessionStorageConfig, session } from "./session";
+declare export { StorageConfig, storage } from "./storage";
+declare export { async, either, farcached } from "./tools";
 declare interface StorageAdapter {
   <State>(
     key: string,
-    update: (raw?: any) => any
+    update: (raw?: any) => void
   ): {
     get(raw?: any, ctx?: any): State | Promise<State | void> | void,
     set(value: State, ctx?: any): void,
@@ -38,37 +38,37 @@ declare type Contract<Data> =
       isData: (raw: mixed) => boolean,
       getErrorMessages: (raw: mixed) => string[],
       ...
-    }
+    };
 declare type Done<State> = {
   key: string,
   keyPrefix: string,
-  operation: 'set' | 'get',
+  operation: "set" | "get",
   value: State,
   ...
-}
+};
 declare type Fail<Err> = {
   key: string,
   keyPrefix: string,
-  operation: 'set' | 'get',
+  operation: "set" | "get",
   error: Err,
   value?: any,
   ...
-}
+};
 declare type Finally<State, Err> =
   | {
       ...Done<State>,
       ...{
-        status: 'done',
+        status: "done",
         ...
       },
     }
   | {
       ...Fail<Err>,
       ...{
-        status: 'fail',
+        status: "fail",
         ...
       },
-    }
+    };
 declare interface ConfigPersist {
   pickup?: Unit<any>;
   context?: Unit<any>;
@@ -103,12 +103,12 @@ declare type ConfigStore<State, Err = Error> = { ... } & ConfigCommon<
   State,
   Err
 > &
-  ConfigJustStore<State>
+  ConfigJustStore<State>;
 declare type ConfigSourceTarget<State, Err = Error> = { ... } & ConfigCommon<
   State,
   Err
 > &
-  ConfigJustSourceTarget<State>
+  ConfigJustSourceTarget<State>;
 declare interface Persist {
   <State, Err>(config: {
     ...ConfigAdapter,
@@ -129,9 +129,9 @@ declare interface Persist {
     ...AdapterConfig,
   }): Subscription;
 }
-declare function createPersist(defaults?: ConfigPersist): Persist
-declare var persist: Persist
-declare export {
+declare function createPersist(defaults?: ConfigPersist): Persist;
+declare var persist: Persist;
+export type {
   ConfigPersist,
   ConfigSourceTarget,
   ConfigStore,
@@ -142,6 +142,5 @@ declare export {
   Persist,
   StorageAdapter,
   StorageAdapterFactory,
-  createPersist,
-  persist,
-}
+};
+declare export { createPersist, persist };

package/local/index.d.cts

@@ -0,0 +1,99 @@
+import { Unit, Store, Event, Effect, Subscription } from 'effector';
+
+interface StorageAdapter {
+    <State>(key: string, update: (raw?: any) => void): {
+        get(raw?: any, ctx?: any): State | Promise<State | undefined> | undefined;
+        set(value: State, ctx?: any): void;
+    };
+    keyArea?: any;
+    noop?: boolean;
+}
+interface StorageAdapterFactory<AdapterConfig> {
+    (config?: AdapterConfig): StorageAdapter;
+    factory: true;
+}
+type Contract<Data> = ((raw: unknown) => raw is Data) | {
+    isData: (raw: unknown) => raw is Data;
+    getErrorMessages: (raw: unknown) => string[];
+};
+type Done<State> = {
+    key: string;
+    keyPrefix: string;
+    operation: 'set' | 'get';
+    value: State;
+};
+type Fail<Err> = {
+    key: string;
+    keyPrefix: string;
+    operation: 'set' | 'get';
+    error: Err;
+    value?: any;
+};
+type Finally<State, Err> = (Done<State> & {
+    status: 'done';
+}) | (Fail<Err> & {
+    status: 'fail';
+});
+interface ConfigPersist$1 {
+    pickup?: Unit<any>;
+    context?: Unit<any>;
+    keyPrefix?: string;
+    contract?: Contract<any>;
+}
+interface ConfigCommon<State, Err = Error> {
+    clock?: Unit<any>;
+    done?: Unit<Done<State>>;
+    fail?: Unit<Fail<Err>>;
+    finally?: Unit<Finally<State, Err>>;
+    pickup?: Unit<any>;
+    context?: Unit<any>;
+    key?: string;
+    keyPrefix?: string;
+    contract?: Contract<State | undefined>;
+}
+interface ConfigJustStore<State> {
+    store: Store<State>;
+}
+interface ConfigJustSourceTarget<State> {
+    source: Store<State> | Event<State> | Effect<State, any, any>;
+    target: Store<State> | Event<State> | Effect<State, any, any>;
+}
+interface ConfigStore$1<State, Err = Error> extends ConfigCommon<State, Err>, ConfigJustStore<State> {
+}
+interface ConfigSourceTarget$1<State, Err = Error> extends ConfigCommon<State, Err>, ConfigJustSourceTarget<State> {
+}
+
+interface ConfigPersist extends ConfigPersist$1 {
+    sync?: boolean | 'force';
+    timeout?: number;
+}
+interface LocalStorageConfig {
+    sync?: boolean | 'force';
+    serialize?: (value: any) => string;
+    deserialize?: (value: string) => any;
+    timeout?: number;
+    def?: any;
+}
+interface ConfigStore<State, Err = Error> extends LocalStorageConfig, ConfigStore$1<State, Err> {
+}
+interface ConfigSourceTarget<State, Err = Error> extends LocalStorageConfig, ConfigSourceTarget$1<State, Err> {
+}
+interface Persist {
+    <State, Err = Error>(config: ConfigSourceTarget<State, Err>): Subscription;
+    <State, Err = Error>(config: ConfigStore<State, Err>): Subscription;
+}
+declare function local(config?: LocalStorageConfig): StorageAdapter;
+declare namespace local {
+    var factory: true;
+}
+/**
+ * Creates custom partially applied `persist`
+ * with predefined `localStorage` adapter
+ */
+declare function createPersist(defaults?: ConfigPersist): Persist;
+/**
+ * Default partially applied `persist`
+ */
+declare const persist: Persist;
+
+export { type ConfigPersist, type ConfigSourceTarget, type ConfigStore, type Contract, type Done, type Fail, type Finally, type LocalStorageConfig, type Persist, type StorageAdapter, type StorageAdapterFactory, createPersist, local, persist };

package/local/index.d.ts

@@ -1,122 +1,99 @@
-import { Unit, Store, Event, Effect, Subscription } from 'effector'
+import { Unit, Store, Event, Effect, Subscription } from 'effector';
 
 interface StorageAdapter {
-  <State>(key: string, update: (raw?: any) => any): {
-    get(raw?: any, ctx?: any): State | Promise<State | undefined> | undefined
-    set(value: State, ctx?: any): void
-  }
-  keyArea?: any
-  noop?: boolean
+    <State>(key: string, update: (raw?: any) => void): {
+        get(raw?: any, ctx?: any): State | Promise<State | undefined> | undefined;
+        set(value: State, ctx?: any): void;
+    };
+    keyArea?: any;
+    noop?: boolean;
 }
 interface StorageAdapterFactory<AdapterConfig> {
-  (config?: AdapterConfig): StorageAdapter
-  factory: true
+    (config?: AdapterConfig): StorageAdapter;
+    factory: true;
 }
-type Contract<Data> =
-  | ((raw: unknown) => raw is Data)
-  | {
-      isData: (raw: unknown) => raw is Data
-      getErrorMessages: (raw: unknown) => string[]
-    }
+type Contract<Data> = ((raw: unknown) => raw is Data) | {
+    isData: (raw: unknown) => raw is Data;
+    getErrorMessages: (raw: unknown) => string[];
+};
 type Done<State> = {
-  key: string
-  keyPrefix: string
-  operation: 'set' | 'get'
-  value: State
-}
+    key: string;
+    keyPrefix: string;
+    operation: 'set' | 'get';
+    value: State;
+};
 type Fail<Err> = {
-  key: string
-  keyPrefix: string
-  operation: 'set' | 'get'
-  error: Err
-  value?: any
-}
-type Finally<State, Err> =
-  | (Done<State> & {
-      status: 'done'
-    })
-  | (Fail<Err> & {
-      status: 'fail'
-    })
+    key: string;
+    keyPrefix: string;
+    operation: 'set' | 'get';
+    error: Err;
+    value?: any;
+};
+type Finally<State, Err> = (Done<State> & {
+    status: 'done';
+}) | (Fail<Err> & {
+    status: 'fail';
+});
 interface ConfigPersist$1 {
-  pickup?: Unit<any>
-  context?: Unit<any>
-  keyPrefix?: string
-  contract?: Contract<any>
+    pickup?: Unit<any>;
+    context?: Unit<any>;
+    keyPrefix?: string;
+    contract?: Contract<any>;
 }
 interface ConfigCommon<State, Err = Error> {
-  clock?: Unit<any>
-  done?: Unit<Done<State>>
-  fail?: Unit<Fail<Err>>
-  finally?: Unit<Finally<State, Err>>
-  pickup?: Unit<any>
-  context?: Unit<any>
-  key?: string
-  keyPrefix?: string
-  contract?: Contract<State | undefined>
+    clock?: Unit<any>;
+    done?: Unit<Done<State>>;
+    fail?: Unit<Fail<Err>>;
+    finally?: Unit<Finally<State, Err>>;
+    pickup?: Unit<any>;
+    context?: Unit<any>;
+    key?: string;
+    keyPrefix?: string;
+    contract?: Contract<State | undefined>;
 }
 interface ConfigJustStore<State> {
-  store: Store<State>
+    store: Store<State>;
 }
 interface ConfigJustSourceTarget<State> {
-  source: Store<State> | Event<State> | Effect<State, any, any>
-  target: Store<State> | Event<State> | Effect<State, any, any>
+    source: Store<State> | Event<State> | Effect<State, any, any>;
+    target: Store<State> | Event<State> | Effect<State, any, any>;
+}
+interface ConfigStore$1<State, Err = Error> extends ConfigCommon<State, Err>, ConfigJustStore<State> {
+}
+interface ConfigSourceTarget$1<State, Err = Error> extends ConfigCommon<State, Err>, ConfigJustSourceTarget<State> {
 }
-interface ConfigStore$1<State, Err = Error>
-  extends ConfigCommon<State, Err>,
-    ConfigJustStore<State> {}
-interface ConfigSourceTarget$1<State, Err = Error>
-  extends ConfigCommon<State, Err>,
-    ConfigJustSourceTarget<State> {}
 
 interface ConfigPersist extends ConfigPersist$1 {
-  sync?: boolean | 'force'
-  timeout?: number
+    sync?: boolean | 'force';
+    timeout?: number;
 }
 interface LocalStorageConfig {
-  sync?: boolean | 'force'
-  serialize?: (value: any) => string
-  deserialize?: (value: string) => any
-  timeout?: number
-  def?: any
+    sync?: boolean | 'force';
+    serialize?: (value: any) => string;
+    deserialize?: (value: string) => any;
+    timeout?: number;
+    def?: any;
+}
+interface ConfigStore<State, Err = Error> extends LocalStorageConfig, ConfigStore$1<State, Err> {
+}
+interface ConfigSourceTarget<State, Err = Error> extends LocalStorageConfig, ConfigSourceTarget$1<State, Err> {
 }
-interface ConfigStore<State, Err = Error>
-  extends LocalStorageConfig,
-    ConfigStore$1<State, Err> {}
-interface ConfigSourceTarget<State, Err = Error>
-  extends LocalStorageConfig,
-    ConfigSourceTarget$1<State, Err> {}
 interface Persist {
-  <State, Err = Error>(config: ConfigSourceTarget<State, Err>): Subscription
-  <State, Err = Error>(config: ConfigStore<State, Err>): Subscription
+    <State, Err = Error>(config: ConfigSourceTarget<State, Err>): Subscription;
+    <State, Err = Error>(config: ConfigStore<State, Err>): Subscription;
 }
-declare function local(config?: LocalStorageConfig): StorageAdapter
+declare function local(config?: LocalStorageConfig): StorageAdapter;
 declare namespace local {
-  var factory: true
+    var factory: true;
 }
 /**
  * Creates custom partially applied `persist`
  * with predefined `localStorage` adapter
  */
-declare function createPersist(defaults?: ConfigPersist): Persist
+declare function createPersist(defaults?: ConfigPersist): Persist;
 /**
  * Default partially applied `persist`
  */
-declare const persist: Persist
+declare const persist: Persist;
 
-export {
-  ConfigPersist,
-  ConfigSourceTarget,
-  ConfigStore,
-  Contract,
-  Done,
-  Fail,
-  Finally,
-  LocalStorageConfig,
-  Persist,
-  StorageAdapter,
-  StorageAdapterFactory,
-  createPersist,
-  local,
-  persist,
-}
+export { type ConfigPersist, type ConfigSourceTarget, type ConfigStore, type Contract, type Done, type Fail, type Finally, type LocalStorageConfig, type Persist, type StorageAdapter, type StorageAdapterFactory, createPersist, local, persist };