@blac/react 0.0.29 → 0.0.40

package/babel.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  presets: [
+    ['@babel/env', { modules: false }],
+    '@babel/preset-typescript',
+    '@babel/preset-react',
+  ],
+  plugins: ['@babel/plugin-proposal-decorators'],
+};

package/dev.ts

@@ -0,0 +1,45 @@
+// bun runtime
+
+// watch for any changes in ./src and run `npm run build` if any changes are detected
+
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+
+const srcDir = path.join(__dirname, 'src');
+let building = false;
+
+const build = () => {
+  console.log('Building...');
+  exec('npm run build', (err, stdout, stderr) => {
+    if (err) {
+      console.error(err);
+      building = false;
+      return;
+    }
+    console.log(stdout);
+    console.log(stderr);
+    building = false;
+  });
+};
+
+const watch = () => {
+  console.log('Watching for changes...');
+  fs.watch(srcDir, { recursive: true }, (eventType, filename) => {
+  if (building) {
+    return;
+  }
+  building = true;
+    console.log(`Change detected in ${filename}`);
+    build();
+  });
+};
+
+const main = () => {
+  build();
+  watch();
+};
+
+main();
+
+

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@blac/react",
-  "version": "0.0.29",
+  "version": "0.0.40",
   "license": "MIT",
-  "main": "index.cjs.js",
-  "module": "index.es.js",
-  "typings": "src/index.d.ts",
-  "types": "src/index.d.ts",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "typings": "src/index.ts",
+  "types": "src/index.ts",
   "keywords": [
     "react",
     "typescript",
@@ -28,9 +28,9 @@
     "blac": "*"
   },
   "devDependencies": {
-    "vite-plugin-dts": "^3.7.1",
-    "@types/react": "^18.2.48",
+    "@types/react": "^18.2.69",
     "react": "^18.2.0",
-    "vitest": "^1.2.1"
+    "vite-plugin-dts": "^3.7.3",
+    "vitest": "^1.4.0"
   }
-}
+}

package/publish.ts

@@ -0,0 +1,45 @@
+// Run with Bun
+
+const packageJsonConfig = {
+  main: 'index.cjs.js',
+  module: 'index.es.js',
+  typings: 'src/index.d.ts',
+  types: 'src/index.d.ts',
+};
+
+const filesToCopy = ['README.md', '.npmignore'];
+const outputDir = 'dist';
+
+(async () => {
+  // copy files to outputDir
+  for (const file of filesToCopy) {
+    const input = Bun.file(file);
+    const output = Bun.file(`${outputDir}/${file}`);
+    await Bun.write(output, input);
+  }
+
+  // update package.json
+  const packageJson = Bun.file(`package.json`);
+  const content = await packageJson.text();
+  const json = JSON.parse(content);
+
+  // patch version
+  const currentVersion = json.version;
+  const versionParts = currentVersion.split('.');
+  versionParts[2] = Number(versionParts[2]) + 1;
+  const newVersion = versionParts.join('.');
+
+  // update package.json version
+  json.version = newVersion;
+  await Bun.write(packageJson, JSON.stringify(json, null, 2));
+
+  // write package.json in outputDir for publishing
+  const publishContent = JSON.stringify(
+    { ...json, ...packageJsonConfig },
+    null,
+    2,
+  );
+  await Bun.write(`${outputDir}/package.json`, publishContent);
+
+  console.log('Files Copied to dist and modified');
+})();

package/src/externalBlocStore.ts

