@dnd-kit/state 0.0.1

package/README.md

@@ -0,0 +1,5 @@
+# @dnd-kit/state
+
+[![Stable release](https://img.shields.io/npm/v/@dnd-kit/state.svg)](https://npm.im/@dnd-kit/state)
+
+Internal state management library for @dnd-kit

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { ReadonlySignal } from '@preact/signals-core';
+export { ReadonlySignal, Signal, batch, effect, signal, untracked } from '@preact/signals-core';
+
+declare function computed<T>(compute: () => T, comparator?: (a: T, b: T) => boolean): ReadonlySignal<T>;
+
+declare function deepEqual<T>(a: T, b: T): boolean;
+
+declare function reactive(target: Object, propertyKey: string): void;
+declare function derived(target: Object, propertyKey: string, descriptor: PropertyDescriptor): void;
+
+type CleanupFunction = () => void;
+type Effect = () => CleanupFunction | void;
+
+declare function effects(...entries: Effect[]): CleanupFunction;
+
+export { CleanupFunction, Effect, computed, deepEqual, derived, effects, reactive };

package/dist/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Signal: () => import_signals_core4.Signal,
+  batch: () => import_signals_core4.batch,
+  computed: () => computed,
+  deepEqual: () => deepEqual,
+  derived: () => derived,
+  effect: () => import_signals_core4.effect,
+  effects: () => effects,
+  reactive: () => reactive,
+  signal: () => import_signals_core4.signal,
+  untracked: () => import_signals_core4.untracked
+});
+module.exports = __toCommonJS(src_exports);
+var import_signals_core4 = require("@preact/signals-core");
+
+// src/computed.ts
+var import_signals_core = require("@preact/signals-core");
+function computed(compute, comparator) {
+  if (comparator) {
+    let previousValue;
+    return (0, import_signals_core.computed)(() => {
+      const value = compute();
+      if (value && previousValue && comparator(previousValue, value)) {
+        return previousValue;
+      }
+      previousValue = value;
+      return value;
+    });
+  }
+  return (0, import_signals_core.computed)(compute);
+}
+
+// src/comparators.ts
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false;
+    }
+    if (a.length !== b.length) {
+      return false;
+    }
+    const hasDifferentValues = a.some(
+      (value, index) => !deepEqual(value, b[index])
+    );
+    return !hasDifferentValues;
+  }
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/decorators.ts
+var import_signals_core2 = require("@preact/signals-core");
+function reactive(target, propertyKey) {
+  const store = /* @__PURE__ */ new WeakMap();
+  Object.defineProperty(target, propertyKey, {
+    get() {
+      if (!store.get(this)) {
+        store.set(this, (0, import_signals_core2.signal)(void 0));
+      }
+      const stored = store.get(this);
+      const value = stored == null ? void 0 : stored.value;
+      return value;
+    },
+    set(value) {
+      const stored = store.get(this);
+      if (stored) {
+        if (stored.peek() !== value) {
+          stored.value = value;
+        }
+        return;
+      }
+      store.set(this, (0, import_signals_core2.signal)(value));
+    }
+  });
+}
+function derived(target, propertyKey, descriptor) {
+  const store = /* @__PURE__ */ new WeakMap();
+  const compute = descriptor.get;
+  Object.defineProperty(target, propertyKey, {
+    get() {
+      if (!compute) {
+        return void 0;
+      }
+      if (!store.get(this)) {
+        store.set(this, computed(compute.bind(this)));
+      }
+      const stored = store.get(this);
+      const value = stored == null ? void 0 : stored.value;
+      return value;
+    }
+  });
+}
+
+// src/effects.ts
+var import_signals_core3 = require("@preact/signals-core");
+function effects(...entries) {
+  const effects2 = entries.map(import_signals_core3.effect);
+  return () => effects2.forEach((cleanup) => cleanup());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Signal,
+  batch,
+  computed,
+  deepEqual,
+  derived,
+  effect,
+  effects,
+  reactive,
+  signal,
+  untracked
+});

package/dist/index.mjs

@@ -0,0 +1,113 @@
+// src/index.ts
+import {
+  batch,
+  effect as effect2,
+  untracked,
+  signal as signal2,
+  Signal
+} from "@preact/signals-core";
+
+// src/computed.ts
+import {
+  computed as computedSignal
+} from "@preact/signals-core";
+function computed(compute, comparator) {
+  if (comparator) {
+    let previousValue;
+    return computedSignal(() => {
+      const value = compute();
+      if (value && previousValue && comparator(previousValue, value)) {
+        return previousValue;
+      }
+      previousValue = value;
+      return value;
+    });
+  }
+  return computedSignal(compute);
+}
+
+// src/comparators.ts
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false;
+    }
+    if (a.length !== b.length) {
+      return false;
+    }
+    const hasDifferentValues = a.some(
+      (value, index) => !deepEqual(value, b[index])
+    );
+    return !hasDifferentValues;
+  }
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/decorators.ts
+import { signal } from "@preact/signals-core";
+function reactive(target, propertyKey) {
+  const store = /* @__PURE__ */ new WeakMap();
+  Object.defineProperty(target, propertyKey, {
+    get() {
+      if (!store.get(this)) {
+        store.set(this, signal(void 0));
+      }
+      const stored = store.get(this);
+      const value = stored == null ? void 0 : stored.value;
+      return value;
+    },
+    set(value) {
+      const stored = store.get(this);
+      if (stored) {
+        if (stored.peek() !== value) {
+          stored.value = value;
+        }
+        return;
+      }
+      store.set(this, signal(value));
+    }
+  });
+}
+function derived(target, propertyKey, descriptor) {
+  const store = /* @__PURE__ */ new WeakMap();
+  const compute = descriptor.get;
+  Object.defineProperty(target, propertyKey, {
+    get() {
+      if (!compute) {
+        return void 0;
+      }
+      if (!store.get(this)) {
+        store.set(this, computed(compute.bind(this)));
+      }
+      const stored = store.get(this);
+      const value = stored == null ? void 0 : stored.value;
+      return value;
+    }
+  });
+}
+
+// src/effects.ts
+import { effect } from "@preact/signals-core";
+function effects(...entries) {
+  const effects2 = entries.map(effect);
+  return () => effects2.forEach((cleanup) => cleanup());
+}
+export {
+  Signal,
+  batch,
+  computed,
+  deepEqual,
+  derived,
+  effect2 as effect,
+  effects,
+  reactive,
+  signal2 as signal,
+  untracked
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dnd-kit/state",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --external react",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts --external react",
+    "lint": "TIMING=1 eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "dependencies": {
+    "@preact/signals-core": "^1.6.0",
+    "tslib": "^2.6.2"
+  },
+  "devDependencies": {
+    "@dnd-kit/eslint-config": "*",
+    "eslint": "^8.38.0",
+    "tsup": "^6.7.0",
+    "typescript": "^5.0.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}