@vanyamate/sec 0.1.5 → 0.2.1

package/README.md

@@ -2,23 +2,224 @@
 
 Tiny state manager
 
+*It may change in the future*
+
+For react/preact/svelte/qwik/solid
+
 ```
 npm i @vanyamate/sec
 ```
 
+with
+
+```
+npm i @vanyamate/sec-react
+npm i @vanyamate/sec-solidjs
+```
+
+For vue (like old 0.1.5 version)
+
+```
+npm i @vanyamate/sec-vue
+```
+
+## Documentation:
+
+### effect
+
+Effect is a wrapper around action. Action is any asynchronous action. Store subscribes to effect. Effect can be called
+from anywhere in the code.
+
+Effect takes one value - action.
+
+```typescript
+
+const loginAction = async function (loginData: LoginData): Promise<UserData> {
+    // login action.. (fetch, etc.)
+    return fetch(`${ __API__ }/v1/auth`, {
+        method: 'POST',
+        body  : JSON.stringify(loginData),
+    })
+        .then((response) => response.json());
+};
+
+const loginEffect = effect(loginAction);
+
+// Anywhere in code
+loginEffect({ login: 'VanyaMate', password: 'qwerty12345' });
+
+```
+
+### marker
+
+markers are needed to enable/disable the store. markers also subscribe to the effect. marker takes 1 value of the
+subscription type. `afterAll`, `beforeAll` or `undefined`
+
+The marker has an api.
+
+- `on` - subscribe to effect. takes 2 parameters. type (`onBefore`, `onSuccess`, `onError` and `onFinally`) and effect.
+  after effect is triggered, all listeners that were set via `subscribe` are triggered.
+- `subscribe` - adds a handler that will be triggered when any effect of the required type is executed.
+
 ```typescript
-import { store, effect, combine } from './index';
 
+const loginMarker  = marker('beforeAll').on('onSuccess', loginEffect);
+const logoutMarker = marker('afterAll').on('onSuccess', logoutEffect);
+
+```
+
+order of execution: 'beforeAll' -> undefined -> 'afterAll' (within one type (for example `onSuccess`))
+
+### to
+
+Just helper. Returns a function that returns the passed value.
+
+```typescript
+
+to(123); // Return () => 123
+
+```
+
+```typescript
+// before    .on(logoutEffect, 'onSuccess', () => []);
+// after     .on(logoutEffect, 'onSuccess', to([]));
+```
+
+### pending
+
+Just helper. wrapper over store. returns a bool value and is used to create a pending-store.
+
+```typescript
+/**
+ *
+ * instead of
+ * const postsIsPending = store<boolean>(false)
+ *  .on(getPostsForUser, 'onBefore', () => true)
+ *  .on(getPostsForUser, 'onFinally', () => false)
+ *  .on(createPostEffect, 'onBefore', () => true)
+ *  .on(createPostEffect, 'onFinally', () => false);
+ *
+ */
+
+const postsIsPending = pending([
+    getPostsForUser,
+    createPostEffect,
+]);
+```
+
+### store
+
+Store stores data and subscribes to effect.
+
+When initializing, the store takes 2 values. The first value is the initialization data. The second value is optional -
+enable/disable. When disabled, the store will not be updated.
+
+The store has an api.
+
+- `on` - subscription to effect. takes 3 parameters. effect, type (`onBefore`, `onSuccess`, `onError` and `onFinally`)
+  and handler. handler has signature depending on type. handler is a function that takes 2 parameters and should always
+  return value of the type that is currently specified in store. first parameter is current state of store, and the
+  second is an object and depends on subscription type. for `onBefore` it is only `{ args }` where `args` is an array of
+  arguments of the function that we passed to effect. for `onSuccess` it is `{ args, result }` where `result` is result
+  of `Promise` execution. for `onError` `{ args, error }` where `error` is `unknown`. and for `onFinally` it is
+  `{ args }`.
+    - `onBefore` - `(state, { args }) => state`
+    - `onSuccess` - `(state, { args, result }) => state`
+    - `onError` - `(state, { args, error }) => state`
+    - `onFinally` - `(state, { args }) => state`
+- `get` - get current store value.
+- `set` - set new value
+- `subscribe` - receives a function as input that will be executed when the store changes and returns an unsubscribe
+  function.
+- `enableOn` - receives a marker that, when triggered, will enable the store.
+- `disableOn` - receives a marker that, when triggered, will disable the store.
+
+```typescript
+
+const authIsPending = store<boolean>(false)
+    .on(loginEffect, 'onBefore', () => true)
+    .on(loginEffect, 'onFinally', to(false)); // instead of () => false
+
+const authError = store<Error | null>(null)
+    .on(loginEffect, 'onError', (_, { error }) => {
+        // For example
+        if (error instanceof Error) {
+            return error;
+        } else {
+            return new Error(error);
+        }
+    });
+
+const authData = store<UserData | null>(null)
+    .on(loginEffect, 'onSuccess', (_, { result }) => result)
+    .on(logoutEffect, 'onSuccess', () => null);
+
+const postsForUserId = store<number>(0)
+    .enableOn(loginMarker)
+    .disableOn(logoutMarker)
+    .on(getPostsForUser, 'onBefore', (_, { args: [ id ] }) => id);
+
+/**
+ *
+ * instead of
+ * const postsIsPending = store<boolean>(false)
+ *  .on(getPostsForUser, 'onBefore', () => true)
+ *  .on(getPostsForUser, 'onFinally', () => false)
+ *  .on(createPostEffect, 'onBefore', () => true)
+ *  .on(createPostEffect, 'onFinally', () => false);
+ *
+ */
+
+const postsIsPending = pending([
+    getPostsForUser,
+    createPostEffect,
+]);
+
+const posts = store<Array<Post>>([])
+    .enableOn(loginMarker)
+    .disableOn(logoutMarker)
+    .on(getPostsForUser, 'onSuccess', (state, { result, args: [ userId ] }) => {
+        if (postsForUserId.get() === userId) {
+            return state.concat(result);
+        } else {
+            return result;
+        }
+    })
+    .on(createPostEffect, 'onSuccess', (state, { result, args: [ userId ] }) => {
+        if (postsForUserId.get() === userId) {
+            return state.concat(result);
+        } else {
+            return state;
+        }
+    })
+    .on(logoutEffect, 'onSuccess', to([]));
+```
+
+### Types
+
+#### StoreHandlerMap
+
+instead of writing everything in `.on` - you can take out the handlers separately, setting the required type for them.
+`StoreHandlerMap` is a generic and takes 2 parameters, and then the type is selected.
+first is type of store value. second is action signature. and then select type of subscribe.
+
+```
+StoreHandlerMap<number, typeof getRandomId>['onSuccess']
+```
+
+```typescript
+// Example:
 
-const sum = async (a, b) => a + b;
+const getRandomId = async function () {
+    return { id: Math.random() };
+};
 
-// Create effect
-const sumEffect = effect(sum);
+const getRandomEffect = effect(getRandomId);
 
-// Create stores
-const allSums = store(0).on(sumEffect, 'onSuccess', (state, { result }) => state + result);
-const lastSum = store(0).on(sumEffect, 'onSuccess', (_, { result }) => result);
+const handler: StoreHandlerMap<number, typeof getRandomId>['onSuccess'] = function (state, { result }) {
+    return result.id;
+};
 
-// Create combine
-const bothSum = combine([ allSums, lastSum ], (...args) => args.reduce((acc, item) => acc + item.get(), 0));
+const num = store<number>(0)
+    .on(getRandomEffect, 'onSuccess', handler);
 ```

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=function(t,o){t&&o()},a=function(t,o=!0){const c={on:(n,l,s)=>(l==="onBefore"?n.onBefore((...e)=>u(o,()=>t=s(t,{args:e}))):l==="onSuccess"?n.onSuccess((e,...r)=>u(o,()=>t=s(t,{result:e,args:r}))):l==="onError"?n.onError((e,...r)=>u(o,()=>t=s(t,{error:e,args:r}))):n.onFinally((...e)=>u(o,()=>t=s(t,{args:e}))),c),get(){return t},set(n){t=n},subscribe(n){return()=>{}},enableOn(n){return n.subscribe(()=>o=!0),c},disableOn(n){return n.subscribe(()=>o=!1),c}};return c},i=function(){return{afterAll:[],beforeAll:[],other:[]}},b=function(t){const o=i(),c=i(),n=i(),l=i(),s=async function(...e){return o.beforeAll.forEach(r=>r(...e)),o.other.forEach(r=>r(...e)),o.afterAll.forEach(r=>r(...e)),t(...e).then(r=>(c.beforeAll.forEach(f=>f(r,...e)),c.other.forEach(f=>f(r,...e)),c.afterAll.forEach(f=>f(r,...e)),r)).catch(r=>{throw n.beforeAll.forEach(f=>f(r,...e)),n.other.forEach(f=>f(r,...e)),n.afterAll.forEach(f=>f(r,...e)),r}).finally(()=>{l.beforeAll.forEach(r=>r(...e)),l.other.forEach(r=>r(...e)),l.afterAll.forEach(r=>r(...e))})};return s.onBefore=(e,r)=>{switch(r){case"beforeAll":o.beforeAll.push(e);break;case"afterAll":o.afterAll.push(e);break;default:o.other.push(e)}},s.onSuccess=(e,r)=>{switch(r){case"beforeAll":c.beforeAll.push(e);break;case"afterAll":c.afterAll.push(e);break;default:c.other.push(e)}},s.onError=(e,r)=>{switch(r){case"beforeAll":n.beforeAll.push(e);break;case"afterAll":n.afterAll.push(e);break;default:n.other.push(e)}},s.onFinally=(e,r)=>{switch(r){case"beforeAll":l.beforeAll.push(e);break;case"afterAll":l.afterAll.push(e);break;default:l.other.push(e)}},s},A=function(t,o,c=!0){let n=o(...t);const l=[];t.forEach(e=>{e.subscribe(()=>{u(c,()=>{n=o(...t),l.forEach(r=>r(n))})})});const s={on:()=>{throw new Error("Cannot call 'on' on combined store")},get(){return n},set(){throw new Error("Cannot call 'set' on combined store")},subscribe(e){return l.push(e),()=>{const r=l.indexOf(e);~r&&l.splice(r,1)}},enableOn(e){return e.subscribe(()=>c=!1),s},disableOn(e){return e.subscribe(()=>c=!0),s}};return s},E=function(t){const o=[],c={on:(n,l)=>(n==="onBefore"?l.onBefore(()=>o.forEach(s=>s()),t):n==="onSuccess"?l.onSuccess(()=>o.forEach(s=>s()),t):n==="onError"?l.onError(()=>o.forEach(s=>s()),t):l.onFinally(()=>o.forEach(s=>s()),t),c),subscribe:n=>{o.push(n)}};return c},h=function(t){return()=>t},p=function(t){const o=a(!1);return t.forEach(c=>{o.on(c,"onBefore",h(!0)),o.on(c,"onFinally",h(!1))}),o};exports.combine=A;exports.effect=b;exports.enableCheck=u;exports.marker=E;exports.pending=p;exports.store=a;exports.to=h;

