srasm 0.0.0 → 0.0.3

package/dist/index.cjs

@@ -0,0 +1,159 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createStateStore: () => createStateStore,
+  logClick: () => logClick
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/context/createStateStore.ts
+var import_react = __toESM(require("react"), 1);
+
+// src/utils/deepEqual.ts
+function deepEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (typeof obj1 !== "object" || typeof obj2 !== "object" || obj1 === null || obj2 === null) {
+    return Object.is(obj1, obj2);
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/context/createStateStore.ts
+var import_with_selector = require("use-sync-external-store/with-selector");
+function createStateStore(initialSlices) {
+  let storeState = { ...initialSlices };
+  const sliceListeners = /* @__PURE__ */ new Map();
+  const getSliceListeners = (k) => {
+    let set = sliceListeners.get(k);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      sliceListeners.set(k, set);
+    }
+    return set;
+  };
+  const subscribeSlice = (key, listener) => {
+    const set = getSliceListeners(key);
+    set.add(listener);
+    return () => set.delete(listener);
+  };
+  const emitSlice = (key) => {
+    getSliceListeners(key).forEach((l) => l());
+  };
+  const updateSlice = (key, payload, useDeepEqualCheck) => {
+    const current = storeState[key];
+    let next = current;
+    if (typeof payload === "function") {
+      next = payload(current);
+      if (Object.is(current, next)) return;
+      if (useDeepEqualCheck && deepEqual(current, next)) return;
+    } else {
+      if (typeof current === "object" && current !== null && typeof payload === "object" && payload !== null) {
+        next = { ...current, ...payload };
+        if (useDeepEqualCheck && deepEqual(current, next)) return;
+      } else {
+        if (Object.is(current, payload)) return;
+        if (useDeepEqualCheck && deepEqual(current, payload)) return;
+        next = payload;
+      }
+    }
+    if (!Object.is(storeState[key], next)) {
+      storeState = { ...storeState, [key]: next };
+      emitSlice(key);
+    }
+  };
+  function useSRASM(slice, selector, options) {
+    const selected = (0, import_with_selector.useSyncExternalStoreWithSelector)(
+      (listener) => subscribeSlice(slice, listener),
+      () => storeState[slice],
+      () => initialSlices[slice],
+      selector ?? ((s) => s),
+      options?.isEqual ?? Object.is
+    );
+    const setState = (0, import_react.useCallback)(
+      (payload) => updateSlice(slice, payload, !!options?.useDeepEqualCheck),
+      [slice, options?.useDeepEqualCheck]
+    );
+    return { state: selected, setState };
+  }
+  function useSRASMAsync(slice, fetcher, tags = []) {
+    const { state, setState } = useSRASM(slice);
+    const [loading, setLoading] = import_react.default.useState(false);
+    const [error, setError] = import_react.default.useState(null);
+    const fetchData = (0, import_react.useCallback)(async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        const data = await fetcher();
+        setState(data);
+      } catch (err) {
+        setError(err);
+      } finally {
+        setLoading(false);
+      }
+    }, [slice, fetcher, setState]);
+    import_react.default.useEffect(() => {
+      fetchData();
+    }, [JSON.stringify(tags)]);
+    return {
+      data: state,
+      loading,
+      error,
+      refetch: fetchData
+    };
+  }
+  const SRASMProvider = ({
+    children
+  }) => {
+    return children;
+  };
+  return { SRASMProvider, useSRASM, useSRASMAsync };
+}
+
+// src/ml/globalLogs.ts
+var logClick = (event) => {
+  const key = "click_events";
+  const existing = JSON.parse(localStorage.getItem(key) || "[]");
+  existing.push(event);
+  localStorage.setItem(key, JSON.stringify(existing));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStateStore,
+  logClick
+});

package/dist/index.d.cts

