effector-storage 5.0.1 → 6.0.1

package/README.md

@@ -19,12 +19,14 @@ Small module for [Effector](https://github.com/effector/effector) ☄️ to sync
   - [with query string](#with-query-string)
   - [with React Native AsyncStorage](#with-react-native-asyncstorage)
   - [with React Native EncryptedStorage](#with-react-native-encryptedstorage)
+  - [extra adapters](#extra-adapters)
 - [Usage with domains](#usage-with-domains)
-- [Functional helpers](#functional-helpers)
 - [Formulae](#formulae)
   - [Units](#units)
   - [Options](#options)
   - [Returns](#returns)
+  - [Contracts](#contracts)
+  - [Notes](#notes)
 - [`createPersist` factory](#createpersist-factory)
   - [Options](#options-1)
   - [Returns](#returns-1)
@@ -62,7 +64,7 @@ $ npm install --save effector-storage
 
 ### with `localStorage`
 
-Docs: [effector-storage/local](https://github.com/yumauri/effector-storage/tree/master/src/local/README.md)
+Docs: [effector-storage/local](https://github.com/yumauri/effector-storage/tree/main/src/local/README.md)
 
 ```javascript
 import { persist } from 'effector-storage/local'
@@ -78,7 +80,7 @@ Stores, persisted in `localStorage`, are automatically synced between two (or mo
 
 ### with `sessionStorage`
 
-Docs: [effector-storage/session](https://github.com/yumauri/effector-storage/tree/master/src/session/README.md)
+Docs: [effector-storage/session](https://github.com/yumauri/effector-storage/tree/main/src/session/README.md)
 
 Same as above, just import `persist` from `'effector-storage/session'`:
 
@@ -90,7 +92,7 @@ Stores, persisted in `sessionStorage`, are synced between instances, but not bet
 
 ### with query string
 
-Docs: [effector-storage/query](https://github.com/yumauri/effector-storage/tree/master/src/query/README.md)
+Docs: [effector-storage/query](https://github.com/yumauri/effector-storage/tree/main/src/query/README.md)
 
 You can _reflect_ plain string store value in query string parameter, using this adapter. Think of it like about synchronizing store value and query string parameter.
 
@@ -108,7 +110,9 @@ Use this only with plain string stores (`Store<string | null>`) to avoid strange
 
 ### with React Native AsyncStorage
 
-Docs: [effector-storage/rn/async](https://github.com/yumauri/effector-storage/tree/master/src/rn/async/README.md)
+❗️ Will be deprecated in next minor release and removed in next major release, in favor of [`@effector-storage/react-native-async-storage`](https://github.com/yumauri/effector-storage-extras/tree/main/packages/react-native-async-storage).
+
+Docs: [effector-storage/rn/async](https://github.com/yumauri/effector-storage/tree/main/src/rn/async/README.md)
 
 ```javascript
 import { persist } from 'effector-storage/rn/async'
@@ -124,7 +128,9 @@ persist({ store: $counter })
 
 ### with React Native EncryptedStorage
 
-Docs: [effector-storage/rn/encrypted](https://github.com/yumauri/effector-storage/tree/master/src/rn/encrypted/README.md)
+❗️ Will be deprecated in next minor release and removed in next major release, in favor of [`@effector-storage/react-native-encrypted-storage`](https://github.com/yumauri/effector-storage-extras/tree/main/packages/react-native-encrypted-storage).
+
+Docs: [effector-storage/rn/encrypted](https://github.com/yumauri/effector-storage/tree/main/src/rn/encrypted/README.md)
 
 ```javascript
 import { persist } from 'effector-storage/rn/encrypted'
@@ -138,6 +144,10 @@ persist({ store: $counter })
 
 ⚠️ Note, that [EncryptedStorage] is asynchronous (it is based on [AsyncStorage] actually).
 
+### extra adapters
+
+You can find a collection of useful adapters in [effector-storage-extras](https://github.com/yumauri/effector-storage-extras). That side repository was created in order to not bloat `effector-storage` with dependencies and adapters, which depends on other libraries.
+
 ## Usage with domains
 
 You can use `persist` inside Domain's `onCreateStore` hook:
@@ -177,7 +187,9 @@ In order to synchronize _something_, you need to specify effector units. Dependi
 - `key`? ([_string_]): Key for local/session storage, to store value in. If omitted — `store` name is used. **Note!** If `key` is not specified, `store` _must_ have a `name`! You can use `'effector/babel-plugin'` to have those names automatically.
 - `keyPrefix`? ([_string_]): Prefix, used in adapter, to be concatenated to `key`. By default = `''`.
 - `clock`? ([_Event_] | [_Effect_] | [_Store_]): Unit, if passed – then value from `store`/`source` will be stored in the storage only upon its trigger.
-- `pickup`? ([_Event_] | [_Effect_] | [_Store_]): Unit, which you can specify to update `store` value from storage. **Note!** When you add `pickup`, `persist` _will not_ get initial value from storage automatically!
+- `pickup`? ([_Event_] | [_Effect_] | [_Store_]): Unit, which you can specify to update `store` value from storage. This unit can also set a special context for adapter. **Note!** When you add `pickup`, `persist` _will not_ get initial value from storage automatically!
+- `context`? ([_Event_] | [_Effect_] | [_Store_]): Unit, which can set a special context for adapter.
+- `contract`? ([_Contract_]): Rule to statically validate data from storage.
 - `done`? ([_Event_] | [_Effect_] | [_Store_]): Unit, which will be triggered on each successful read or write from/to storage.<br>
   Payload structure:
   - `key` ([_string_]): Same `key` as above.
@@ -188,14 +200,14 @@ In order to synchronize _something_, you need to specify effector units. Dependi
   Payload structure:
   - `key` ([_string_]): Same `key` as above.
   - `keyPrefix` ([_string_]): Prefix, used in adapter, to be concatenated to `key`. By default = `''`.
-  - `operation` (_`'set'`_ | _`'get'`_): Type of operation, read (get) or write (set).
+  - `operation` (_`'set'`_ | _`'get'`_ | _`'validate'`_): Type of operation, read (get), write (set) or validation against contract (validate).
   - `error` ([_Error_]): Error instance
   - `value`? (_any_): In case of _'set'_ operation — value from `store`. In case of _'get'_ operation could contain raw value from storage or could be empty.
 - `finally`? ([_Event_] | [_Effect_] | [_Store_]): Unit, which will be triggered either in case of success or error.<br>
   Payload structure:
   - `key` ([_string_]): Same `key` as above.
   - `keyPrefix` ([_string_]): Prefix, used in adapter, to be concatenated to `key`. By default = `''`.
-  - `operation` (_`'set'`_ | _`'get'`_): Type of operation, read (get) or write (set).
+  - `operation` (_`'set'`_ | _`'get'`_ | _`'validate'`_): Type of operation, read (get), write (set) or validation against contract (validate).
   - `status` (_`'done'`_ | _`'fail'`_): Operation status.
   - `error`? ([_Error_]): Error instance, in case of error.
   - `value`? (_any_): Value, in case it is exists (look above).
@@ -204,6 +216,58 @@ In order to synchronize _something_, you need to specify effector units. Dependi
 
 - ([_Subscription_]): You can use this subscription to remove store association with storage, if you don't need them to be synced anymore. It is a function.
 
+### Contracts
+
+You can use `contract` option to validate data from storage. Contract has the following type definition:
+
+```typescript
+export type Contract<Data> =
+  | ((raw: unknown) => raw is Data)
+  | {
+      isData: (raw: unknown) => raw is Data
+      getErrorMessages: (raw: unknown) => string[]
+    }
+```
+
+So, it could be simple type guard function in trivial use cases, or more complex object with `isData` type guard and `getErrorMessages` function, which returns array of error messages. This format is fully compatible with [Farfetched contracts](https://farfetched.pages.dev/api/primitives/contract.html), so you can use any adapter from Farfetched ([runtypes](https://farfetched.pages.dev/api/contracts/runtypes.html), [zod](https://farfetched.pages.dev/api/contracts/zod.html), [io-ts](https://farfetched.pages.dev/api/contracts/io-ts.html), [superstruct](https://farfetched.pages.dev/api/contracts/superstruct.html), [typed-contracts](https://farfetched.pages.dev/api/contracts/typed-contracts.html)) with `persist` and `contract` option:
+
+```typescript
+// simple type guard
+persist({
+  store: $counter,
+  key: 'counter',
+  contract: (raw): raw is number => typeof raw === 'number',
+})
+```
+
+```typescript
+// complex contract with Farfetched adapter
+import { Record, Literal, Number } from 'runtypes'
+import { runtypeContract } from '@farfetched/runtypes'
+
+const Asteroid = Record({
+  type: Literal('asteroid'),
+  mass: Number,
+})
+
+persist({
+  store: $asteroid,
+  key: 'asteroid',
+  contract: runtypeContract(Asteroid),
+})
+```
+
+There are two gotchas with contracts:
+
+1. From `effector-storage` point of view it is absolutely normal, when there is no persisted value in the storage yet. So, `undefined` value is _always valid_, even if contract does not explicitly allow it.
+2. `effector-storage` does not prevent persisting invalid data to the storage, but it will validate it nonetheless, after persisting, so, if you write invalid data to the storage, `fail` will be triggered, but data will be persisted.
+
+### Notes
+
+Without specifying `pickup` property, calling `persist` will immediately call adapter to get initial value. In case of synchronous storage (like `localStorage` or `sessionStorage`) this action will synchronously set store value, and call `done`/`fail`/`finally` right away. You should take that into account, if you adds some logic on `done`, for example — place `persist` after that logic (see issue [#38](https://github.com/yumauri/effector-storage/issues/38) for more details).
+
+You can modify adapter to be asynchronous to mitigate this behavior with [`async`](https://github.com/yumauri/effector-storage/tree/main/src/tools/README.md#async) function.
+
 ## `createPersist` factory
 
 In rare cases you might want to use `createPersist` factory. It allows you to specify some adapter options, like `keyPrefix`.
@@ -229,7 +293,10 @@ persist({
 
 ### Options
 
+- `pickup`? ([_Event_] | [_Effect_] | [_Store_]): Unit, which you can specify to update `store` value from storage. This unit can also set a special context for adapter. **Note!** When you add `pickup`, `persist` _will not_ get initial value from storage automatically!
+- `context`? ([_Event_] | [_Effect_] | [_Store_]): Unit, which can set a special context for adapter.
 - `keyPrefix`? ([_string_]): Key prefix for adapter. It will be concatenated with any `key`, given to returned `persist` function.
+- `contract`? ([_Contract_]): Rule to statically validate data from storage.
 
 ### Returns
 
@@ -239,7 +306,7 @@ persist({
 
 `effector-storage` consists of a _core_ module and _adapter_ modules.
 
-The core module itself does nothing with actual storage, it just connects effector units to the storage adapter, using two _Effects_ and bunch of _forwards_.
+The core module itself does nothing with actual storage, it just connects effector units to the storage adapter, using couple of _Effects_ and bunch of connections.
 
 The storage adapter _gets_ and _sets_ values, and also can asynchronously emit values on storage updates.
 
@@ -258,10 +325,11 @@ Adapter is a function, which is called by the core `persist` function, and has f
 ```typescript
 interface StorageAdapter {
   <State>(key: string, update: (raw?: any) => any): {
-    get(raw?: any): State | Promise<State>
-    set(value: State): void
+    get(raw?: any, ctx?: any): State | Promise<State | undefined> | undefined
+    set(value: State, ctx?: any): void
   }
   keyArea?: any
+  noop?: boolean
 }
 ```
 
@@ -273,13 +341,18 @@ interface StorageAdapter {
 #### Returns
 
 - `{ get, set }` (_{ Function, Function }_): Getter from and setter to storage. These functions are used as Effects handlers, and could be sync or async. Also, you don't have to catch exceptions and errors inside those functions — Effects will do that for you.<br>
-  As mentioned above, call of `update` function will trigger `get` function with the same argument. So you can handle cases, when `get` function is called during initial `persist` execution (without arguments), or after external update. Check out [example below](#storage-with-external-updates-example).
+  As mentioned above, call of `update` function will trigger `get` function with the same argument. So you can handle cases, when `get` function is called during initial `persist` execution (without arguments), or after external update. Check out [example below](#storage-with-external-updates-example).<br>
+  Also getter and setter both accepts optional _context_ as a second argument — it can be any value. This context could be useful, if adapter depends on some external environment, for example, it can contain _Request_ and _Response_ from Express middleware, to get/set cookies from/to. (TODO: isomorphic cookies adapter example).
 
 #### keyArea
 
 Adapter function can have static field `keyArea` — this could be any value of any type, which should be unique for _keys namespace_. For example, two local storage adapters could have different settings, but both of them uses same _storage area_ — `localStorage`. So, different stores, persisted in local storage with the same key (but possibly with different adapters), should be synced. That is what `keyArea` is responsible for. Value of that field is used as a key in cache `Map`.<br>
 In case it is omitted — adapter instances is used instead.
 
+#### noop
+
+Marks adapter as "no-op" for [`either`](https://github.com/yumauri/effector-storage/tree/main/src/tools/README.md#either) function.
+
 ### Synchronous storage adapter example
 
 For example, simplified _localStorage_ adapter might looks like this. This is over-simplified example, don't do that in real code, there are no serialization and deserialization, no checks for edge cases. This is just to show an idea.
@@ -378,10 +451,10 @@ import { persist } from 'effector-storage'
 const pickup = createEvent()
 
 const adapter = (key, update) => {
-  // if `pickup` event was triggered -> trigger `update`
+  // if `pickup` event was triggered -> call an `update` function
   // this will call `get` function from below ↓
   // wrapped in Effect, to handle any errors
-  forward({ from: pickup, to: update })
+  pickup.watch(update)
   return {
     get: () => localStorage.getItem(key),
     set: (value) => localStorage.setItem(key, value),
@@ -443,7 +516,7 @@ adapter = storage(options)
 #### Options
 
 - `storage` (_Storage_): Storage to communicate with.
-- `sync`? ([_boolean_]): Add [`'storage'`] event listener or no. Default = `false`.
+- `sync`? ([_boolean_] | 'force'): Add [`'storage'`] event listener or no. Default = `false`. In case of `'force'` value adapter will always read new value from _Storage_, instead of event.
 - `serialize`? (_(value: any) => string_): Custom serialize function. Default = `JSON.stringify`
 - `deserialize`? (_(value: string) => any_): Custom deserialize function. Default = `JSON.parse`
 
@@ -486,11 +559,11 @@ Use this approach with caution, beware of infinite circular updates. To avoid th
 
 ## TODO
 
-- [x] [localStorage] support (docs: [effector-storage/local](https://github.com/yumauri/effector-storage/tree/master/src/local/README.md))
-- [x] [sessionStorage] support (docs: [effector-storage/session](https://github.com/yumauri/effector-storage/tree/master/src/session/README.md))
-- [x] [query string](https://developer.mozilla.org/en-US/docs/Web/API/Location/search) support (docs: [effector-storage/query](https://github.com/yumauri/effector-storage/tree/master/src/query/README.md))
-- [x] [AsyncStorage] support (docs: [effector-storage/rn/async](https://github.com/yumauri/effector-storage/tree/master/src/rn/async/README.md))
-- [x] [EncryptedStorage] support (docs: [effector-storage/rn/encrypted](https://github.com/yumauri/effector-storage/tree/master/src/rn/encrypted/README.md))
+- [x] [localStorage] support (docs: [effector-storage/local](https://github.com/yumauri/effector-storage/tree/main/src/local/README.md))
+- [x] [sessionStorage] support (docs: [effector-storage/session](https://github.com/yumauri/effector-storage/tree/main/src/session/README.md))
+- [x] [query string](https://developer.mozilla.org/en-US/docs/Web/API/Location/search) support (docs: [effector-storage/query](https://github.com/yumauri/effector-storage/tree/main/src/query/README.md))
+- [x] [AsyncStorage] support (docs: [effector-storage/rn/async](https://github.com/yumauri/effector-storage/tree/main/src/rn/async/README.md))
+- [x] [EncryptedStorage] support (docs: [effector-storage/rn/encrypted](https://github.com/yumauri/effector-storage/tree/main/src/rn/encrypted/README.md))
 - [ ] [IndexedDB] support
 - [ ] [Cookies] support
 - [ ] you name it support
@@ -516,3 +589,4 @@ Use this approach with caution, beware of infinite circular updates. To avoid th
 [_function_]: https://developer.mozilla.org/en-US/docs/Glossary/Function
 [_boolean_]: https://developer.mozilla.org/en-US/docs/Glossary/Boolean
 [_error_]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+[_Contract_]: #contracts

package/async-storage/index.cjs

@@ -1,2 +1,2 @@
-"use strict";exports.asyncStorage=function({storage:e,serialize:t=JSON.stringify,deserialize:a=JSON.parse}){var r=r=>({async get(){var t=await e.getItem(r);return null===t?void 0:a(t)},async set(a){await e.setItem(r,t(a))}});return r.keyArea=e,r};
+"use strict";function e({storage:e,serialize:t=JSON.stringify,deserialize:a=JSON.parse}){var r=r=>({async get(){var t=await e().getItem(r);return null===t?void 0:a(t)},async set(a){await e().setItem(r,t(a))}});try{r.keyArea=e()}catch(e){}return r}e.factory=!0,exports.asyncStorage=e;
 //# sourceMappingURL=index.cjs.map

package/async-storage/index.cjs.d.ts

@@ -1,21 +1,28 @@
-import { StorageAdapter } from '..'
+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
+}
 
 interface AsyncStorage {
   getItem: (key: string) => Promise<string | null>
   setItem: (key: string, value: string) => Promise<void>
 }
 interface AsyncStorageConfig {
-  storage: AsyncStorage
+  storage: () => AsyncStorage
   serialize?: (value: any) => string
   deserialize?: (value: string) => any
 }
-/**
- * Generic `AsyncStorage` adapter factory
- */
 declare function asyncStorage({
   storage,
   serialize,
   deserialize,
 }: AsyncStorageConfig): StorageAdapter
+declare namespace asyncStorage {
+  var factory: true
+}
 
 export { AsyncStorage, AsyncStorageConfig, asyncStorage }

package/async-storage/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../../src/async-storage/index.ts"],"sourcesContent":["import type { StorageAdapter } from '..'\n\nexport interface AsyncStorage {\n  getItem: (key: string) => Promise<string | null>\n  setItem: (key: string, value: string) => Promise<void>\n}\n\nexport interface AsyncStorageConfig {\n  storage: AsyncStorage\n  serialize?: (value: any) => string\n  deserialize?: (value: string) => any\n}\n\n/**\n * Generic `AsyncStorage` adapter factory\n */\nexport function asyncStorage({\n  storage,\n  serialize = JSON.stringify,\n  deserialize = JSON.parse,\n}: AsyncStorageConfig): StorageAdapter {\n  const adapter: StorageAdapter = <State>(key: string) => ({\n    async get() {\n      const item = await storage.getItem(key)\n      return item === null ? undefined : deserialize(item)\n    },\n\n    async set(value: State) {\n      await storage.setItem(key, serialize(value))\n    },\n  })\n\n  adapter.keyArea = storage\n  return adapter\n}\n"],"names":["storage","serialize","JSON","stringify","deserialize","parse","adapter","key","async","item","getItem","undefined","value","setItem","keyArea"],"mappings":"kCAgBO,UAAsBA,QAC3BA,EAD2BC,UAE3BA,EAAYC,KAAKC,UAFUC,YAG3BA,EAAcF,KAAKG,QAEnB,IAAMC,EAAkCC,IAAiB,CACvDC,YACE,IAAMC,QAAaT,EAAQU,QAAQH,GACnC,OAAgB,OAATE,OAAgBE,EAAYP,EAAYK,EAHM,EAMvDD,UAAUI,SACFZ,EAAQa,QAAQN,EAAKN,EAAUW,GACtC,IAIH,OADAN,EAAQQ,QAAUd,EACXM,CACR"}
+{"version":3,"file":"index.cjs","sources":["../../src/async-storage/index.ts"],"sourcesContent":["import type { StorageAdapter } from '../types'\n\nexport interface AsyncStorage {\n  getItem: (key: string) => Promise<string | null>\n  setItem: (key: string, value: string) => Promise<void>\n}\n\nexport interface AsyncStorageConfig {\n  storage: () => AsyncStorage\n  serialize?: (value: any) => string\n  deserialize?: (value: string) => any\n}\n\n/**\n * Creates generic `AsyncStorage` adapter\n */\nasyncStorage.factory = true as const\nexport function asyncStorage({\n  storage,\n  serialize = JSON.stringify,\n  deserialize = JSON.parse,\n}: AsyncStorageConfig): StorageAdapter {\n  const adapter: StorageAdapter = <State>(key: string) => ({\n    async get() {\n      const item = await storage().getItem(key)\n      return item === null ? undefined : deserialize(item)\n    },\n\n    async set(value: State) {\n      await storage().setItem(key, serialize(value))\n    },\n  })\n\n  try {\n    adapter.keyArea = storage()\n  } catch (error) {\n    // do nothing\n  }\n\n  return adapter\n}\n"],"names":["asyncStorage","storage","serialize","JSON","stringify","deserialize","parse","adapter","key","async","item","getItem","undefined","value","setItem","keyArea","error","factory"],"mappings":"aAiBO,SAASA,GAAaC,QAC3BA,EAAOC,UACPA,EAAYC,KAAKC,UAASC,YAC1BA,EAAcF,KAAKG,QAEnB,IAAMC,EAAkCC,IAAiB,CACvDC,YACE,IAAMC,QAAaT,IAAUU,QAAQH,GACrC,OAAgB,OAATE,OAAgBE,EAAYP,EAAYK,EAChD,EAEDD,UAAUI,SACFZ,IAAUa,QAAQN,EAAKN,EAAUW,GACzC,IAGF,IACEN,EAAQQ,QAAUd,GACnB,CAAC,MAAOe,GACP,CAGF,OAAOT,CACT,CAxBAP,EAAaiB,SAAU"}

package/async-storage/index.d.ts

@@ -1,21 +1,28 @@
-import { StorageAdapter } from '..'
+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
+}
 
 interface AsyncStorage {
   getItem: (key: string) => Promise<string | null>
   setItem: (key: string, value: string) => Promise<void>
 }
 interface AsyncStorageConfig {
-  storage: AsyncStorage
+  storage: () => AsyncStorage
   serialize?: (value: any) => string
   deserialize?: (value: string) => any
 }
-/**
- * Generic `AsyncStorage` adapter factory
- */
 declare function asyncStorage({
   storage,
   serialize,
   deserialize,
 }: AsyncStorageConfig): StorageAdapter
+declare namespace asyncStorage {
+  var factory: true
+}
 
 export { AsyncStorage, AsyncStorageConfig, asyncStorage }

package/async-storage/index.js

@@ -1,2 +1,2 @@
-function e({storage:e,serialize:t=JSON.stringify,deserialize:a=JSON.parse}){var r=r=>({async get(){var t=await e.getItem(r);return null===t?void 0:a(t)},async set(a){await e.setItem(r,t(a))}});return r.keyArea=e,r}export{e as asyncStorage};
+function e({storage:e,serialize:t=JSON.stringify,deserialize:a=JSON.parse}){var r=r=>({async get(){var t=await e().getItem(r);return null===t?void 0:a(t)},async set(a){await e().setItem(r,t(a))}});try{r.keyArea=e()}catch(e){}return r}e.factory=!0;export{e as asyncStorage};
 //# sourceMappingURL=index.js.map

package/async-storage/index.js.flow

@@ -1,19 +1,36 @@
 /**
  * Flowtype definitions for index
  * Generated by Flowgen from a Typescript Definition
- * Flowgen v1.20.1
+ * Flowgen v1.21.0
  * @flow
  */
 
-import { StorageAdapter } from '..'
+declare interface StorageAdapter {
+  <State>(
+    key: string,
+    update: (raw?: any) => any
+  ): {
+    get(raw?: any, ctx?: any): State | Promise<State | void> | void,
+    set(value: State, ctx?: any): void,
+    ...
+  };
+  keyArea?: any;
+  noop?: boolean;
+}
 declare interface AsyncStorage {
   getItem: (key: string) => Promise<string | null>;
   setItem: (key: string, value: string) => Promise<void>;
 }
 declare interface AsyncStorageConfig {
-  storage: AsyncStorage;
+  storage: () => AsyncStorage;
   serialize?: (value: any) => string;
   deserialize?: (value: string) => any;
 }
-declare function asyncStorage(x: AsyncStorageConfig): StorageAdapter
+declare var asyncStorage: typeof npm$namespace$asyncStorage
+
+declare var npm$namespace$asyncStorage: {|
+  (x: AsyncStorageConfig): StorageAdapter,
+  factory: typeof asyncStorage$factory,
+|}
+declare var asyncStorage$factory: true
 declare export { AsyncStorage, AsyncStorageConfig, asyncStorage }

package/async-storage/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/async-storage/index.ts"],"sourcesContent":["import type { StorageAdapter } from '..'\n\nexport interface AsyncStorage {\n  getItem: (key: string) => Promise<string | null>\n  setItem: (key: string, value: string) => Promise<void>\n}\n\nexport interface AsyncStorageConfig {\n  storage: AsyncStorage\n  serialize?: (value: any) => string\n  deserialize?: (value: string) => any\n}\n\n/**\n * Generic `AsyncStorage` adapter factory\n */\nexport function asyncStorage({\n  storage,\n  serialize = JSON.stringify,\n  deserialize = JSON.parse,\n}: AsyncStorageConfig): StorageAdapter {\n  const adapter: StorageAdapter = <State>(key: string) => ({\n    async get() {\n      const item = await storage.getItem(key)\n      return item === null ? undefined : deserialize(item)\n    },\n\n    async set(value: State) {\n      await storage.setItem(key, serialize(value))\n    },\n  })\n\n  adapter.keyArea = storage\n  return adapter\n}\n"],"names":["asyncStorage","storage","serialize","JSON","stringify","deserialize","parse","adapter","key","async","item","getItem","undefined","value","setItem","keyArea"],"mappings":"AAgBO,SAASA,GAAaC,QAC3BA,EAD2BC,UAE3BA,EAAYC,KAAKC,UAFUC,YAG3BA,EAAcF,KAAKG,QAEnB,IAAMC,EAAkCC,IAAiB,CACvDC,YACE,IAAMC,QAAaT,EAAQU,QAAQH,GACnC,OAAgB,OAATE,OAAgBE,EAAYP,EAAYK,EAHM,EAMvDD,UAAUI,SACFZ,EAAQa,QAAQN,EAAKN,EAAUW,GACtC,IAIH,OADAN,EAAQQ,QAAUd,EACXM,CACR"}
+{"version":3,"file":"index.js","sources":["../../src/async-storage/index.ts"],"sourcesContent":["import type { StorageAdapter } from '../types'\n\nexport interface AsyncStorage {\n  getItem: (key: string) => Promise<string | null>\n  setItem: (key: string, value: string) => Promise<void>\n}\n\nexport interface AsyncStorageConfig {\n  storage: () => AsyncStorage\n  serialize?: (value: any) => string\n  deserialize?: (value: string) => any\n}\n\n/**\n * Creates generic `AsyncStorage` adapter\n */\nasyncStorage.factory = true as const\nexport function asyncStorage({\n  storage,\n  serialize = JSON.stringify,\n  deserialize = JSON.parse,\n}: AsyncStorageConfig): StorageAdapter {\n  const adapter: StorageAdapter = <State>(key: string) => ({\n    async get() {\n      const item = await storage().getItem(key)\n      return item === null ? undefined : deserialize(item)\n    },\n\n    async set(value: State) {\n      await storage().setItem(key, serialize(value))\n    },\n  })\n\n  try {\n    adapter.keyArea = storage()\n  } catch (error) {\n    // do nothing\n  }\n\n  return adapter\n}\n"],"names":["asyncStorage","storage","serialize","JSON","stringify","deserialize","parse","adapter","key","async","item","getItem","undefined","value","setItem","keyArea","error","factory"],"mappings":"AAiBO,SAASA,GAAaC,QAC3BA,EAAOC,UACPA,EAAYC,KAAKC,UAASC,YAC1BA,EAAcF,KAAKG,QAEnB,IAAMC,EAAkCC,IAAiB,CACvDC,YACE,IAAMC,QAAaT,IAAUU,QAAQH,GACrC,OAAgB,OAATE,OAAgBE,EAAYP,EAAYK,EAChD,EAEDD,UAAUI,SACFZ,IAAUa,QAAQN,EAAKN,EAAUW,GACzC,IAGF,IACEN,EAAQQ,QAAUd,GACnB,CAAC,MAAOe,GACP,CAGF,OAAOT,CACT,CAxBAP,EAAaiB,SAAU"}

package/async-storage/package.json

@@ -1,5 +1,6 @@
 {
   "type": "module",
+  "sideEffects": false,
   "main": "index.cjs",
   "module": "index.js",
   "react-native": "index.js",

package/core/index.cjs

@@ -0,0 +1,2 @@
+"use strict";var e=require("effector"),r=new Map,t=e=>(r,t)=>e(t,r.ref),o=e.createEvent();o.watch((e=>console.error(e.error))),exports.persist=function(a){var{adapter:i,store:f,source:s=f,target:n=f,clock:d=s,done:c,fail:u=o,finally:l,pickup:p,context:v,key:y,keyPrefix:g="",contract:m}=a;if(!i)throw Error("Adapter is not defined");if(!s)throw Error("Store or source is not defined");if(!n)throw Error("Target is not defined");if(!y&&s.shortName===s.id)throw Error("Key or name is not defined");if(s===n&&!e.is.store(s))throw Error("Source must be different from target");void 0===a.def&&e.is.store(s)&&(a.def=s.defaultState);var k="factory"in i?i(a):i,w=y||s.shortName,h=function(t,o){var a=r.get(t);void 0===a&&(a=new Map,r.set(t,a));var i=a.get(o);return void 0!==i||(i=e.createStore(null,{serialize:"ignore"}),a.set(o,i)),i}(k.keyArea||k,g+w),E=e.createNode(),x=()=>e.clearNode(E),P=e=>({status:r="fail",params:t,result:o,error:a})=>"done"===r?{status:r,key:w,keyPrefix:g,operation:e,value:"get"===e?o:t}:{status:r,key:w,keyPrefix:g,operation:e,value:t,error:a};return e.withRegion(E,(()=>{var r=e.createStore({ref:void 0},{serialize:"ignore"}),o=k(g+w,(e=>D(e))),a=e.attach({source:r,effect:t(o.get)}),i=e.attach({source:r,effect:t(o.set)}),f=e.createEffect((e=>r=>!e||void 0===r||("isData"in e?e.isData(r):e(r))?r:(()=>{throw"getErrorMessages"in e?e.getErrorMessages(r):void 0})())(m)),y=e.createEvent(),E=y.filterMap((({status:e,key:r,keyPrefix:t,operation:o,value:a})=>"done"===e?{key:r,keyPrefix:t,operation:o,value:a}:void 0)),x=y.filterMap((({status:e,key:r,keyPrefix:t,operation:o,error:a,value:i})=>"fail"===e?{key:r,keyPrefix:t,operation:o,error:a,value:i}:void 0)),M=e.createEvent(),D=a;r.updates.watch((()=>{D=(r=>{try{return e.scopeBind(r,{safe:!0})}catch(e){return r}})(a)})),e.sample({source:s,clock:d,target:M}),e.guard({source:e.sample(h,M,((e,r)=>[r,e])),filter:([e,r])=>e!==r,target:i.prepend((([e])=>e))}),e.forward({from:[a.doneData,i],to:h}),e.sample({source:e.merge([a.doneData,h]),target:f}),e.forward({from:f.doneData,to:n}),e.forward({from:[a.finally.map(P("get")),i.finally.map(P("set")),f.fail.map(P("validate"))],to:y}),e.forward({from:x,to:u}),c&&e.forward({from:E,to:c}),l&&e.forward({from:y,to:l}),v&&r.on(v,(({ref:e},r)=>({ref:void 0===r?e:r}))),p?(e.forward({from:p,to:a.prepend((()=>{}))}),r.on(p,(({ref:e},r)=>({ref:void 0===r?e:r})))):a()})),x.unsubscribe=x};
+//# sourceMappingURL=index.cjs.map

package/core/index.cjs.d.ts

@@ -0,0 +1,90 @@
+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
+}
+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 {
+  pickup?: Unit<any>
+  context?: Unit<any>
+  keyPrefix?: string
+  contract?: Contract<any>
+}
+interface ConfigAdapter {
+  adapter: StorageAdapter
+}
+interface ConfigAdapterFactory<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>
+}
+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<State, Err = Error>
+  extends ConfigCommon<State, Err>,
+    ConfigJustStore<State> {}
+interface ConfigSourceTarget<State, Err = Error>
+  extends ConfigCommon<State, Err>,
+    ConfigJustSourceTarget<State> {}
+
+/**
+ * Main `persist` function
+ */
+declare function persist<State, Err = Error>(
+  config: Partial<
+    (ConfigAdapter | ConfigAdapterFactory<any>) &
+      ConfigPersist &
+      ConfigStore<State, Err> &
+      ConfigSourceTarget<State, Err>
+  >
+): Subscription
+
+export { persist }

package/core/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../src/core/area.ts","../../src/core/index.ts"],"sourcesContent":["import type { Store } from 'effector'\nimport { createStore } from 'effector'\n\n/**\n * Keys areas / namespaces cache\n */\nconst areas = new Map<any, Map<string, Store<any>>>()\n\n/**\n * Get store, responsible for the key in key area / namespace\n */\nexport function getAreaStorage<State>(keyArea: any, key: string): Store<State> {\n  let area = areas.get(keyArea)\n  if (area === undefined) {\n    area = new Map()\n    areas.set(keyArea, area)\n  }\n\n  let store = area.get(key)\n  if (store !== undefined) {\n    return store\n  }\n\n  store = createStore(null, { serialize: 'ignore' })\n  area.set(key, store)\n\n  return store\n}\n","import type { Effect, Subscription } from 'effector'\nimport type {\n  ConfigAdapter,\n  ConfigAdapterFactory,\n  ConfigPersist,\n  ConfigSourceTarget,\n  ConfigStore,\n  Contract,\n  Done,\n  Fail,\n  Finally,\n} from '../types'\nimport {\n  attach,\n  clearNode,\n  createEvent,\n  createEffect,\n  createNode,\n  createStore,\n  forward,\n  guard,\n  is,\n  merge,\n  sample,\n  scopeBind,\n  withRegion,\n} from 'effector'\nimport { getAreaStorage } from './area'\n\n// helper function to swap two function arguments\n// end extract current context from ref-box\nconst contextual =\n  <T, C, R>(fn: (value: T, ctx?: C) => R) =>\n  (ctx: { ref?: C }, value: T) =>\n    fn(value, ctx.ref)\n\n// helper function to validate data with contract\nconst contracted =\n  <T>(contract?: Contract<T>) =>\n  (raw: unknown) =>\n    !contract || // no contract -> data is valid\n    raw === undefined || // `undefined` is always valid\n    ('isData' in contract ? contract.isData(raw) : contract(raw))\n      ? (raw as T)\n      : (() => {\n          throw 'getErrorMessages' in contract\n            ? contract.getErrorMessages(raw)\n            : undefined\n        })()\n\n// helper function for safe bind effects to scope\n// since version 22.4.0 there is `safe` option in `scopeBind`,\n// but as long as effector-storage supports 22.0 this helper is required\nconst safeBind = (fx: Effect<any, any, any>) => {\n  try {\n    // @ts-expect-error due to old typings in import\n    return scopeBind(fx, { safe: true })\n  } catch (e) {\n    return fx\n  }\n}\n\n/**\n * Default sink for unhandled errors\n */\nconst sink = createEvent<Fail<any>>()\nsink.watch((payload) => console.error(payload.error))\n\n/**\n * Main `persist` function\n */\nexport function persist<State, Err = Error>(\n  config: Partial<\n    (ConfigAdapter | ConfigAdapterFactory<any>) &\n      ConfigPersist &\n      ConfigStore<State, Err> &\n      ConfigSourceTarget<State, Err>\n  >\n): Subscription {\n  const {\n    adapter: adapterOrFactory,\n    store,\n    source = store,\n    target = store,\n    clock = source,\n    done,\n    fail = sink,\n    finally: anyway,\n    pickup,\n    context,\n    key: keyName,\n    keyPrefix = '',\n    contract,\n  } = config\n\n  if (!adapterOrFactory) {\n    throw Error('Adapter is not defined')\n  }\n  if (!source) {\n    throw Error('Store or source is not defined')\n  }\n  if (!target) {\n    throw Error('Target is not defined')\n  }\n  if (!keyName && source.shortName === (source as any).id) {\n    throw Error('Key or name is not defined')\n  }\n  if (source === target && !is.store(source)) {\n    throw Error('Source must be different from target')\n  }\n\n  // get default value from store, if given\n  // this is used in adapter factory\n  if ((config as any).def === undefined && is.store(source)) {\n    ;(config as any).def = source.defaultState\n  }\n\n  const adapter =\n    'factory' in adapterOrFactory ? adapterOrFactory(config) : adapterOrFactory\n\n  const key = keyName || source.shortName\n  const storage = getAreaStorage<State>(\n    adapter.keyArea || adapter,\n    keyPrefix + key\n  )\n  const region = createNode()\n  const desist = () => clearNode(region)\n\n  const op =\n    (operation: 'get' | 'set' | 'validate') =>\n    ({ status = 'fail', params, result, error }: any): any =>\n      status === 'done'\n        ? {\n            status,\n            key,\n            keyPrefix,\n            operation,\n            value: operation === 'get' ? result : params,\n          }\n        : {\n            status,\n            key,\n            keyPrefix,\n            operation,\n            value: params,\n            error,\n          }\n\n  // create all auxiliary units and nodes within the region,\n  // to be able to remove them all at once on unsubscription\n  withRegion(region, () => {\n    const ctx = createStore<{ ref: any }>(\n      { ref: undefined },\n      { serialize: 'ignore' }\n    )\n\n    const value = adapter<State>(keyPrefix + key, (x) => bindedGet(x))\n\n    const getFx = attach({\n      source: ctx,\n      effect: contextual(value.get),\n    }) as any as Effect<void, State, Err>\n\n    const setFx = attach({\n      source: ctx,\n      effect: contextual(value.set),\n    }) as any as Effect<State, void, Err>\n\n    const validateFx = createEffect<unknown, State>(contracted(contract))\n\n    const localAnyway = createEvent<Finally<State, Err>>()\n    const localDone = localAnyway.filterMap<Done<State>>(\n      ({ status, key, keyPrefix, operation, value }) =>\n        status === 'done' ? { key, keyPrefix, operation, value } : undefined\n    )\n    const localFail = localAnyway.filterMap<Fail<Err>>(\n      ({ status, key, keyPrefix, operation, error, value }: any) =>\n        status === 'fail'\n          ? { key, keyPrefix, operation, error, value }\n          : undefined\n    )\n\n    const trigger = createEvent<State>()\n\n    let bindedGet: (raw?: any) => any = getFx\n    ctx.updates.watch(() => {\n      bindedGet = safeBind(getFx)\n    })\n\n    sample({\n      source,\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      clock: clock!, // `clock` is always defined, as long as `source` is defined\n      target: trigger,\n    })\n\n    guard({\n      source: sample(storage, trigger, (current, proposed) => [\n        proposed,\n        current,\n      ]),\n      filter: ([proposed, current]) => proposed !== current,\n      target: setFx.prepend(([proposed]: State[]) => proposed),\n    })\n    forward({ from: [getFx.doneData, setFx], to: storage })\n    sample({\n      source: merge([getFx.doneData, storage]),\n      target: validateFx as any,\n    })\n    forward({ from: validateFx.doneData, to: target })\n\n    forward({\n      from: [\n        getFx.finally.map(op('get')),\n        setFx.finally.map(op('set')),\n        validateFx.fail.map(op('validate')),\n      ],\n      to: localAnyway,\n    })\n\n    forward({ from: localFail, to: fail })\n    if (done) forward({ from: localDone, to: done })\n    if (anyway) forward({ from: localAnyway, to: anyway })\n\n    if (context) {\n      ctx.on(context, ({ ref }, payload) => ({\n        ref: payload === undefined ? ref : payload,\n      }))\n    }\n\n    if (pickup) {\n      // pick up value from storage ONLY on `pickup` update\n      forward({ from: pickup, to: getFx.prepend(() => undefined) })\n      ctx.on(pickup, ({ ref }, payload) => ({\n        ref: payload === undefined ? ref : payload,\n      }))\n    } else {\n      // kick getter to pick up initial value from storage\n      getFx()\n    }\n  })\n\n  return (desist.unsubscribe = desist)\n}\n"],"names":["areas","Map","contextual","fn","ctx","value","ref","sink","createEvent","watch","payload","console","error","config","adapter","adapterOrFactory","store","source","target","clock","done","fail","finally","anyway","pickup","context","key","keyName","keyPrefix","contract","Error","shortName","id","is","undefined","def","defaultState","storage","keyArea","area","get","set","createStore","serialize","getAreaStorage","region","createNode","desist","clearNode","op","operation","status","params","result","withRegion","x","bindedGet","getFx","attach","effect","setFx","validateFx","createEffect","raw","isData","getErrorMessages","contracted","localAnyway","localDone","filterMap","localFail","trigger","updates","fx","scopeBind","safe","e","safeBind","sample","guard","current","proposed","filter","prepend","forward","from","doneData","to","merge","map","on","unsubscribe"],"mappings":"uCAMMA,EAAQ,IAAIC,ICyBZC,EACMC,GACV,CAACC,EAAkBC,IACjBF,EAAGE,EAAOD,EAAIE,KA+BZC,EAAOC,EAAWA,cACxBD,EAAKE,OAAOC,GAAYC,QAAQC,MAAMF,EAAQE,yBAKvC,SACLC,GAOA,IACEC,QAASC,EAAgBC,MACzBA,EAAKC,OACLA,EAASD,EAAKE,OACdA,EAASF,EAAKG,MACdA,EAAQF,EAAMG,KACdA,EAAIC,KACJA,EAAOd,EACPe,QAASC,EAAMC,OACfA,EAAMC,QACNA,EACAC,IAAKC,EAAOC,UACZA,EAAY,GAAEC,SACdA,GACEhB,EAEJ,IAAKE,EACH,MAAMe,MAAM,0BAEd,IAAKb,EACH,MAAMa,MAAM,kCAEd,IAAKZ,EACH,MAAMY,MAAM,yBAEd,IAAKH,GAAWV,EAAOc,YAAed,EAAee,GACnD,MAAMF,MAAM,8BAEd,GAAIb,IAAWC,IAAWe,EAAEA,GAACjB,MAAMC,GACjC,MAAMa,MAAM,6CAKcI,IAAvBrB,EAAesB,KAAqBF,EAAAA,GAAGjB,MAAMC,KAC9CJ,EAAesB,IAAMlB,EAAOmB,cAGhC,IAAMtB,EACJ,YAAaC,EAAmBA,EAAiBF,GAAUE,EAEvDW,EAAMC,GAAWV,EAAOc,UACxBM,ED9GD,SAA+BC,EAAcZ,GAClD,IAAIa,EAAOvC,EAAMwC,IAAIF,QACRJ,IAATK,IACFA,EAAO,IAAItC,IACXD,EAAMyC,IAAIH,EAASC,IAGrB,IAAIvB,EAAQuB,EAAKC,IAAId,GACrB,YAAcQ,IAAVlB,IAIJA,EAAQ0B,EAAWA,YAAC,KAAM,CAAEC,UAAW,WACvCJ,EAAKE,IAAIf,EAAKV,IAJLA,CAOX,CC8FkB4B,CACd9B,EAAQwB,SAAWxB,EACnBc,EAAYF,GAERmB,EAASC,EAAAA,aACTC,EAASA,IAAMC,YAAUH,GAEzBI,EACHC,GACD,EAAGC,SAAS,OAAQC,SAAQC,SAAQzC,WACvB,SAAXuC,EACI,CACEA,SACAzB,MACAE,YACAsB,YACA7C,MAAqB,QAAd6C,EAAsBG,EAASD,GAExC,CACED,SACAzB,MACAE,YACAsB,YACA7C,MAAO+C,EACPxC,SAiGV,OA5FA0C,EAAUA,WAACT,GAAQ,KACjB,IAAMzC,EAAMsC,EAAAA,YACV,CAAEpC,SAAK4B,GACP,CAAES,UAAW,WAGTtC,EAAQS,EAAec,EAAYF,GAAM6B,GAAMC,EAAUD,KAEzDE,EAAQC,EAAAA,OAAO,CACnBzC,OAAQb,EACRuD,OAAQzD,EAAWG,EAAMmC,OAGrBoB,EAAQF,EAAAA,OAAO,CACnBzC,OAAQb,EACRuD,OAAQzD,EAAWG,EAAMoC,OAGrBoB,EAAaC,EAAYA,aAlI7BjC,IACHkC,IACElC,QACOK,IAAR6B,IACC,WAAYlC,EAAWA,EAASmC,OAAOD,GAAOlC,EAASkC,IACnDA,EACD,MACE,KAAM,qBAAsBlC,EACxBA,EAASoC,iBAAiBF,QAC1B7B,CACL,EAJD,GA4H4CgC,CAAWrC,IAErDsC,EAAc3D,EAAAA,cACd4D,EAAYD,EAAYE,WAC5B,EAAGlB,SAAQzB,MAAKE,YAAWsB,YAAW7C,WACzB,SAAX8C,EAAoB,CAAEzB,MAAKE,YAAWsB,YAAW7C,cAAU6B,IAEzDoC,EAAYH,EAAYE,WAC5B,EAAGlB,SAAQzB,MAAKE,YAAWsB,YAAWtC,QAAOP,WAChC,SAAX8C,EACI,CAAEzB,MAAKE,YAAWsB,YAAWtC,QAAOP,cACpC6B,IAGFqC,EAAU/D,EAAAA,cAEZgD,EAAgCC,EACpCrD,EAAIoE,QAAQ/D,OAAM,KAChB+C,EArIYiB,KAChB,IAEE,OAAOC,EAAAA,UAAUD,EAAI,CAAEE,MAAM,GAC9B,CAAC,MAAOC,GACP,OAAOH,CACT,GA+HgBI,CAASpB,EAAM,IAG7BqB,SAAO,CACL7D,SAEAE,MAAOA,EACPD,OAAQqD,IAGVQ,QAAM,CACJ9D,OAAQ6D,EAAAA,OAAOzC,EAASkC,GAAS,CAACS,EAASC,IAAa,CACtDA,EACAD,KAEFE,OAAQA,EAAED,EAAUD,KAAaC,IAAaD,EAC9C9D,OAAQ0C,EAAMuB,SAAQ,EAAEF,KAAuBA,MAEjDG,UAAQ,CAAEC,KAAM,CAAC5B,EAAM6B,SAAU1B,GAAQ2B,GAAIlD,IAC7CyC,SAAO,CACL7D,OAAQuE,EAAAA,MAAM,CAAC/B,EAAM6B,SAAUjD,IAC/BnB,OAAQ2C,IAEVuB,UAAQ,CAAEC,KAAMxB,EAAWyB,SAAUC,GAAIrE,IAEzCkE,UAAQ,CACNC,KAAM,CACJ5B,EAAMnC,QAAQmE,IAAIxC,EAAG,QACrBW,EAAMtC,QAAQmE,IAAIxC,EAAG,QACrBY,EAAWxC,KAAKoE,IAAIxC,EAAG,cAEzBsC,GAAIpB,IAGNiB,UAAQ,CAAEC,KAAMf,EAAWiB,GAAIlE,IAC3BD,GAAMgE,EAAAA,QAAQ,CAAEC,KAAMjB,EAAWmB,GAAInE,IACrCG,GAAQ6D,EAAAA,QAAQ,CAAEC,KAAMlB,EAAaoB,GAAIhE,IAEzCE,GACFrB,EAAIsF,GAAGjE,GAAS,EAAGnB,OAAOI,KAAa,CACrCJ,SAAiB4B,IAAZxB,EAAwBJ,EAAMI,MAInCc,GAEF4D,UAAQ,CAAEC,KAAM7D,EAAQ+D,GAAI9B,EAAM0B,SAAQ,KAAe,MACzD/E,EAAIsF,GAAGlE,GAAQ,EAAGlB,OAAOI,KAAa,CACpCJ,SAAiB4B,IAAZxB,EAAwBJ,EAAMI,OAIrC+C,GACF,IAGMV,EAAO4C,YAAc5C,CAC/B"}

package/core/index.d.ts

@@ -0,0 +1,90 @@
+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
+}
+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 {
+  pickup?: Unit<any>
+  context?: Unit<any>
+  keyPrefix?: string
+  contract?: Contract<any>
+}
+interface ConfigAdapter {
+  adapter: StorageAdapter
+}
+interface ConfigAdapterFactory<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>
+}
+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<State, Err = Error>
+  extends ConfigCommon<State, Err>,
+    ConfigJustStore<State> {}
+interface ConfigSourceTarget<State, Err = Error>
+  extends ConfigCommon<State, Err>,
+    ConfigJustSourceTarget<State> {}
+
+/**
+ * Main `persist` function
+ */
+declare function persist<State, Err = Error>(
+  config: Partial<
+    (ConfigAdapter | ConfigAdapterFactory<any>) &
+      ConfigPersist &
+      ConfigStore<State, Err> &
+      ConfigSourceTarget<State, Err>
+  >
+): Subscription
+
+export { persist }

package/core/index.js

@@ -0,0 +1,2 @@
+import{createStore as e,createEvent as r,is as o,createNode as t,withRegion as a,attach as i,createEffect as f,sample as n,guard as s,forward as d,merge as u,scopeBind as l,clearNode as c}from"effector";var p=new Map,v=e=>(r,o)=>e(o,r.ref),y=r();function k(k){var{adapter:m,store:g,source:h=g,target:w=g,clock:x=h,done:E,fail:P=y,finally:M,pickup:D,context:b,key:S,keyPrefix:z="",contract:A}=k;if(!m)throw Error("Adapter is not defined");if(!h)throw Error("Store or source is not defined");if(!w)throw Error("Target is not defined");if(!S&&h.shortName===h.id)throw Error("Key or name is not defined");if(h===w&&!o.store(h))throw Error("Source must be different from target");void 0===k.def&&o.store(h)&&(k.def=h.defaultState);var N="factory"in m?m(k):m,K=S||h.shortName,T=function(r,o){var t=p.get(r);void 0===t&&(t=new Map,p.set(r,t));var a=t.get(o);return void 0!==a||(a=e(null,{serialize:"ignore"}),t.set(o,a)),a}(N.keyArea||N,z+K),j=t(),q=()=>c(j),B=e=>({status:r="fail",params:o,result:t,error:a})=>"done"===r?{status:r,key:K,keyPrefix:z,operation:e,value:"get"===e?t:o}:{status:r,key:K,keyPrefix:z,operation:e,value:o,error:a};return a(j,(()=>{var o=e({ref:void 0},{serialize:"ignore"}),t=N(z+K,(e=>S(e))),a=i({source:o,effect:v(t.get)}),c=i({source:o,effect:v(t.set)}),p=f((e=>r=>!e||void 0===r||("isData"in e?e.isData(r):e(r))?r:(()=>{throw"getErrorMessages"in e?e.getErrorMessages(r):void 0})())(A)),y=r(),k=y.filterMap((({status:e,key:r,keyPrefix:o,operation:t,value:a})=>"done"===e?{key:r,keyPrefix:o,operation:t,value:a}:void 0)),m=y.filterMap((({status:e,key:r,keyPrefix:o,operation:t,error:a,value:i})=>"fail"===e?{key:r,keyPrefix:o,operation:t,error:a,value:i}:void 0)),g=r(),S=a;o.updates.watch((()=>{S=(e=>{try{return l(e,{safe:!0})}catch(r){return e}})(a)})),n({source:h,clock:x,target:g}),s({source:n(T,g,((e,r)=>[r,e])),filter:([e,r])=>e!==r,target:c.prepend((([e])=>e))}),d({from:[a.doneData,c],to:T}),n({source:u([a.doneData,T]),target:p}),d({from:p.doneData,to:w}),d({from:[a.finally.map(B("get")),c.finally.map(B("set")),p.fail.map(B("validate"))],to:y}),d({from:m,to:P}),E&&d({from:k,to:E}),M&&d({from:y,to:M}),b&&o.on(b,(({ref:e},r)=>({ref:void 0===r?e:r}))),D?(d({from:D,to:a.prepend((()=>{}))}),o.on(D,(({ref:e},r)=>({ref:void 0===r?e:r})))):a()})),q.unsubscribe=q}y.watch((e=>console.error(e.error)));export{k as persist};
+//# sourceMappingURL=index.js.map