opshot 0.1.1 → 0.3.1

package/package.json

@@ -1,72 +1,76 @@
 {
-  "name": "opshot",
-  "version": "0.1.1",
-  "description": "Plain-object state for React: mutate it directly, re-render only the components that read what changed, and track every change operation",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./react": {
-      "import": "./dist/react.js",
-      "types": "./dist/react.d.ts"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "sideEffects": false,
-  "publishConfig": {
-    "access": "public"
-  },
-  "author": "Matt Cavender",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/visionsofparadise/opshot.git"
-  },
-  "scripts": {
-    "check": "concurrently \"eslint . --fix --cache --format ./agent-eslint.js\" \"tsc --noEmit --pretty false 2>&1 | node ./agent-tsc.js\"",
-    "check:verbose": "concurrently \"eslint . --cache\" \"tsc --noEmit\"",
-    "lint": "eslint . --fix --cache --format ./agent-eslint.js",
-    "lint:verbose": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "unit": "vitest run unit",
-    "build": "tsup --config tsup.config.ts"
-  },
-  "peerDependencies": {
-    "react": ">=18.0.0"
-  },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    }
-  },
-  "dependencies": {
-    "proxy-compare": "^3.0.1",
-    "valtio": "2.3.2"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.39.5",
-    "@stylistic/eslint-plugin": "^5.10.0",
-    "@testing-library/react": "^16.3.2",
-    "@types/react": "^19.2.17",
-    "concurrently": "^10.0.3",
-    "eslint": "^9.39.5",
-    "eslint-plugin-barrel-files": "^3.0.1",
-    "eslint-plugin-check-file": "^3.3.1",
-    "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^7.1.1",
-    "fast-json-patch": "^3.1.1",
-    "globals": "^17.7.0",
-    "jsdom": "^29.1.1",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.64.0",
-    "vitest": "^4.1.10"
-  }
+	"name": "opshot",
+	"version": "0.3.1",
+	"description": "Plain-object state for React: mutate it directly, re-render only the components that read what changed, and track every change operation",
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"sideEffects": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"author": "Matt Cavender",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/visionsofparadise/opshot.git"
+	},
+	"scripts": {
+		"check": "prettier --write . && eslint . --fix --cache && concurrently \"tsc --noEmit\" \"markdownlint-cli2 \\\"**/*.md\\\"\" \"textlint \\\"**/*.md\\\"\" \"knip --no-progress\" \"jscpd .\"",
+		"lint": "eslint . --fix --cache",
+		"lint:fix": "eslint . --fix",
+		"format": "prettier --write .",
+		"unit": "vitest run unit",
+		"integration": "vitest run integration",
+		"build": "tsup --config tsup.config.ts"
+	},
+	"peerDependencies": {
+		"react": ">=18.0.0"
+	},
+	"devDependencies": {
+		"@eslint/compat": "^1.3.2",
+		"@eslint/js": "^9.39.5",
+		"@stylistic/eslint-plugin": "^5.10.0",
+		"@testing-library/react": "^16.3.2",
+		"@types/react": "^19.2.17",
+		"concurrently": "^10.0.3",
+		"eslint": "^9.39.5",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-import-resolver-typescript": "^4.4.4",
+		"eslint-plugin-barrel-files": "^3.0.1",
+		"eslint-plugin-check-file": "^3.3.1",
+		"eslint-plugin-comment-rules": "^0.1.5",
+		"eslint-plugin-import-x": "^4.17.1",
+		"eslint-plugin-jsx-a11y": "^6.10.2",
+		"eslint-plugin-react": "^7.37.5",
+		"eslint-plugin-react-hooks": "^7.1.1",
+		"globals": "^17.7.0",
+		"jscpd": "^5.0.12",
+		"jsdom": "^29.1.1",
+		"knip": "^6.29.0",
+		"markdownlint-cli2": "^0.23.1",
+		"prettier": "^3.6.2",
+		"proxy-compare": "^3.0.1",
+		"react": "^19.2.7",
+		"react-dom": "^19.2.7",
+		"textlint": "^15.2.2",
+		"textlint-filter-rule-comments": "^1.2.2",
+		"textlint-rule-no-dead-link": "^6.2.1",
+		"tsup": "^8.5.1",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.64.0",
+		"valtio": "2.3.2",
+		"vitest": "^4.1.10"
+	},
+	"allowScripts": {
+		"esbuild@0.27.7": true,
+		"unrs-resolver@1.12.2": true
+	}
 }

package/dist/react.d.ts

@@ -1,9 +0,0 @@
-import { FC } from 'react';
-import { Group, Define, State } from './index.js';
-import 'valtio/vanilla';
-
-declare function resnapshot<P extends object>(component: FC<P>): FC<P>;
-declare const useCreateGroup: () => Group;
-declare const useCreateState: <T extends object>(define: Define<T>, group?: Group) => State<T>;
-
-export { resnapshot, useCreateGroup, useCreateState };

package/dist/react.js

