@subjected/react - npm Package Compare versions

Comparing version 0.2.1 to 0.2.2

cjs/index.js

+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('react');
+var operators = require('rxjs/operators');
+var core = require('@subjected/core');
+
+function useStateContainer(stateContainer) {
+    const [state, updateState] = react.useState(stateContainer.state);
+    react.useEffect(() => {
+        const subscription = stateContainer.observable.pipe(operators.skip(1)).subscribe(nextState => {
+            updateState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return state;
+}
+
+function useComputed(computedSelector) {
+    const [state, setState] = react.useState(computedSelector.state);
+    react.useEffect(() => {
+        const subscription = computedSelector.observable.pipe(operators.skip(1)).subscribe(nextState => {
+            setState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return state;
+}
+
+class MissingSelectorFunctionError extends Error {
+    constructor() {
+        super();
+        this.message =
+            'A StateContainer was passed to useSelector without a selector function, did you mean to pass one as a second argument to useSelector?';
+    }
+}
+
+function useSelector(selectorOrContainer, selectorFunc) {
+    let selector;
+    if (selectorOrContainer instanceof core.StateContainer) {
+        if (!selectorFunc) {
+            throw new MissingSelectorFunctionError();
+        }
+        selector = react.useRef(new core.Selector(selectorOrContainer, selectorFunc)).current;
+    }
+    else {
+        selector = selectorOrContainer;
+    }
+    const [state, setState] = react.useState(selector.state);
+    react.useEffect(() => {
+        const subscription = selector.observable.pipe(operators.skip(1)).subscribe(nextState => {
+            setState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return [state, selector.stateSource.values().next().value.state];
+}
+
+function usePerform(stateContainer) {
+    const perform = react.useCallback((...params) => stateContainer.perform(...params), [stateContainer]);
+    const performAsync = react.useCallback((...params) => stateContainer.performAsync(...params), [stateContainer]);
+    const performAsyncSequence = react.useCallback((...params) => stateContainer.performAsyncSequence(...params), [stateContainer]);
+    return {
+        perform,
+        performAsync,
+        performAsyncSequence,
+    };
+}
+
+function useLazyPerform(stateContainer) {
+    const perform = react.useCallback((...params) => () => stateContainer.perform(...params), [stateContainer]);
+    const performAsync = react.useCallback((...params) => () => stateContainer.performAsync(...params), [stateContainer]);
+    const performAsyncSequence = react.useCallback((...params) => () => stateContainer.performAsyncSequence(...params), [stateContainer]);
+    return {
+        perform,
+        performAsync,
+        performAsyncSequence,
+    };
+}
+
+function useResolvers(container, binding) {
+    const bindings = react.useMemo(() => {
+        return core.bindResolvers(container, binding);
+    }, [container, binding]);
+    return bindings;
+}
+
+exports.MissingSelectorFunctionError = MissingSelectorFunctionError;
+exports.useComputed = useComputed;
+exports.useLazyPerform = useLazyPerform;
+exports.usePerform = usePerform;
+exports.useResolvers = useResolvers;
+exports.useSelector = useSelector;
+exports.useStateContainer = useStateContainer;
+//# sourceMappingURL=index.js.map

cjs/index.js.map

+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

esm/index.js

+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { skip } from 'rxjs/operators';
+import { StateContainer, Selector, bindResolvers } from '@subjected/core';
+
+function useStateContainer(stateContainer) {
+    const [state, updateState] = useState(stateContainer.state);
+    useEffect(() => {
+        const subscription = stateContainer.observable.pipe(skip(1)).subscribe(nextState => {
+            updateState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return state;
+}
+
+function useComputed(computedSelector) {
+    const [state, setState] = useState(computedSelector.state);
+    useEffect(() => {
+        const subscription = computedSelector.observable.pipe(skip(1)).subscribe(nextState => {
+            setState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return state;
+}
+
+class MissingSelectorFunctionError extends Error {
+    constructor() {
+        super();
+        this.message =
+            'A StateContainer was passed to useSelector without a selector function, did you mean to pass one as a second argument to useSelector?';
+    }
+}
+
+function useSelector(selectorOrContainer, selectorFunc) {
+    let selector;
+    if (selectorOrContainer instanceof StateContainer) {
+        if (!selectorFunc) {
+            throw new MissingSelectorFunctionError();
+        }
+        selector = useRef(new Selector(selectorOrContainer, selectorFunc)).current;
+    }
+    else {
+        selector = selectorOrContainer;
+    }
+    const [state, setState] = useState(selector.state);
+    useEffect(() => {
+        const subscription = selector.observable.pipe(skip(1)).subscribe(nextState => {
+            setState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return [state, selector.stateSource.values().next().value.state];
+}
+
+function usePerform(stateContainer) {
+    const perform = useCallback((...params) => stateContainer.perform(...params), [stateContainer]);
+    const performAsync = useCallback((...params) => stateContainer.performAsync(...params), [stateContainer]);
+    const performAsyncSequence = useCallback((...params) => stateContainer.performAsyncSequence(...params), [stateContainer]);
+    return {
+        perform,
+        performAsync,
+        performAsyncSequence,
+    };
+}
+
+function useLazyPerform(stateContainer) {
+    const perform = useCallback((...params) => () => stateContainer.perform(...params), [stateContainer]);
+    const performAsync = useCallback((...params) => () => stateContainer.performAsync(...params), [stateContainer]);
+    const performAsyncSequence = useCallback((...params) => () => stateContainer.performAsyncSequence(...params), [stateContainer]);
+    return {
+        perform,
+        performAsync,
+        performAsyncSequence,
+    };
+}
+
+function useResolvers(container, binding) {
+    const bindings = useMemo(() => {
+        return bindResolvers(container, binding);
+    }, [container, binding]);
+    return bindings;
+}
+
+export { MissingSelectorFunctionError, useComputed, useLazyPerform, usePerform, useResolvers, useSelector, useStateContainer };

esm/index.mjs

+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { skip } from 'rxjs/operators';
+import { StateContainer, Selector, bindResolvers } from '@subjected/core';
+
+function useStateContainer(stateContainer) {
+    const [state, updateState] = useState(stateContainer.state);
+    useEffect(() => {
+        const subscription = stateContainer.observable.pipe(skip(1)).subscribe(nextState => {
+            updateState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return state;
+}
+
+function useComputed(computedSelector) {
+    const [state, setState] = useState(computedSelector.state);
+    useEffect(() => {
+        const subscription = computedSelector.observable.pipe(skip(1)).subscribe(nextState => {
+            setState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return state;
+}
+
+class MissingSelectorFunctionError extends Error {
+    constructor() {
+        super();
+        this.message =
+            'A StateContainer was passed to useSelector without a selector function, did you mean to pass one as a second argument to useSelector?';
+    }
+}
+
+function useSelector(selectorOrContainer, selectorFunc) {
+    let selector;
+    if (selectorOrContainer instanceof StateContainer) {
+        if (!selectorFunc) {
+            throw new MissingSelectorFunctionError();
+        }
+        selector = useRef(new Selector(selectorOrContainer, selectorFunc)).current;
+    }
+    else {
+        selector = selectorOrContainer;
+    }
+    const [state, setState] = useState(selector.state);
+    useEffect(() => {
+        const subscription = selector.observable.pipe(skip(1)).subscribe(nextState => {
+            setState(nextState);
+        });
+        return () => subscription.unsubscribe();
+    }, []);
+    return [state, selector.stateSource.values().next().value.state];
+}
+
+function usePerform(stateContainer) {
+    const perform = useCallback((...params) => stateContainer.perform(...params), [stateContainer]);
+    const performAsync = useCallback((...params) => stateContainer.performAsync(...params), [stateContainer]);
+    const performAsyncSequence = useCallback((...params) => stateContainer.performAsyncSequence(...params), [stateContainer]);
+    return {
+        perform,
+        performAsync,
+        performAsyncSequence,
+    };
+}
+
+function useLazyPerform(stateContainer) {
+    const perform = useCallback((...params) => () => stateContainer.perform(...params), [stateContainer]);
+    const performAsync = useCallback((...params) => () => stateContainer.performAsync(...params), [stateContainer]);
+    const performAsyncSequence = useCallback((...params) => () => stateContainer.performAsyncSequence(...params), [stateContainer]);
+    return {
+        perform,
+        performAsync,
+        performAsyncSequence,
+    };
+}
+
+function useResolvers(container, binding) {
+    const bindings = useMemo(() => {
+        return bindResolvers(container, binding);
+    }, [container, binding]);
+    return bindings;
+}
+
+export { MissingSelectorFunctionError, useComputed, useLazyPerform, usePerform, useResolvers, useSelector, useStateContainer };

types/errors.d.ts

+export declare class MissingSelectorFunctionError extends Error {
+    constructor();
+}

types/hooks/useComputed.d.ts

+import { ComputedSelector } from '@subjected/core';
+declare function useComputed<ComputedState>(computedSelector: ComputedSelector<ComputedState>): ComputedState;
+export default useComputed;

types/hooks/useLazyPerform.d.ts

+import { StateContainer, StateShape } from '@subjected/core';
+declare function useLazyPerform<S extends StateShape>(stateContainer: StateContainer<S>): {
+    perform: (...params: import("@subjected/core").ActionResolverFunc<S>[]) => () => S;
+    performAsync: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => () => Promise<S>;
+    performAsyncSequence: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => () => Promise<S>;
+};
+export default useLazyPerform;

types/hooks/usePerform.d.ts

+import { StateContainer, StateShape } from '@subjected/core';
+declare function usePerform<S extends StateShape>(stateContainer: StateContainer<S>): {
+    perform: (...params: import("@subjected/core").ActionResolverFunc<S>[]) => S;
+    performAsync: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => Promise<S>;
+    performAsyncSequence: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => Promise<S>;
+};
+export default usePerform;

types/hooks/useResolvers.d.ts

+import { StateContainer, StateShape, ResolverMapping, ResolverMappingBinding, SyncResolverList, SyncResolverBinding } from '@subjected/core';
+declare function useResolvers<S extends StateShape, M extends ResolverMapping<S>>(container: StateContainer<S>, binding: M): ResolverMappingBinding<S, M>;
+declare function useResolvers<S extends StateShape, M extends SyncResolverList<S>>(container: StateContainer<S>, binding: M): SyncResolverBinding<S, M>;
+export default useResolvers;

types/hooks/useSelector.d.ts

+import { StateShape, Selector, StateContainer } from '@subjected/core';
+declare function useSelector<S extends StateShape, SelectedState>(selector: Selector<S, SelectedState>): [SelectedState, S];
+declare function useSelector<S extends StateShape, SelectedState>(container: StateContainer<S>, selectorFunc: (state: S) => SelectedState): [SelectedState, S];
+export default useSelector;

types/hooks/useStateContainer.d.ts

+import { StateShape, StateContainer } from '@subjected/core';
+declare function useStateContainer<S extends StateShape>(stateContainer: StateContainer<S>): S;
+export default useStateContainer;

types/index.d.ts

+import useStateContainer from './hooks/useStateContainer';
+import useComputed from './hooks/useComputed';
+import useSelector from './hooks/useSelector';
+import usePerform from './hooks/usePerform';
+import useLazyPerform from './hooks/useLazyPerform';
+import useResolvers from './hooks/useResolvers';
+export * from './errors';
+export { useStateContainer, useComputed, useSelector, usePerform, useLazyPerform, useResolvers };

umd/index.js

+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('rxjs/operators'), require('@subjected/core')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'rxjs/operators', '@subjected/core'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SubjectedReact = {}, global.React, global._operators, global.Subjected));
+}(this, (function (exports, react, operators, core) { 'use strict';
+
+  function useStateContainer(stateContainer) {
+      const [state, updateState] = react.useState(stateContainer.state);
+      react.useEffect(() => {
+          const subscription = stateContainer.observable.pipe(operators.skip(1)).subscribe(nextState => {
+              updateState(nextState);
+          });
+          return () => subscription.unsubscribe();
+      }, []);
+      return state;
+  }
+
+  function useComputed(computedSelector) {
+      const [state, setState] = react.useState(computedSelector.state);
+      react.useEffect(() => {
+          const subscription = computedSelector.observable.pipe(operators.skip(1)).subscribe(nextState => {
+              setState(nextState);
+          });
+          return () => subscription.unsubscribe();
+      }, []);
+      return state;
+  }
+
+  class MissingSelectorFunctionError extends Error {
+      constructor() {
+          super();
+          this.message =
+              'A StateContainer was passed to useSelector without a selector function, did you mean to pass one as a second argument to useSelector?';
+      }
+  }
+
+  function useSelector(selectorOrContainer, selectorFunc) {
+      let selector;
+      if (selectorOrContainer instanceof core.StateContainer) {
+          if (!selectorFunc) {
+              throw new MissingSelectorFunctionError();
+          }
+          selector = react.useRef(new core.Selector(selectorOrContainer, selectorFunc)).current;
+      }
+      else {
+          selector = selectorOrContainer;
+      }
+      const [state, setState] = react.useState(selector.state);
+      react.useEffect(() => {
+          const subscription = selector.observable.pipe(operators.skip(1)).subscribe(nextState => {
+              setState(nextState);
+          });
+          return () => subscription.unsubscribe();
+      }, []);
+      return [state, selector.stateSource.values().next().value.state];
+  }
+
+  function usePerform(stateContainer) {
+      const perform = react.useCallback((...params) => stateContainer.perform(...params), [stateContainer]);
+      const performAsync = react.useCallback((...params) => stateContainer.performAsync(...params), [stateContainer]);
+      const performAsyncSequence = react.useCallback((...params) => stateContainer.performAsyncSequence(...params), [stateContainer]);
+      return {
+          perform,
+          performAsync,
+          performAsyncSequence,
+      };
+  }
+
+  function useLazyPerform(stateContainer) {
+      const perform = react.useCallback((...params) => () => stateContainer.perform(...params), [stateContainer]);
+      const performAsync = react.useCallback((...params) => () => stateContainer.performAsync(...params), [stateContainer]);
+      const performAsyncSequence = react.useCallback((...params) => () => stateContainer.performAsyncSequence(...params), [stateContainer]);
+      return {
+          perform,
+          performAsync,
+          performAsyncSequence,
+      };
+  }
+
+  function useResolvers(container, binding) {
+      const bindings = react.useMemo(() => {
+          return core.bindResolvers(container, binding);
+      }, [container, binding]);
+      return bindings;
+  }
+
+  exports.MissingSelectorFunctionError = MissingSelectorFunctionError;
+  exports.useComputed = useComputed;
+  exports.useLazyPerform = useLazyPerform;
+  exports.usePerform = usePerform;
+  exports.useResolvers = useResolvers;
+  exports.useSelector = useSelector;
+  exports.useStateContainer = useStateContainer;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

umd/index.min.js

+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("react"),require("rxjs/operators"),require("@subjected/core")):"function"==typeof define&&define.amd?define(["exports","react","rxjs/operators","@subjected/core"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).SubjectedReact={},e.React,e._operators,e.Subjected)}(this,(function(e,r,s,t){"use strict";class o extends Error{constructor(){super(),this.message="A StateContainer was passed to useSelector without a selector function, did you mean to pass one as a second argument to useSelector?"}}e.MissingSelectorFunctionError=o,e.useComputed=function(e){const[t,o]=r.useState(e.state);return r.useEffect((()=>{const r=e.observable.pipe(s.skip(1)).subscribe((e=>{o(e)}));return()=>r.unsubscribe()}),[]),t},e.useLazyPerform=function(e){return{perform:r.useCallback(((...r)=>()=>e.perform(...r)),[e]),performAsync:r.useCallback(((...r)=>()=>e.performAsync(...r)),[e]),performAsyncSequence:r.useCallback(((...r)=>()=>e.performAsyncSequence(...r)),[e])}},e.usePerform=function(e){return{perform:r.useCallback(((...r)=>e.perform(...r)),[e]),performAsync:r.useCallback(((...r)=>e.performAsync(...r)),[e]),performAsyncSequence:r.useCallback(((...r)=>e.performAsyncSequence(...r)),[e])}},e.useResolvers=function(e,s){return r.useMemo((()=>t.bindResolvers(e,s)),[e,s])},e.useSelector=function(e,n){let u;if(e instanceof t.StateContainer){if(!n)throw new o;u=r.useRef(new t.Selector(e,n)).current}else u=e;const[c,a]=r.useState(u.state);return r.useEffect((()=>{const e=u.observable.pipe(s.skip(1)).subscribe((e=>{a(e)}));return()=>e.unsubscribe()}),[]),[c,u.stateSource.values().next().value.state]},e.useStateContainer=function(e){const[t,o]=r.useState(e.state);return r.useEffect((()=>{const r=e.observable.pipe(s.skip(1)).subscribe((e=>{o(e)}));return()=>r.unsubscribe()}),[]),t},Object.defineProperty(e,"__esModule",{value:!0})}));

CHANGELOG.md

@@ -6,2 +6,10 @@ # Change Log
 
+## [0.2.2](https://github.com/BrandonBurrus/subjected/compare/@subjected/react@0.2.1...@subjected/react@0.2.2) (2020-10-06)
+
+**Note:** Version bump only for package @subjected/react
+
+
+
+
+
 ## [0.2.1](https://github.com/BrandonBurrus/subjected/compare/@subjected/react@0.2.0...@subjected/react@0.2.1) (2020-10-06)
@@ -8,0 +16,0 @@

package.json

 {
   "name": "@subjected/react",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "React bindings for the Subjected library",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/types/index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "unpkg": "umd/index.js",
+  "types": "types/index.d.ts",
   "author": "Brandon Burrus <[e-mail]> (https://brandonburrus.com/)",
   "license": "MIT",
   "scripts": {
-    "prebuild": "rimraf dist",
+    "prebuild": "rimraf cjs esm umd types",
     "build": "rollup -c",
@@ -21,4 +22,6 @@ "test": "jest --verbose -e --notify",
   "files": [
-    "dist",
-    "README.md"
+    "cjs",
+    "esm",
+    "umd",
+    "types"
   ],
@@ -28,3 +31,3 @@ "sideEffects": false,
     "displayName": {
-      "name": "REACT",
+      "name": "@subjected/react",
       "color": "cyanBright"
@@ -37,4 +40,3 @@ },
   "dependencies": {
-    "@babel/runtime": "^7.11.2",
-    "@subjected/core": "^0.2.1",
+    "@subjected/core": "^0.2.2",
     "react": "^16.13.1",
@@ -52,3 +54,3 @@ "rxjs": "^6.6.3"
   },
-  "gitHead": "f65afa69103b15d8cf578ef395ae7ef28573312f"
+  "gitHead": "2bc355b928d17c5bf38187f62dd2153c5b0a2630"
 }

dist/cjs/index.js

-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./hooks/useStateContainer.ts"),r=require("./hooks/useComputed.ts"),t=require("./hooks/useSelector.ts"),u=require("./hooks/usePerform.ts"),o=require("./hooks/useLazyPerform.ts"),n=require("./hooks/useResolvers.ts");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var f=s(e),i=s(r),a=s(t),l=s(u),c=s(o),d=s(n);Object.defineProperty(exports,"useStateContainer",{enumerable:!0,get:function(){return f.default}}),Object.defineProperty(exports,"useComputed",{enumerable:!0,get:function(){return i.default}}),Object.defineProperty(exports,"useSelector",{enumerable:!0,get:function(){return a.default}}),Object.defineProperty(exports,"usePerform",{enumerable:!0,get:function(){return l.default}}),Object.defineProperty(exports,"useLazyPerform",{enumerable:!0,get:function(){return c.default}}),Object.defineProperty(exports,"useResolvers",{enumerable:!0,get:function(){return d.default}});

dist/esm/index.js

-export{default as useStateContainer}from"./hooks/useStateContainer.ts";export{default as useComputed}from"./hooks/useComputed.ts";export{default as useSelector}from"./hooks/useSelector.ts";export{default as usePerform}from"./hooks/usePerform.ts";export{default as useLazyPerform}from"./hooks/useLazyPerform.ts";export{default as useResolvers}from"./hooks/useResolvers.ts";

dist/types/errors.d.ts

-export declare class MissingSelectorFunctionError extends Error {
-    constructor();
-}

dist/types/hooks/useComputed.d.ts

-import { ComputedSelector } from '@subjected/core';
-declare function useComputed<ComputedState>(computedSelector: ComputedSelector<ComputedState>): ComputedState;
-export default useComputed;

dist/types/hooks/useLazyPerform.d.ts

-import { StateContainer, StateShape } from '@subjected/core';
-declare function useLazyPerform<S extends StateShape>(stateContainer: StateContainer<S>): {
-    perform: (...params: import("@subjected/core").ActionResolverFunc<S>[]) => () => S;
-    performAsync: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => () => Promise<S>;
-    performAsyncSequence: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => () => Promise<S>;
-};
-export default useLazyPerform;

dist/types/hooks/usePerform.d.ts

-import { StateContainer, StateShape } from '@subjected/core';
-declare function usePerform<S extends StateShape>(stateContainer: StateContainer<S>): {
-    perform: (...params: import("@subjected/core").ActionResolverFunc<S>[]) => S;
-    performAsync: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => Promise<S>;
-    performAsyncSequence: (...params: import("@subjected/core").AsyncActionResolverFunc<S>[]) => Promise<S>;
-};
-export default usePerform;

dist/types/hooks/useResolvers.d.ts

-import { StateContainer, StateShape, ResolverMapping, ResolverMappingBinding, SyncResolverList, SyncResolverBinding } from '@subjected/core';
-declare function useResolvers<S extends StateShape, M extends ResolverMapping<S>>(container: StateContainer<S>, binding: M): ResolverMappingBinding<S, M>;
-declare function useResolvers<S extends StateShape, M extends SyncResolverList<S>>(container: StateContainer<S>, binding: M): SyncResolverBinding<S, M>;
-export default useResolvers;

dist/types/hooks/useSelector.d.ts

-import { StateShape, Selector, StateContainer } from '@subjected/core';
-declare function useSelector<S extends StateShape, SelectedState>(selector: Selector<S, SelectedState>): [SelectedState, S];
-declare function useSelector<S extends StateShape, SelectedState>(container: StateContainer<S>, selectorFunc: (state: S) => SelectedState): [SelectedState, S];
-export default useSelector;

dist/types/hooks/useStateContainer.d.ts

-import { StateShape, StateContainer } from '@subjected/core';
-declare function useStateContainer<S extends StateShape>(stateContainer: StateContainer<S>): S;
-export default useStateContainer;

dist/types/index.d.ts

-import useStateContainer from './hooks/useStateContainer';
-import useComputed from './hooks/useComputed';
-import useSelector from './hooks/useSelector';
-import usePerform from './hooks/usePerform';
-import useLazyPerform from './hooks/useLazyPerform';
-import useResolvers from './hooks/useResolvers';
-export { useStateContainer, useComputed, useSelector, usePerform, useLazyPerform, useResolvers };

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Fixed alerts

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Improved metrics

Total package byte prevSize

24919

153.5%

Dependency count

3

-25%

Number of package files

18

28.57%

Lines of code

374

750%

Worsened metrics

Number of medium supply chain risk alerts

1

Infinity%

Dependency changes

• - Removed

  @babel/runtime@^7.11.2

• - Removed

  @babel/runtime@7.29.7
  (transitive)

• Updated

  @subjected/core@^0.2.2