@@ -0,0 +1,57 @@
+import { BlocBase, BlocGeneric, InferStateFromGeneric } from 'blac';
+
+export interface ExternalStore<
+  B extends BlocGeneric<any, any>,
+  S extends InferStateFromGeneric<B>,
+> {
+  subscribe: (onStoreChange: () => void) => () => void;
+  getSnapshot: () => S;
+  getServerSnapshot?: () => S;
+}
+
+const externalBlocStore = <
+  B extends BlocGeneric<any, any>,
+  S extends InferStateFromGeneric<B>,
+>(
+  bloc: B,
+  dependencyArray: (state: S) => unknown[],
+): ExternalStore<B, S> => {
+  let lastDependencyCheck = dependencyArray(bloc.state);
+
+  return {
+    subscribe: (listener: () => void) => {
+      const unSub = bloc.addSubscriber((data) => {
+        try {
+          const newDependencyCheck = dependencyArray(data) ?? [];
+
+          let allEqual = true;
+          for (let i = 0; i < newDependencyCheck.length; i++) {
+            if (newDependencyCheck[i] !== lastDependencyCheck[i]) {
+              allEqual = false;
+              break;
+            }
+          }
+
+          if (!allEqual) {
+            lastDependencyCheck = newDependencyCheck;
+            listener();
+          }
+        } catch (e) {
+          console.error({
+            e,
+            bloc,
+            dependencyArray,
+            lastDependencyCheck,
+          });
+        }
+      });
+      return () => {
+        unSub();
+      };
+    },
+    getSnapshot: (): S => bloc.state,
+    getServerSnapshot: (): S => bloc.state,
+  };
+};
+
+export default externalBlocStore;

package/src/{index.d.ts → index.ts}

@@ -1,3 +1,4 @@
 import externalBlocStore from './externalBlocStore';
 import useBloc from './useBloc';
+
 export { externalBlocStore, useBloc };

package/src/useBloc.tsx

@@ -0,0 +1,130 @@
+import {
+  Blac,
+  BlocBase,
+  BlocConstructor,
+  BlocGeneric,
+  BlocInstanceId,
+  BlocProps,
+  CubitPropsType,
+  InferStateFromGeneric,
+  ValueType,
+} from 'blac';
+import { useEffect, useId, useMemo, useSyncExternalStore } from 'react';
+import externalBlocStore from './externalBlocStore';
+
+// export type BlocHookData<B extends BlocBase<S>, S> = [
+//   value: ValueType<B>,
+//   instance: B,
+// ];
+
+type HookTypes<
+  B extends BlocConstructor<BlocGeneric<S, A>>,
+  S = any,
+  A = any,
+> = [InferStateFromGeneric<InstanceType<B>>, InstanceType<B>];
+
+// type BlocHookData<B extends BlocBase<S>, S> = [S, InstanceType<B>]; // B is the bloc class, S is the state of the bloc
+// type UseBlocClassResult<B, S> = BlocHookData<B, S>;
+
+export type BlocHookDependencyArrayFn<B extends BlocGeneric<any, any>> = (
+  state: InferStateFromGeneric<B>,
+) => unknown[];
+
+export interface BlocHookOptions<B extends BlocGeneric<any, any>> {
+  id?: string;
+  dependencySelector?: BlocHookDependencyArrayFn<B>;
+  props?: CubitPropsType<B>;
+}
+
+export class UseBlocClass {
+  // static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(
+  //   bloc: B,
+  // ): BlocHookData<InstanceType<B>, S> {
+  // static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(
+  //   bloc: B,
+  //   depsSelector: BlocHookDependencyArrayFn<InstanceType<B>, S>,
+  // ): BlocHookData<InstanceType<B>, S>;
+  // static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(
+  //   bloc: B,
+  //   instanceId: string,
+  // ): BlocHookData<InstanceType<B>, S>;
+  // static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(
+  //   bloc: B,
+  //   options?:
+  //     | BlocHookOptions<InstanceType<B>, S>
+  //     | BlocHookDependencyArrayFn<InstanceType<B>, S>
+  //     | BlocInstanceId,
+  // ): BlocHookData<InstanceType<B>, S> {
+
+  // constructor, no options
+  static useBloc<
+    B extends BlocConstructor<BlocGeneric<S, A>>,
+    S = any,
+    A = any,
+  >(bloc: B, options?: BlocHookOptions<InstanceType<B>>): HookTypes<B> {
+    const rid = useId();
+    // default options
+    let dependencyArray: BlocHookDependencyArrayFn<InstanceType<B>> = (
+      state: InferStateFromGeneric<B>,
+    ) => [state];
+    let blocId: BlocInstanceId | undefined;
+    let props: BlocProps | undefined;
+
+    // parse options
+
+    // if options is a function, its a dependencySelector
+    // if (typeof options === 'function') {
+    //   dependencyArray = options;
+    // }
+    //
+    // if options is a string its an ID
+    // if (typeof options === 'string') {
+    //   blocId = options;
+    // }
+
+    if (typeof options === 'object') {
+      dependencyArray = options.dependencySelector ?? dependencyArray;
+      blocId = options.id;
+      props = options.props ?? props;
+    }
+
+    const base = bloc as unknown as BlocBase<S>;
+    const isIsolated = base.isolated;
+    if (isIsolated) {
+      blocId = rid;
+    }
+
+    const resolvedBloc = Blac.getInstance().getBloc(bloc, {
+      id: blocId,
+      props,
+      reconnect: false,
+    }) as InstanceType<B>;
+
+    if (!resolvedBloc) {
+      throw new Error(`useBloc: could not resolve: ${bloc.name || bloc}`);
+    }
+
+    const { subscribe, getSnapshot, getServerSnapshot } = useMemo(
+      () => externalBlocStore(resolvedBloc, dependencyArray),
+      [resolvedBloc.createdAt],
+    );
+
+    const state = useSyncExternalStore<InferStateFromGeneric<S>>(
+      subscribe,
+      getSnapshot,
+      getServerSnapshot,
+    );
+
+    useEffect(() => {
+      if ((resolvedBloc.isolated && props) || (props && !resolvedBloc.props)) {
+        resolvedBloc.props = props;
+      }
+    }, [props]);
+
+    return [state, resolvedBloc];
+  }
+}
+
+const useBloc = UseBlocClass.useBloc;
+
+export default useBloc;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "esnext",
+    "jsx": "react",
+    "sourceMap": true,
+    "outDir": "dist",
+    "strict": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "exclude": ["publish.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,30 @@
+import { defineConfig } from 'vite';
+import reactRefresh from '@vitejs/plugin-react';
+import dts from 'vite-plugin-dts';
+import { dependencies, devDependencies } from './package.json';
+
+const external = [
+  ...Object.keys(dependencies),
+  ...Object.keys(devDependencies),
+].filter((name) => {
+  return name;
+});
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [reactRefresh(), dts()],
+  publicDir: 'public',
+  build: {
+    lib: {
+      entry: './src/index.ts', // Specifies the entry point for building the library.
+      name: 'blac-react', // Sets the name of the generated library.
+      fileName: (format) => `index.${format}.js`, // Generates the output file name based on the format.
+      formats: ['cjs', 'es'], // Specifies the output formats (CommonJS and ES modules).
+    },
+    rollupOptions: {
+      external: [...external, 'react', 'react-dom', 'react/jsx-runtime'], // Defines external dependencies for Rollup bundling.
+    },
+    sourcemap: true, // Generates source maps for debugging.
+    emptyOutDir: true, // Clears the output directory before building.
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  
+})