package/dist/index.d.ts

@@ -1,29 +1,88 @@
-export type EffectFunction<Args extends any[], Result> = (...args: Args) => Promise<Result>;
-export type EffectEvent = 'onBefore' | 'onSuccess' | 'onError' | 'onFinally';
-export type Effect<Args extends any[], Result> = {
-    (...args: Args): Promise<Result>;
-    onSuccess: (callback: (result: Result, ...args: Args) => void) => void;
-    onError: (callback: (error: unknown, ...args: Args) => void) => void;
-    onFinally: (callback: (...args: Args) => void) => void;
-    onBefore: (callback: (...args: Args) => void) => void;
-};
-export type Listener<State> = (state: State) => void;
-export type Payload<Result, Args> = {
-    result?: Result;
-    error?: unknown;
-    args: Args;
-};
-export type Handler<State, Args, Result> = (state: State, payload: Payload<Result, Args>) => State;
-export declare function effect<Args extends any[], Result>(fn: EffectFunction<Args, Result>): Effect<Args, Result>;
-export type Store<State> = {
-    get: () => State;
-    set: (newState: State) => void;
-    on: <Args extends any[], Result>(effect: Effect<Args, Result>, event: EffectEvent, handler: Handler<State, Args, Result>) => Store<State>;
-    subscribe: (listener: Listener<State>) => () => void;
-};
-export declare function store<State>(initialState: State): Store<State>;
-export declare function combine<States extends any[], Result>(stores: {
-    [K in keyof States]: Store<States[K]>;
-}, callback: (...stores: {
-    [K in keyof States]: Store<States[K]>;
-}) => Result): Store<Result>;
+export declare const combine: <State, States extends Array<any>>(stores: { [Index in keyof States]: Store<States[Index]>; }, callback: (...stores: { [K in keyof States]: Store<States[K]>; }) => State, enabled?: boolean) => Store<State>;
+
+export declare type Effect<AsyncAction extends EffectAction> = {
+    (...args: Parameters<AsyncAction>): Promise<Awaited<ReturnType<AsyncAction>>>;
+    onSuccess: (callback: EffectSuccessCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
+    onError: (callback: EffectErrorCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
+    onBefore: (callback: EffectBeforeCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
+    onFinally: (callback: EffectFinallyCallback<AsyncAction>, position?: EffectSubscribePosition) => void;
+};
+
+export declare const effect: <Action extends EffectAction>(action: Action) => Effect<Action>;
+
+export declare type EffectAction = (...args: Array<any>) => Promise<any>;
+
+export declare type EffectBeforeCallback<AsyncAction extends EffectAction> = (...args: Parameters<AsyncAction>) => void;
+
+export declare type EffectCallbackList<Type> = {
+    beforeAll: Array<Type>;
+    afterAll: Array<Type>;
+    other: Array<Type>;
+};
+
+export declare type EffectErrorCallback<AsyncAction extends EffectAction> = (error: unknown, ...args: Parameters<AsyncAction>) => void;
+
+export declare type EffectFinallyCallback<AsyncAction extends EffectAction> = (...args: Parameters<AsyncAction>) => void;
+
+export declare type EffectSubscribePosition = 'beforeAll' | 'afterAll' | undefined;
+
+export declare type EffectSuccessCallback<AsyncAction extends EffectAction> = (result: Awaited<ReturnType<AsyncAction>>, ...args: Parameters<AsyncAction>) => void;
+
+export declare const enableCheck: (enabled: boolean, callback: () => void) => void;
+
+export declare type Marker<State> = {
+    on: <Action extends EffectAction>(event: keyof StoreHandlerMap<State, Action>, effect: Effect<Action>, position?: EffectSubscribePosition) => Marker<State>;
+    subscribe: (listener: MarkerListener) => void;
+};
+
+export declare const marker: <State>(position?: EffectSubscribePosition) => Marker<State>;
+
+export declare type MarkerListener = () => void;
+
+export declare const pending: (effects: Array<Effect<any>>) => Store<boolean>;
+
+export declare type Store<State> = {
+    on: StoreEffectSubscribe<State>;
+    enableOn: StoreMarkerSubscribe<State>;
+    disableOn: StoreMarkerSubscribe<State>;
+    get: () => State;
+    set: (data: State) => void;
+    subscribe: (listener: StoreListener<State>) => () => void;
+};
+
+export declare const store: <State extends any>(state: State, enabled?: boolean) => Store<State>;
+
+export declare type StoreEffectSubscribe<State> = <Action extends EffectAction, Event extends keyof StoreHandlerMap<State, Action>>(effect: Effect<Action>, event: Event, handler: StoreHandlerMap<State, Action>[Event]) => Store<State>;
+
+export declare type StoreHandlerMap<State, Action extends EffectAction> = {
+    onBefore: StoreOnBeforeHandler<State, Action>;
+    onSuccess: StoreOnSuccessHandler<State, Action>;
+    onError: StoreOnErrorHandler<State, Action>;
+    onFinally: StoreOnFinallyHandler<State, Action>;
+};
+
+export declare type StoreListener<State> = (state: State) => void;
+
+export declare type StoreMarkerSubscribe<State> = (marker: Marker<State>) => Store<State>;
+
+export declare type StoreOnBeforeHandler<State, Action extends EffectAction> = (state: State, data: {
+    args: Parameters<Action>;
+}) => State;
+
+export declare type StoreOnErrorHandler<State, Action extends EffectAction> = (state: State, data: {
+    args: Parameters<Action>;
+    error: unknown;
+}) => State;
+
+export declare type StoreOnFinallyHandler<State, Action extends EffectAction> = (state: State, data: {
+    args: Parameters<Action>;
+}) => State;
+
+export declare type StoreOnSuccessHandler<State, Action extends EffectAction> = (state: State, data: {
+    args: Parameters<Action>;
+    result: Awaited<ReturnType<Action>>;
+}) => State;
+
+export declare const to: <State>(state: State) => () => State;
+
+export { }

package/dist/index.js

@@ -1,109 +1,167 @@
-export function effect(fn) {
-    let beforeListeners = [];
-    let successListeners = [];
-    let errorListeners = [];
-    let finallyListeners = [];
-    const wrappedEffect = async (...args) => {
-        beforeListeners.forEach(listener => listener(...args));
-        try {
-            const result = await fn(...args);
-            successListeners.forEach(listener => listener(result, ...args));
-            return result;
-        }
-        catch (error) {
-            errorListeners.forEach(listener => listener(error, ...args));
-            throw error;
-        }
-        finally {
-            finallyListeners.forEach(listener => listener(...args));
-        }
-    };
-    wrappedEffect.onBefore = (callback) => {
-        beforeListeners.push(callback);
-    };
-    wrappedEffect.onSuccess = (callback) => {
-        successListeners.push(callback);
-    };
-    wrappedEffect.onError = (callback) => {
-        errorListeners.push(callback);
-    };
-    wrappedEffect.onFinally = (callback) => {
-        finallyListeners.push(callback);
-    };
-    return wrappedEffect;
-}
-export function store(initialState) {
-    let state = initialState;
-    let listeners = [];
-    const get = () => state;
-    const set = (newState) => {
-        state = newState;
-        listeners.forEach(listener => listener(state));
-    };
-    const on = (effect, event, handler) => {
-        const callback = (payload) => set(handler(state, payload));
-        if (event === 'onBefore') {
-            effect.onBefore((...args) => callback({ args }));
-        }
-        else if (event === 'onSuccess') {
-            effect.onSuccess((result, ...args) => callback({
-                result,
-                args,
-            }));
-        }
-        else if (event === 'onError') {
-            effect.onError((error, ...args) => callback({ error, args }));
-        }
-        else if (event === 'onFinally') {
-            effect.onFinally((...args) => callback({ args }));
-        }
-        return storeApi;
-    };
-    const subscribe = (listener) => {
-        listeners.push(listener);
-        return () => {
-            const index = listeners.indexOf(listener);
-            if (index !== -1) {
-                listeners.splice(index, 1);
-            }
-        };
-    };
-    const storeApi = {
-        get,
-        set,
-        on,
-        subscribe,
-    };
-    return storeApi;
-}
-export function combine(stores, callback) {
-    let combinedState = callback(...stores);
-    stores.forEach((store) => {
-        store.subscribe(() => {
-            combinedState = callback(...stores);
-            listeners.forEach(listener => listener(combinedState));
-        });
+const u = function(s, o) {
+  s && o();
+}, a = function(s, o = !0) {
+  const c = {
+    on: (n, f, t) => (f === "onBefore" ? n.onBefore(
+      (...r) => u(
+        o,
+        () => s = t(s, { args: r })
+      )
+    ) : f === "onSuccess" ? n.onSuccess(
+      (r, ...e) => u(
+        o,
+        () => s = t(s, {
+          result: r,
+          args: e
+        })
+      )
+    ) : f === "onError" ? n.onError(
+      (r, ...e) => u(
+        o,
+        () => s = t(s, {
+          error: r,
+          args: e
+        })
+      )
+    ) : n.onFinally(
+      (...r) => u(
+        o,
+        () => s = t(s, { args: r })
+      )
+    ), c),
+    get() {
+      return s;
+    },
+    set(n) {
+      s = n;
+    },
+    subscribe(n) {
+      return () => {
+      };
+    },
+    enableOn(n) {
+      return n.subscribe(() => o = !0), c;
+    },
+    disableOn(n) {
+      return n.subscribe(() => o = !1), c;
+    }
+  };
+  return c;
+}, h = function() {
+  return {
+    afterAll: [],
+    beforeAll: [],
+    other: []
+  };
+}, b = function(s) {
+  const o = h(), c = h(), n = h(), f = h(), t = async function(...r) {
+    return o.beforeAll.forEach((e) => e(...r)), o.other.forEach((e) => e(...r)), o.afterAll.forEach((e) => e(...r)), s(...r).then((e) => (c.beforeAll.forEach((l) => l(e, ...r)), c.other.forEach((l) => l(e, ...r)), c.afterAll.forEach((l) => l(e, ...r)), e)).catch((e) => {
+      throw n.beforeAll.forEach((l) => l(e, ...r)), n.other.forEach((l) => l(e, ...r)), n.afterAll.forEach((l) => l(e, ...r)), e;
+    }).finally(() => {
+      f.beforeAll.forEach((e) => e(...r)), f.other.forEach((e) => e(...r)), f.afterAll.forEach((e) => e(...r));
     });
-    const listeners = [];
-    const get = () => combinedState;
-    const subscribe = (listener) => {
-        listeners.push(listener);
-        return () => {
-            const index = listeners.indexOf(listener);
-            if (index !== -1) {
-                listeners.splice(index, 1);
-            }
-        };
-    };
-    const storeApi = {
-        get,
-        set: () => {
-            throw new Error('Cannot call \'set\' on combined store');
-        },
-        on: () => {
-            throw new Error('Cannot call \'on\' on combined store');
-        },
-        subscribe,
-    };
-    return storeApi;
-}
+  };
+  return t.onBefore = (r, e) => {
+    switch (e) {
+      case "beforeAll":
+        o.beforeAll.push(r);
+        break;
+      case "afterAll":
+        o.afterAll.push(r);
+        break;
+      default:
+        o.other.push(r);
+    }
+  }, t.onSuccess = (r, e) => {
+    switch (e) {
+      case "beforeAll":
+        c.beforeAll.push(r);
+        break;
+      case "afterAll":
+        c.afterAll.push(r);
+        break;
+      default:
+        c.other.push(r);
+    }
+  }, t.onError = (r, e) => {
+    switch (e) {
+      case "beforeAll":
+        n.beforeAll.push(r);
+        break;
+      case "afterAll":
+        n.afterAll.push(r);
+        break;
+      default:
+        n.other.push(r);
+    }
+  }, t.onFinally = (r, e) => {
+    switch (e) {
+      case "beforeAll":
+        f.beforeAll.push(r);
+        break;
+      case "afterAll":
+        f.afterAll.push(r);
+        break;
+      default:
+        f.other.push(r);
+    }
+  }, t;
+}, A = function(s, o, c = !0) {
+  let n = o(...s);
+  const f = [];
+  s.forEach((r) => {
+    r.subscribe(() => {
+      u(c, () => {
+        n = o(...s), f.forEach((e) => e(n));
+      });
+    });
+  });
+  const t = {
+    on: () => {
+      throw new Error("Cannot call 'on' on combined store");
+    },
+    get() {
+      return n;
+    },
+    set() {
+      throw new Error("Cannot call 'set' on combined store");
+    },
+    subscribe(r) {
+      return f.push(r), () => {
+        const e = f.indexOf(r);
+        ~e && f.splice(e, 1);
+      };
+    },
+    enableOn(r) {
+      return r.subscribe(() => c = !1), t;
+    },
+    disableOn(r) {
+      return r.subscribe(() => c = !0), t;
+    }
+  };
+  return t;
+}, E = function(s) {
+  const o = [], c = {
+    on: (n, f) => (n === "onBefore" ? f.onBefore(() => o.forEach((t) => t()), s) : n === "onSuccess" ? f.onSuccess(() => o.forEach((t) => t()), s) : n === "onError" ? f.onError(() => o.forEach((t) => t()), s) : f.onFinally(() => o.forEach((t) => t()), s), c),
+    subscribe: (n) => {
+      o.push(n);
+    }
+  };
+  return c;
+}, i = function(s) {
+  return () => s;
+}, p = function(s) {
+  const o = a(!1);
+  return s.forEach((c) => {
+    o.on(c, "onBefore", i(!0)), o.on(c, "onFinally", i(!1));
+  }), o;
+};
+export {
+  A as combine,
+  b as effect,
+  u as enableCheck,
+  E as marker,
+  p as pending,
+  a as store,
+  i as to
+};