@@ -0,0 +1,42 @@
+import React from 'react';
+
+/**
+ * Creates a state store with the given initial state slices.
+ * The state store is used by the `useSRASM` hook to provide a strongly-typed
+ * way of accessing and updating the state.
+ *
+ * @param {Slices} initialSlices The initial state slices to be used by the state store.
+ * @return {{ SRASMProvider: React.FC<{ children: React.ReactNode; relevantCode?: { fileName: string; code: string }[] | undefined; additionalSlices?: any[] | undefined }>; useSRASM: <K extends SliceKey, Selected = Slices[K]>(slice: K, selector?: (s: Slices[K]) => Selected, options?: { useDeepEqualCheck?: boolean; isEqual?: (a: Selected, b: Selected) => boolean; }) => useSRASMReturn }}
+ * The returned object contains the `SRASMProvider` context provider component and the `useSRASM` hook.
+ * The `SRASMProvider` component should be used to wrap your application, providing the necessary state and error handling to SRASM components.
+ * The `useSRASM` hook can be used by your React components to access and update the state.
+ */
+declare function createStateStore<Slices extends Record<string, any>>(initialSlices: Slices): {
+    SRASMProvider: ({ children, }: {
+        children: React.ReactNode;
+    }) => React.ReactElement<{
+        children: React.ReactNode;
+    }>;
+    useSRASM: <K extends keyof Slices, Selected = Slices[K]>(slice: K, selector?: (s: Slices[K]) => Selected, options?: {
+        useDeepEqualCheck?: boolean;
+        isEqual?: (a: Selected, b: Selected) => boolean;
+    }) => {
+        state: any;
+        setState: (payload: Partial<Slices[K]> | ((prev: Slices[K]) => Partial<Slices[K]>)) => void;
+    };
+    useSRASMAsync: <K extends keyof Slices>(slice: K, fetcher: () => Promise<Slices[K]>, tags?: any[]) => {
+        data: any;
+        loading: boolean;
+        error: any;
+        refetch: () => Promise<void>;
+    };
+};
+
+type ClickEvent = {
+    itemId: string;
+    categoryId: string;
+    ts: number;
+};
+declare const logClick: (event: ClickEvent) => void;
+
+export { type ClickEvent, createStateStore, logClick };

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+
+/**
+ * Creates a state store with the given initial state slices.
+ * The state store is used by the `useSRASM` hook to provide a strongly-typed
+ * way of accessing and updating the state.
+ *
+ * @param {Slices} initialSlices The initial state slices to be used by the state store.
+ * @return {{ SRASMProvider: React.FC<{ children: React.ReactNode; relevantCode?: { fileName: string; code: string }[] | undefined; additionalSlices?: any[] | undefined }>; useSRASM: <K extends SliceKey, Selected = Slices[K]>(slice: K, selector?: (s: Slices[K]) => Selected, options?: { useDeepEqualCheck?: boolean; isEqual?: (a: Selected, b: Selected) => boolean; }) => useSRASMReturn }}
+ * The returned object contains the `SRASMProvider` context provider component and the `useSRASM` hook.
+ * The `SRASMProvider` component should be used to wrap your application, providing the necessary state and error handling to SRASM components.
+ * The `useSRASM` hook can be used by your React components to access and update the state.
+ */
+declare function createStateStore<Slices extends Record<string, any>>(initialSlices: Slices): {
+    SRASMProvider: ({ children, }: {
+        children: React.ReactNode;
+    }) => React.ReactElement<{
+        children: React.ReactNode;
+    }>;
+    useSRASM: <K extends keyof Slices, Selected = Slices[K]>(slice: K, selector?: (s: Slices[K]) => Selected, options?: {
+        useDeepEqualCheck?: boolean;
+        isEqual?: (a: Selected, b: Selected) => boolean;
+    }) => {
+        state: any;
+        setState: (payload: Partial<Slices[K]> | ((prev: Slices[K]) => Partial<Slices[K]>)) => void;
+    };
+    useSRASMAsync: <K extends keyof Slices>(slice: K, fetcher: () => Promise<Slices[K]>, tags?: any[]) => {
+        data: any;
+        loading: boolean;
+        error: any;
+        refetch: () => Promise<void>;
+    };
+};
+
+type ClickEvent = {
+    itemId: string;
+    categoryId: string;
+    ts: number;
+};
+declare const logClick: (event: ClickEvent) => void;
+
+export { type ClickEvent, createStateStore, logClick };

package/dist/index.js