package/index.cjs.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("blac"),l=require("react"),d=(c,s)=>{let t=s(c.state);return{subscribe:u=>{const n=c.addEventListenerStateChange(o=>{try{const e=s(o)??[];let i=!0;for(let a=0;a<e.length;a++)if(e[a]!==t[a]){i=!1;break}i||(t=e,u())}catch(e){console.error({e,bloc:c,dependencyArray:s,lastDependencyCheck:t})}});return()=>{n()}},getSnapshot:()=>c.state,getServerSnapshot:()=>c.state}};class y{static useBloc(s,t){const u=l.useId();let n=B=>[B],o,e;typeof t=="function"&&(n=t),typeof t=="string"&&(o=t),typeof t=="object"&&(n=t.dependencySelector??n,o=t.id,e=t.props??e),s.isolated&&(o=u);const r=h.Blac.getInstance().getBloc(s,{id:o,props:e,reconnect:!1});if(!r)throw new Error(`useBloc: could not resolve: ${s.name||s}`);const{subscribe:f,getSnapshot:S,getServerSnapshot:g}=l.useMemo(()=>d(r,n),[r.createdAt]),p=l.useSyncExternalStore(f,S,g);return l.useEffect(()=>{(r.isolated&&e||e&&!r.props)&&(r.props=e)},[e]),[p,r]}}const b=y.useBloc;exports.externalBlocStore=d;exports.useBloc=b;
-//# sourceMappingURL=index.cjs.js.map