@@ -1,267 +0,0 @@
-import { isChanged, createProxy } from 'proxy-compare';
-import { memo, useState, useMemo, useRef, useCallback, useSyncExternalStore, useLayoutEffect } from 'react';
-import { unstable_getInternalStates, snapshot, subscribe, ref, proxy } from 'valtio/vanilla';
-
-// src/react.tsx
-var { refSet } = unstable_getInternalStates();
-var isPlainArray = (value) => Array.isArray(value) && !refSet.has(value);
-var isPlainObject = (value) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value) || refSet.has(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-};
-var isCloneable = (value) => isPlainObject(value) || isPlainArray(value);
-var cloneValue = (value) => {
-  if (isPlainArray(value)) return value.map(cloneValue);
-  if (isPlainObject(value)) {
-    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneValue(child)]));
-  }
-  return value;
-};
-var toPointer = (path) => {
-  if (path.length === 0) return "";
-  return `/${path.map((segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1")).join("/")}`;
-};
-var removing = (pointer) => ({ op: "remove", path: pointer });
-var carrying = (op, pointer, value) => {
-  if (!isCloneable(value)) return { op, path: pointer, value };
-  return {
-    op,
-    path: pointer,
-    get value() {
-      return cloneValue(value);
-    }
-  };
-};
-var addPair = (pointer, after) => ({ do: carrying("add", pointer, after), undo: removing(pointer) });
-var removePair = (pointer, before) => ({ do: removing(pointer), undo: carrying("add", pointer, before) });
-var replacePair = (pointer, before, after) => ({
-  do: carrying("replace", pointer, after),
-  undo: carrying("replace", pointer, before)
-});
-var diffValue = (before, after, path, ops) => {
-  if (Object.is(before, after)) return;
-  if (isPlainArray(before) && isPlainArray(after)) {
-    if (before.length !== after.length) {
-      ops.push(replacePair(toPointer(path), before, after));
-      return;
-    }
-    for (let index = 0; index < after.length; index++) diffValue(before[index], after[index], [...path, index], ops);
-    return;
-  }
-  if (isPlainObject(before) && isPlainObject(after)) {
-    for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
-      if (!Object.hasOwn(before, key)) ops.push(addPair(toPointer([...path, key]), after[key]));
-      else if (!Object.hasOwn(after, key)) ops.push(removePair(toPointer([...path, key]), before[key]));
-      else diffValue(before[key], after[key], [...path, key], ops);
-    }
-    return;
-  }
-  ops.push(replacePair(toPointer(path), before, after));
-};
-function diffSnapshots(before, after) {
-  const ops = [];
-  diffValue(before, after, [], ops);
-  return ops;
-}
-
-// src/createState.ts
-var stateBrand = /* @__PURE__ */ Symbol.for("opshot.state");
-var hasOwn = (value, key) => Object.hasOwn(value, key);
-function createState(define) {
-  return createGroupState(define);
-}
-function createGroupState(define, groupListeners) {
-  const callback = typeof define === "function" ? define : () => define;
-  const listeners = /* @__PURE__ */ new Set();
-  const created = {};
-  const requireProxy = () => {
-    const { proxied } = created;
-    if (!proxied) throw new Error("opshot: called during createState definition");
-    return proxied;
-  };
-  const get = () => snapshot(requireProxy());
-  const mutate = (callback2, options = {}) => {
-    const proxied = requireProxy();
-    if (handle.isMutating) throw new Error("opshot: nested mutate on the same state");
-    handle.isMutating = true;
-    const before = snapshot(proxied);
-    try {
-      callback2(proxied);
-    } finally {
-      handle.isMutating = false;
-    }
-    const after = snapshot(proxied);
-    if (before === after) return;
-    if (listeners.size === 0 && (groupListeners?.size ?? 0) === 0) return;
-    const ops = diffSnapshots(before, after);
-    if (ops.length === 0) return;
-    for (const listener of [...groupListeners ?? []]) listener(after, ops, options);
-    for (const listener of [...listeners]) listener(after, ops, options);
-  };
-  const subscribe = (listener) => {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  };
-  const isSameState = (other) => isState(other) && other.op === handle;
-  const unwrap = () => {
-    const { op, ...rest } = get();
-    return rest;
-  };
-  const literal = callback(mutate, get);
-  if (Object.hasOwn(literal, "op")) throw new Error('opshot: "op" is a reserved key on a state');
-  const base = Object.create(Reflect.getPrototypeOf(literal));
-  Object.defineProperties(base, Object.getOwnPropertyDescriptors(literal));
-  const handle = { proxy: base, isMutating: false, mutate, subscribe, isSameState, unwrap, [stateBrand]: true };
-  Object.defineProperty(base, "op", { value: ref(handle), enumerable: true, writable: false, configurable: false });
-  created.proxied = proxy(base);
-  handle.proxy = created.proxied;
-  return get();
-}
-function isState(value) {
-  if (typeof value !== "object" || value === null || !hasOwn(value, "op")) return false;
-  const handle = value.op;
-  if (typeof handle !== "object" || handle === null || !hasOwn(handle, stateBrand)) return false;
-  return handle[stateBrand] === true;
-}
-
-// src/createGroup.ts
-function createGroup() {
-  const listeners = /* @__PURE__ */ new Set();
-  return {
-    createState(define) {
-      return createGroupState(define, listeners);
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    }
-  };
-}
-
-// src/react.tsx
-function shouldTraverse(value) {
-  if (value === null || typeof value !== "object") return false;
-  if (Array.isArray(value)) return true;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function findSnapshotPaths(value, path = [], paths = []) {
-  if (isState(value)) {
-    paths.push(path);
-    return paths;
-  }
-  if (!shouldTraverse(value)) return paths;
-  if (Array.isArray(value)) {
-    value.forEach((item, index) => {
-      findSnapshotPaths(item, [...path, index], paths);
-    });
-  } else {
-    for (const [key, propertyValue] of Object.entries(value)) {
-      if (key === "children") continue;
-      findSnapshotPaths(propertyValue, [...path, key], paths);
-    }
-  }
-  return paths;
-}
-function getAtPath(object, path) {
-  let current = object;
-  for (const segment of path) {
-    if (current === null || current === void 0) return void 0;
-    current = current[segment];
-  }
-  return current;
-}
-function setAtPath(object, path, value) {
-  if (path.length === 0) return value;
-  const head = path[0];
-  if (head === void 0) throw new Error("setAtPath: non-empty path yielded no head segment");
-  const tail = path.slice(1);
-  const current = object[head];
-  const updated = setAtPath(current, tail, value);
-  if (Array.isArray(object)) {
-    const clone = [...object];
-    clone[head] = updated;
-    return clone;
-  }
-  return { ...object, [head]: updated };
-}
-var targetCache = /* @__PURE__ */ new WeakMap();
-function useResnapshotAll(snapshots) {
-  const lastRendered = useRef([]);
-  const lastReturned = useRef([]);
-  const nextProxies = snapshots.map((snap) => snap.op.proxy);
-  const [proxies, setProxies] = useState(nextProxies);
-  const isStale = proxies.length !== nextProxies.length || proxies.some((proxied, index) => proxied !== nextProxies[index]);
-  if (isStale) setProxies(nextProxies);
-  const trackings = useMemo(() => proxies.map(() => ({ affected: /* @__PURE__ */ new WeakMap(), proxyCache: /* @__PURE__ */ new WeakMap() })), [proxies]);
-  const getSnapshot = useCallback(() => {
-    const next = proxies.map((proxied) => snapshot(proxied));
-    const last = lastReturned.current;
-    if (last.length === next.length && last.every((snap, index) => snap === next[index])) return last;
-    lastReturned.current = next;
-    return next;
-  }, [proxies]);
-  const subscribe$1 = useCallback(
-    (callback) => {
-      const unsubscribes = proxies.map(
-        (proxied, index) => subscribe(proxied, () => {
-          const prev = lastRendered.current[index];
-          const tracking = trackings[index];
-          if (prev && tracking && prev !== snapshot(proxied)) {
-            if (!tracking.affected.has(prev)) return;
-            try {
-              if (!isChanged(prev, snapshot(proxied), tracking.affected, /* @__PURE__ */ new WeakMap())) return;
-            } catch {
-            }
-          }
-          callback();
-        })
-      );
-      return () => {
-        for (const unsubscribe of unsubscribes) unsubscribe();
-      };
-    },
-    [proxies, trackings]
-  );
-  const freshSnapshots = useSyncExternalStore(subscribe$1, getSnapshot);
-  useLayoutEffect(() => {
-    lastRendered.current = freshSnapshots;
-  });
-  const trackedSnapshots = useMemo(
-    () => freshSnapshots.map((snap, index) => {
-      const tracking = trackings[index];
-      if (!tracking) return snap;
-      return createProxy(snap, tracking.affected, tracking.proxyCache, targetCache);
-    }),
-    [freshSnapshots, trackings]
-  );
-  return isStale ? snapshots : trackedSnapshots;
-}
-function resnapshot(component) {
-  const componentName = component.displayName ?? component.name;
-  const Resnapshotted = (props) => {
-    const snapshotPaths = useMemo(() => findSnapshotPaths(props), [props]);
-    const staleSnapshots = useMemo(() => snapshotPaths.map((path) => getAtPath(props, path)).filter(isState), [props, snapshotPaths]);
-    const freshSnapshots = useResnapshotAll(staleSnapshots);
-    const freshProps = useMemo(() => {
-      if (freshSnapshots === staleSnapshots) return props;
-      return snapshotPaths.reduce((acc, path, index) => setAtPath(acc, path, freshSnapshots[index]), props);
-    }, [props, snapshotPaths, staleSnapshots, freshSnapshots]);
-    return component(freshProps);
-  };
-  Resnapshotted.displayName = `resnapshot(${componentName === "" ? "Anonymous" : componentName})`;
-  return memo(Resnapshotted);
-}
-var useCreateGroup = () => useState(() => createGroup())[0];
-var useCreateState = (define, group) => {
-  const created = useState(() => group ? group.createState(define) : createState(define))[0];
-  const [fresh] = useResnapshotAll([created]);
-  return fresh;
-};
-
-export { resnapshot, useCreateGroup, useCreateState };