@@ -0,0 +1,122 @@
+// src/context/createStateStore.ts
+import React, { useCallback } from "react";
+
+// src/utils/deepEqual.ts
+function deepEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (typeof obj1 !== "object" || typeof obj2 !== "object" || obj1 === null || obj2 === null) {
+    return Object.is(obj1, obj2);
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/context/createStateStore.ts
+import { useSyncExternalStoreWithSelector } from "use-sync-external-store/with-selector";
+function createStateStore(initialSlices) {
+  let storeState = { ...initialSlices };
+  const sliceListeners = /* @__PURE__ */ new Map();
+  const getSliceListeners = (k) => {
+    let set = sliceListeners.get(k);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      sliceListeners.set(k, set);
+    }
+    return set;
+  };
+  const subscribeSlice = (key, listener) => {
+    const set = getSliceListeners(key);
+    set.add(listener);
+    return () => set.delete(listener);
+  };
+  const emitSlice = (key) => {
+    getSliceListeners(key).forEach((l) => l());
+  };
+  const updateSlice = (key, payload, useDeepEqualCheck) => {
+    const current = storeState[key];
+    let next = current;
+    if (typeof payload === "function") {
+      next = payload(current);
+      if (Object.is(current, next)) return;
+      if (useDeepEqualCheck && deepEqual(current, next)) return;
+    } else {
+      if (typeof current === "object" && current !== null && typeof payload === "object" && payload !== null) {
+        next = { ...current, ...payload };
+        if (useDeepEqualCheck && deepEqual(current, next)) return;
+      } else {
+        if (Object.is(current, payload)) return;
+        if (useDeepEqualCheck && deepEqual(current, payload)) return;
+        next = payload;
+      }
+    }
+    if (!Object.is(storeState[key], next)) {
+      storeState = { ...storeState, [key]: next };
+      emitSlice(key);
+    }
+  };
+  function useSRASM(slice, selector, options) {
+    const selected = useSyncExternalStoreWithSelector(
+      (listener) => subscribeSlice(slice, listener),
+      () => storeState[slice],
+      () => initialSlices[slice],
+      selector ?? ((s) => s),
+      options?.isEqual ?? Object.is
+    );
+    const setState = useCallback(
+      (payload) => updateSlice(slice, payload, !!options?.useDeepEqualCheck),
+      [slice, options?.useDeepEqualCheck]
+    );
+    return { state: selected, setState };
+  }
+  function useSRASMAsync(slice, fetcher, tags = []) {
+    const { state, setState } = useSRASM(slice);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const fetchData = useCallback(async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        const data = await fetcher();
+        setState(data);
+      } catch (err) {
+        setError(err);
+      } finally {
+        setLoading(false);
+      }
+    }, [slice, fetcher, setState]);
+    React.useEffect(() => {
+      fetchData();
+    }, [JSON.stringify(tags)]);
+    return {
+      data: state,
+      loading,
+      error,
+      refetch: fetchData
+    };
+  }
+  const SRASMProvider = ({
+    children
+  }) => {
+    return children;
+  };
+  return { SRASMProvider, useSRASM, useSRASMAsync };
+}
+
+// src/ml/globalLogs.ts
+var logClick = (event) => {
+  const key = "click_events";
+  const existing = JSON.parse(localStorage.getItem(key) || "[]");
+  existing.push(event);
+  localStorage.setItem(key, JSON.stringify(existing));
+};
+export {
+  createStateStore,
+  logClick
+};

package/package.json

@@ -1,43 +1,38 @@
 {
   "name": "srasm",
   "private": false,
-  "version": "0.0.0",
+  "version": "0.0.3",
   "type": "module",
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
   "scripts": {
     "dev": "vite",
-    "build": "tsc -b && vite build",
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
     "lint": "eslint .",
     "preview": "vite preview",
-    "debug": " npx eslint . --debug",
-    "prepublishOnly": "npm run build"
+    "debug": " npx eslint . --debug"
   },
   "dependencies": {
-    "@langchain/core": "^1.1.0",
-    "@langchain/openai": "^1.1.3",
-    "@tailwindcss/vite": "^4.1.17",
-    "@tensorflow/tfjs": "^4.22.0",
-    "axios": "^1.13.2",
     "clsx": "^2.1.1",
-    "dotenv": "^17.2.3",
-    "langchain": "^1.1.1",
-    "lucide-react": "^0.555.0",
-    "postcss": "^8.5.6",
-    "rc-tree": "^5.13.1",
-    "react": "^19.2.0",
-    "react-d3-tree": "^3.6.6",
-    "react-dom": "^19.2.0",
-    "react-hot-toast": "^2.6.0",
-    "react-markdown": "^10.1.0",
-    "react-router-dom": "^7.9.6",
+    "react": ">=18",
     "react-virtuoso": "^4.16.1",
-    "rehype-highlight": "^7.0.2",
-    "remark-gfm": "^4.0.1",
-    "tailwindcss": "^4.1.18",
     "use-sync-external-store": "^1.6.0"
   },
+  "peerDependencies": {
+    "react": ">=18"
+  },
   "devDependencies": {
-    "@tailwindcss/postcss": "^4.1.18",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.1",
     "@types/bun": "latest",
@@ -45,13 +40,9 @@
     "@types/react": "^19.2.2",
     "@types/react-dom": "^19.2.2",
     "@types/use-sync-external-store": "^1.5.0",
-    "@vitejs/plugin-react": "^5.1.0",
-    "baseline-browser-mapping": "^2.9.15",
-    "happy-dom": "^20.0.11",
-    "jsdom": "^27.0.1",
-    "typescript": "~5.9.3",
-    "vite": "^7.2.2",
-    "vitest": "^4.0.16"
+    "esbuild": "^0.27.2",
+    "tsup": "^8.5.1",
+    "typescript": "~5.9.3"
   },
   "module": "index.ts"
 }