package/index.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs.js","sources":["../src/externalBlocStore.ts","../src/useBloc.tsx"],"sourcesContent":["import { BlocBase } from 'blac';\n\nexport interface ExternalStore<B extends BlocBase<S>, S> {\n  subscribe: (onStoreChange: () => void) => () => void;\n  getSnapshot: () => S;\n  getServerSnapshot?: () => S;\n}\n\nconst externalBlocStore = <B extends BlocBase<S>, S>(\n  bloc: B,\n  dependencyArray: (state: S) => unknown[],\n): ExternalStore<B, S> => {\n  let lastDependencyCheck = dependencyArray(bloc.state);\n\n  return {\n    subscribe: (listener: () => void) => {\n      const unSub = bloc.addEventListenerStateChange((data) => {\n        try {\n          const newDependencyCheck = dependencyArray(data) ?? [];\n\n          let allEqual = true;\n          for (let i = 0; i < newDependencyCheck.length; i++) {\n            if (newDependencyCheck[i] !== lastDependencyCheck[i]) {\n              allEqual = false;\n              break;\n            }\n          }\n\n          if (!allEqual) {\n            lastDependencyCheck = newDependencyCheck;\n            listener();\n          }\n        } catch (e) {\n          console.error({\n            e,\n            bloc,\n            dependencyArray,\n            lastDependencyCheck,\n          });\n        }\n      });\n      return () => {\n        unSub();\n      };\n    },\n    getSnapshot: (): S => bloc.state,\n    getServerSnapshot: (): S => bloc.state,\n  };\n};\n\nexport default externalBlocStore;\n","import {\n  Blac,\n  BlocBase,\n  BlocConstructor,\n  BlocInstanceId,\n  BlocProps,\n  CubitPropsType,\n  ValueType,\n} from 'blac';\nimport { useEffect, useId, useMemo, useSyncExternalStore } from 'react';\nimport externalBlocStore from './externalBlocStore';\n\nexport type BlocHookData<B extends BlocBase<S>, S> = [\n  value: ValueType<B>,\n  instance: B,\n];\n\n// type BlocHookData<B extends BlocBase<S>, S> = [S, InstanceType<B>]; // B is the bloc class, S is the state of the bloc\n// type UseBlocClassResult<B, S> = BlocHookData<B, S>;\n\nexport type BlocHookDependencyArrayFn<B extends BlocBase<S>, S> = (\n  state: ValueType<B>,\n) => unknown[];\n\nexport interface BlocHookOptions<B extends BlocBase<S>, S> {\n  id?: string;\n  dependencySelector?: BlocHookDependencyArrayFn<B, S>;\n  props?: CubitPropsType<B>;\n}\n\nexport class UseBlocClass {\n  // constructor, no options\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    options: BlocHookOptions<InstanceType<B>, S>,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    depsSelector: BlocHookDependencyArrayFn<InstanceType<B>, S>,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    instanceId: string,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    options?:\n      | BlocHookOptions<InstanceType<B>, S>\n      | BlocHookDependencyArrayFn<InstanceType<B>, S>\n      | BlocInstanceId,\n  ): BlocHookData<InstanceType<B>, S> {\n    const rid = useId();\n    // default options\n    let dependencyArray: BlocHookDependencyArrayFn<InstanceType<B>, S> = (\n      state: ValueType<InstanceType<B>>,\n    ) => [state];\n    let blocId: BlocInstanceId | undefined;\n    let props: BlocProps | undefined;\n\n    // parse options\n\n    // if options is a function, its a dependencySelector\n    if (typeof options === 'function') {\n      dependencyArray = options;\n    }\n\n    // if options is a string its an ID\n    if (typeof options === 'string') {\n      blocId = options;\n    }\n\n    if (typeof options === 'object') {\n      dependencyArray = options.dependencySelector ?? dependencyArray;\n      blocId = options.id;\n      props = options.props ?? props;\n    }\n\n    const base = bloc as unknown as BlocBase<S>;\n    const isIsolated = base.isolated;\n    if (isIsolated) {\n      blocId = rid;\n    }\n\n    const resolvedBloc = Blac.getInstance().getBloc(bloc, {\n      id: blocId,\n      props,\n      reconnect: false,\n    }) as InstanceType<B>;\n\n    if (!resolvedBloc) {\n      throw new Error(`useBloc: could not resolve: ${bloc.name || bloc}`);\n    }\n\n    const { subscribe, getSnapshot, getServerSnapshot } = useMemo(\n      () => externalBlocStore(resolvedBloc, dependencyArray),\n      [resolvedBloc.createdAt],\n    );\n\n    const state = useSyncExternalStore<ValueType<InstanceType<B>>>(\n      subscribe,\n      getSnapshot,\n      getServerSnapshot,\n    );\n\n    useEffect(() => {\n      if ((resolvedBloc.isolated && props) || (props && !resolvedBloc.props)) {\n        resolvedBloc.props = props;\n      }\n    }, [props]);\n\n    return [state, resolvedBloc];\n  }\n}\n\nconst useBloc = UseBlocClass.useBloc;\n\nexport default useBloc;\n"],"names":["externalBlocStore","bloc","dependencyArray","lastDependencyCheck","listener","unSub","data","newDependencyCheck","allEqual","i","UseBlocClass","options","rid","useId","state","blocId","props","resolvedBloc","Blac","subscribe","getSnapshot","getServerSnapshot","useMemo","useSyncExternalStore","useEffect","useBloc"],"mappings":"2HAQMA,EAAoB,CACxBC,EACAC,IACwB,CACpB,IAAAC,EAAsBD,EAAgBD,EAAK,KAAK,EAE7C,MAAA,CACL,UAAYG,GAAyB,CACnC,MAAMC,EAAQJ,EAAK,4BAA6BK,GAAS,CACnD,GAAA,CACF,MAAMC,EAAqBL,EAAgBI,CAAI,GAAK,CAAA,EAEpD,IAAIE,EAAW,GACf,QAASC,EAAI,EAAGA,EAAIF,EAAmB,OAAQE,IAC7C,GAAIF,EAAmBE,CAAC,IAAMN,EAAoBM,CAAC,EAAG,CACzCD,EAAA,GACX,KACF,CAGGA,IACmBL,EAAAI,EACbH,WAEJ,EAAG,CACV,QAAQ,MAAM,CACZ,EACA,KAAAH,EACA,gBAAAC,EACA,oBAAAC,CAAA,CACD,CACH,CAAA,CACD,EACD,MAAO,IAAM,CACLE,GAAA,CAEV,EACA,YAAa,IAASJ,EAAK,MAC3B,kBAAmB,IAASA,EAAK,KAAA,CAErC,EClBO,MAAMS,CAAa,CAiBxB,OAAO,QACLT,EACAU,EAIkC,CAClC,MAAMC,EAAMC,EAAAA,QAEZ,IAAIX,EACFY,GACG,CAACA,CAAK,EACPC,EACAC,EAKA,OAAOL,GAAY,aACHT,EAAAS,GAIhB,OAAOA,GAAY,WACZI,EAAAJ,GAGP,OAAOA,GAAY,WACrBT,EAAkBS,EAAQ,oBAAsBT,EAChDa,EAASJ,EAAQ,GACjBK,EAAQL,EAAQ,OAASK,GAGdf,EACW,WAEbc,EAAAH,GAGX,MAAMK,EAAeC,EAAA,KAAK,YAAY,EAAE,QAAQjB,EAAM,CACpD,GAAIc,EACJ,MAAAC,EACA,UAAW,EAAA,CACZ,EAED,GAAI,CAACC,EACH,MAAM,IAAI,MAAM,+BAA+BhB,EAAK,MAAQA,CAAI,EAAE,EAGpE,KAAM,CAAE,UAAAkB,EAAW,YAAAC,EAAa,kBAAAC,CAAsB,EAAAC,EAAA,QACpD,IAAMtB,EAAkBiB,EAAcf,CAAe,EACrD,CAACe,EAAa,SAAS,CAAA,EAGnBH,EAAQS,EAAA,qBACZJ,EACAC,EACAC,CAAA,EAGFG,OAAAA,EAAAA,UAAU,IAAM,EACTP,EAAa,UAAYD,GAAWA,GAAS,CAACC,EAAa,SAC9DA,EAAa,MAAQD,EACvB,EACC,CAACA,CAAK,CAAC,EAEH,CAACF,EAAOG,CAAY,CAC7B,CACF,CAEA,MAAMQ,EAAUf,EAAa"}

package/index.es.js

@@ -1,64 +0,0 @@
-import { Blac as h } from "blac";
-import { useId as g, useMemo as B, useSyncExternalStore as m, useEffect as y } from "react";
-const v = (o, s) => {
-  let t = s(o.state);
-  return {
-    subscribe: (l) => {
-      const c = o.addEventListenerStateChange((n) => {
-        try {
-          const e = s(n) ?? [];
-          let f = !0;
-          for (let a = 0; a < e.length; a++)
-            if (e[a] !== t[a]) {
-              f = !1;
-              break;
-            }
-          f || (t = e, l());
-        } catch (e) {
-          console.error({
-            e,
-            bloc: o,
-            dependencyArray: s,
-            lastDependencyCheck: t
-          });
-        }
-      });
-      return () => {
-        c();
-      };
-    },
-    getSnapshot: () => o.state,
-    getServerSnapshot: () => o.state
-  };
-};
-class E {
-  static useBloc(s, t) {
-    const l = g();
-    let c = (S) => [S], n, e;
-    typeof t == "function" && (c = t), typeof t == "string" && (n = t), typeof t == "object" && (c = t.dependencySelector ?? c, n = t.id, e = t.props ?? e), s.isolated && (n = l);
-    const r = h.getInstance().getBloc(s, {
-      id: n,
-      props: e,
-      reconnect: !1
-    });
-    if (!r)
-      throw new Error(`useBloc: could not resolve: ${s.name || s}`);
-    const { subscribe: u, getSnapshot: i, getServerSnapshot: d } = B(
-      () => v(r, c),
-      [r.createdAt]
-    ), p = m(
-      u,
-      i,
-      d
-    );
-    return y(() => {
-      (r.isolated && e || e && !r.props) && (r.props = e);
-    }, [e]), [p, r];
-  }
-}
-const b = E.useBloc;
-export {
-  v as externalBlocStore,
-  b as useBloc
-};
-//# sourceMappingURL=index.es.js.map

package/index.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.es.js","sources":["../src/externalBlocStore.ts","../src/useBloc.tsx"],"sourcesContent":["import { BlocBase } from 'blac';\n\nexport interface ExternalStore<B extends BlocBase<S>, S> {\n  subscribe: (onStoreChange: () => void) => () => void;\n  getSnapshot: () => S;\n  getServerSnapshot?: () => S;\n}\n\nconst externalBlocStore = <B extends BlocBase<S>, S>(\n  bloc: B,\n  dependencyArray: (state: S) => unknown[],\n): ExternalStore<B, S> => {\n  let lastDependencyCheck = dependencyArray(bloc.state);\n\n  return {\n    subscribe: (listener: () => void) => {\n      const unSub = bloc.addEventListenerStateChange((data) => {\n        try {\n          const newDependencyCheck = dependencyArray(data) ?? [];\n\n          let allEqual = true;\n          for (let i = 0; i < newDependencyCheck.length; i++) {\n            if (newDependencyCheck[i] !== lastDependencyCheck[i]) {\n              allEqual = false;\n              break;\n            }\n          }\n\n          if (!allEqual) {\n            lastDependencyCheck = newDependencyCheck;\n            listener();\n          }\n        } catch (e) {\n          console.error({\n            e,\n            bloc,\n            dependencyArray,\n            lastDependencyCheck,\n          });\n        }\n      });\n      return () => {\n        unSub();\n      };\n    },\n    getSnapshot: (): S => bloc.state,\n    getServerSnapshot: (): S => bloc.state,\n  };\n};\n\nexport default externalBlocStore;\n","import {\n  Blac,\n  BlocBase,\n  BlocConstructor,\n  BlocInstanceId,\n  BlocProps,\n  CubitPropsType,\n  ValueType,\n} from 'blac';\nimport { useEffect, useId, useMemo, useSyncExternalStore } from 'react';\nimport externalBlocStore from './externalBlocStore';\n\nexport type BlocHookData<B extends BlocBase<S>, S> = [\n  value: ValueType<B>,\n  instance: B,\n];\n\n// type BlocHookData<B extends BlocBase<S>, S> = [S, InstanceType<B>]; // B is the bloc class, S is the state of the bloc\n// type UseBlocClassResult<B, S> = BlocHookData<B, S>;\n\nexport type BlocHookDependencyArrayFn<B extends BlocBase<S>, S> = (\n  state: ValueType<B>,\n) => unknown[];\n\nexport interface BlocHookOptions<B extends BlocBase<S>, S> {\n  id?: string;\n  dependencySelector?: BlocHookDependencyArrayFn<B, S>;\n  props?: CubitPropsType<B>;\n}\n\nexport class UseBlocClass {\n  // constructor, no options\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    options: BlocHookOptions<InstanceType<B>, S>,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    depsSelector: BlocHookDependencyArrayFn<InstanceType<B>, S>,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    instanceId: string,\n  ): BlocHookData<InstanceType<B>, S>;\n  static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(\n    bloc: B,\n    options?:\n      | BlocHookOptions<InstanceType<B>, S>\n      | BlocHookDependencyArrayFn<InstanceType<B>, S>\n      | BlocInstanceId,\n  ): BlocHookData<InstanceType<B>, S> {\n    const rid = useId();\n    // default options\n    let dependencyArray: BlocHookDependencyArrayFn<InstanceType<B>, S> = (\n      state: ValueType<InstanceType<B>>,\n    ) => [state];\n    let blocId: BlocInstanceId | undefined;\n    let props: BlocProps | undefined;\n\n    // parse options\n\n    // if options is a function, its a dependencySelector\n    if (typeof options === 'function') {\n      dependencyArray = options;\n    }\n\n    // if options is a string its an ID\n    if (typeof options === 'string') {\n      blocId = options;\n    }\n\n    if (typeof options === 'object') {\n      dependencyArray = options.dependencySelector ?? dependencyArray;\n      blocId = options.id;\n      props = options.props ?? props;\n    }\n\n    const base = bloc as unknown as BlocBase<S>;\n    const isIsolated = base.isolated;\n    if (isIsolated) {\n      blocId = rid;\n    }\n\n    const resolvedBloc = Blac.getInstance().getBloc(bloc, {\n      id: blocId,\n      props,\n      reconnect: false,\n    }) as InstanceType<B>;\n\n    if (!resolvedBloc) {\n      throw new Error(`useBloc: could not resolve: ${bloc.name || bloc}`);\n    }\n\n    const { subscribe, getSnapshot, getServerSnapshot } = useMemo(\n      () => externalBlocStore(resolvedBloc, dependencyArray),\n      [resolvedBloc.createdAt],\n    );\n\n    const state = useSyncExternalStore<ValueType<InstanceType<B>>>(\n      subscribe,\n      getSnapshot,\n      getServerSnapshot,\n    );\n\n    useEffect(() => {\n      if ((resolvedBloc.isolated && props) || (props && !resolvedBloc.props)) {\n        resolvedBloc.props = props;\n      }\n    }, [props]);\n\n    return [state, resolvedBloc];\n  }\n}\n\nconst useBloc = UseBlocClass.useBloc;\n\nexport default useBloc;\n"],"names":["externalBlocStore","bloc","dependencyArray","lastDependencyCheck","listener","unSub","data","newDependencyCheck","allEqual","i","UseBlocClass","options","rid","useId","state","blocId","props","resolvedBloc","Blac","subscribe","getSnapshot","getServerSnapshot","useMemo","useSyncExternalStore","useEffect","useBloc"],"mappings":";;AAQM,MAAAA,IAAoB,CACxBC,GACAC,MACwB;AACpB,MAAAC,IAAsBD,EAAgBD,EAAK,KAAK;AAE7C,SAAA;AAAA,IACL,WAAW,CAACG,MAAyB;AACnC,YAAMC,IAAQJ,EAAK,4BAA4B,CAACK,MAAS;AACnD,YAAA;AACF,gBAAMC,IAAqBL,EAAgBI,CAAI,KAAK,CAAA;AAEpD,cAAIE,IAAW;AACf,mBAASC,IAAI,GAAGA,IAAIF,EAAmB,QAAQE;AAC7C,gBAAIF,EAAmBE,CAAC,MAAMN,EAAoBM,CAAC,GAAG;AACzC,cAAAD,IAAA;AACX;AAAA,YACF;AAGF,UAAKA,MACmBL,IAAAI,GACbH;iBAEJ,GAAG;AACV,kBAAQ,MAAM;AAAA,YACZ;AAAA,YACA,MAAAH;AAAA,YACA,iBAAAC;AAAA,YACA,qBAAAC;AAAA,UAAA,CACD;AAAA,QACH;AAAA,MAAA,CACD;AACD,aAAO,MAAM;AACL,QAAAE;MAAA;AAAA,IAEV;AAAA,IACA,aAAa,MAASJ,EAAK;AAAA,IAC3B,mBAAmB,MAASA,EAAK;AAAA,EAAA;AAErC;AClBO,MAAMS,EAAa;AAAA,EAiBxB,OAAO,QACLT,GACAU,GAIkC;AAClC,UAAMC,IAAMC;AAEZ,QAAIX,IAAiE,CACnEY,MACG,CAACA,CAAK,GACPC,GACAC;AAKA,IAAA,OAAOL,KAAY,eACHT,IAAAS,IAIhB,OAAOA,KAAY,aACZI,IAAAJ,IAGP,OAAOA,KAAY,aACrBT,IAAkBS,EAAQ,sBAAsBT,GAChDa,IAASJ,EAAQ,IACjBK,IAAQL,EAAQ,SAASK,IAGdf,EACW,aAEbc,IAAAH;AAGX,UAAMK,IAAeC,EAAK,YAAY,EAAE,QAAQjB,GAAM;AAAA,MACpD,IAAIc;AAAA,MACJ,OAAAC;AAAA,MACA,WAAW;AAAA,IAAA,CACZ;AAED,QAAI,CAACC;AACH,YAAM,IAAI,MAAM,+BAA+BhB,EAAK,QAAQA,CAAI,EAAE;AAGpE,UAAM,EAAE,WAAAkB,GAAW,aAAAC,GAAa,mBAAAC,EAAsB,IAAAC;AAAA,MACpD,MAAMtB,EAAkBiB,GAAcf,CAAe;AAAA,MACrD,CAACe,EAAa,SAAS;AAAA,IAAA,GAGnBH,IAAQS;AAAA,MACZJ;AAAA,MACAC;AAAA,MACAC;AAAA,IAAA;AAGF,WAAAG,EAAU,MAAM;AACd,OAAKP,EAAa,YAAYD,KAAWA,KAAS,CAACC,EAAa,WAC9DA,EAAa,QAAQD;AAAA,IACvB,GACC,CAACA,CAAK,CAAC,GAEH,CAACF,GAAOG,CAAY;AAAA,EAC7B;AACF;AAEA,MAAMQ,IAAUf,EAAa;"}

package/src/externalBlocStore.d.ts

@@ -1,8 +0,0 @@
-import { BlocBase } from 'blac';
-export interface ExternalStore<B extends BlocBase<S>, S> {
-    subscribe: (onStoreChange: () => void) => () => void;
-    getSnapshot: () => S;
-    getServerSnapshot?: () => S;
-}
-declare const externalBlocStore: <B extends BlocBase<S, {}>, S>(bloc: B, dependencyArray: (state: S) => unknown[]) => ExternalStore<B, S>;
-export default externalBlocStore;

package/src/useBloc.d.ts

@@ -1,19 +0,0 @@
-import { BlocBase, BlocConstructor, CubitPropsType, ValueType } from 'blac';
-export type BlocHookData<B extends BlocBase<S>, S> = [
-    value: ValueType<B>,
-    instance: B
-];
-export type BlocHookDependencyArrayFn<B extends BlocBase<S>, S> = (state: ValueType<B>) => unknown[];
-export interface BlocHookOptions<B extends BlocBase<S>, S> {
-    id?: string;
-    dependencySelector?: BlocHookDependencyArrayFn<B, S>;
-    props?: CubitPropsType<B>;
-}
-export declare class UseBlocClass {
-    static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(bloc: B): BlocHookData<InstanceType<B>, S>;
-    static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(bloc: B, options: BlocHookOptions<InstanceType<B>, S>): BlocHookData<InstanceType<B>, S>;
-    static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(bloc: B, depsSelector: BlocHookDependencyArrayFn<InstanceType<B>, S>): BlocHookData<InstanceType<B>, S>;
-    static useBloc<B extends BlocConstructor<BlocBase<S>>, S>(bloc: B, instanceId: string): BlocHookData<InstanceType<B>, S>;
-}
-declare const useBloc: typeof UseBlocClass.useBloc;
-export default useBloc;