@potmot/diff 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pot-mot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @potmot/diff
+
+简单的差异对比工具库，支持对象、数组的差异分析。
+
+## 功能特性
+
+- ✨ 深度相等比较 (`deepEquals`)
+- 📊 对象差异分析 (`objectDiff`)
+- 📋 数组差异分析 (`arrayDiff`)
+- 🔁 循环引用检测
+- 📤 TypeScript 类型支持
+
+## 安装
+
+```bash
+npm install @potmot/diff
+```
+
+```bash
+yarn add @potmot/diff
+```
+
+```bash
+pnpm add @potmot/diff
+```

package/dist/arrayDiff.d.ts

@@ -0,0 +1,2 @@
+import { ArrayDiff } from './type/DiffItem';
+export declare const arrayDiff: <T extends Record<string, unknown>>(prevList: ReadonlyArray<T> | undefined | null, nextList: ReadonlyArray<T> | undefined | null, matchFnList: ((a: T, b: T) => boolean)[], deepMatchFnList?: ((a: any, b: any) => boolean)[], visitedOld?: WeakSet<object>, visitedNew?: WeakSet<object>) => ArrayDiff<T>;

package/dist/deepEquals.d.ts

@@ -0,0 +1 @@
+export declare const deepEquals: (a: any, b: any) => boolean;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { deepEquals } from './deepEquals';
+export { arrayDiff } from './arrayDiff';
+export { objectDiff } from './objectDiff';

package/dist/index.js

@@ -0,0 +1,150 @@
+const j = (t, e) => {
+  if (t === e)
+    return !0;
+  if (t === null || e === null || t === void 0 || e === void 0)
+    return t === e;
+  if (typeof t != typeof e)
+    return !1;
+  if (typeof t != "object")
+    return t === e;
+  if (Array.isArray(t) && Array.isArray(e)) {
+    if (t.length !== e.length)
+      return !1;
+    for (let o = 0; o < t.length; o++)
+      if (!j(t[o], e[o]))
+        return !1;
+    return !0;
+  }
+  if (Array.isArray(t) || Array.isArray(e))
+    return !1;
+  const i = Object.keys(t), s = Object.keys(e);
+  if (i.length !== s.length)
+    return !1;
+  for (const o of i)
+    if (!s.includes(o) || !j(t[o], e[o]))
+      return !1;
+  return !0;
+}, v = (t, e, i = [j], s = /* @__PURE__ */ new WeakSet(), o = /* @__PURE__ */ new WeakSet()) => {
+  if ((t == null || Object.keys(t).length === 0) && (e == null || Object.keys(e).length === 0))
+    return { type: "object" };
+  if (t == null || typeof t != "object") {
+    const r = {};
+    return e != null && typeof e == "object" && Object.keys(e).forEach((f) => {
+      const n = f;
+      r[n] = {
+        propertyName: n,
+        value: e[n]
+      };
+    }), { type: "object", added: r };
+  }
+  if (e == null || typeof e != "object") {
+    const r = {};
+    return Object.keys(t).forEach((f) => {
+      const n = f;
+      r[n] = {
+        propertyName: n,
+        value: t[n]
+      };
+    }), { type: "object", deleted: r };
+  }
+  if (typeof t == "object") {
+    if (s.has(t))
+      return { type: "circular reference" };
+    s.add(t);
+  }
+  if (typeof e == "object") {
+    if (o.has(e))
+      return { type: "circular reference" };
+    o.add(e);
+  }
+  const p = { type: "object" }, c = {};
+  for (const r in t)
+    r in e || (c[r] = {
+      propertyName: r,
+      value: t[r]
+    });
+  Object.keys(c).length > 0 && (p.deleted = c);
+  const a = {};
+  for (const r in e)
+    r in t || (a[r] = {
+      propertyName: r,
+      value: e[r]
+    });
+  Object.keys(a).length > 0 && (p.added = a);
+  const h = {};
+  for (const r in t)
+    if (r in e) {
+      const f = r, n = r;
+      if (!j(t[f], e[n])) {
+        const y = t[f], d = e[n];
+        let u;
+        Array.isArray(y) && Array.isArray(d) ? u = x(y, d, i, i) : typeof y == "object" && typeof d == "object" && y !== null && d !== null && y !== void 0 && d !== void 0 && (u = v(y, d, i, s, o)), h[r] = {
+          propertyName: r,
+          prevValue: t[f],
+          nextValue: e[n],
+          diff: u
+        };
+      }
+    }
+  return Object.keys(h).length > 0 && (p.updated = h), p;
+}, x = (t, e, i, s = [j], o = /* @__PURE__ */ new WeakSet(), p = /* @__PURE__ */ new WeakSet()) => {
+  const c = {
+    type: "array",
+    added: [],
+    updated: [],
+    deleted: [],
+    moved: [],
+    equals: []
+  };
+  if (!t && !e)
+    return c;
+  if (!t)
+    return e?.forEach((r, f) => {
+      c.added.push({ data: r, nextIndex: f });
+    }), c;
+  if (!e)
+    return t?.forEach((r, f) => {
+      c.deleted.push({ data: r, prevIndex: f });
+    }), c;
+  const a = new Set(t.map((r, f) => ({ item: r, index: f }))), h = new Set(e.map((r, f) => ({ item: r, index: f })));
+  for (const r of i)
+    for (const f of a) {
+      const { item: n, index: y } = f;
+      let d;
+      for (const u of h)
+        r(n, u.item) && (d = u);
+      if (d !== void 0) {
+        const { item: u, index: k } = d;
+        if (j(n, u))
+          y === k ? c.equals.push({
+            data: u,
+            index: k
+          }) : c.moved.push({
+            data: u,
+            prevIndex: y,
+            nextIndex: k
+          });
+        else {
+          const A = Array.isArray(n) && Array.isArray(u) ? x(n, u, s, s, o, p) : typeof n == "object" && typeof u == "object" ? v(n, u, s, o, p) : void 0;
+          c.updated.push({
+            prevData: n,
+            prevIndex: y,
+            nextData: u,
+            nextIndex: k,
+            diff: A
+          });
+        }
+        a.delete(f), h.delete(d);
+      }
+    }
+  return a.forEach(({ item: r, index: f }) => {
+    c.deleted.push({ data: r, prevIndex: f });
+  }), h.forEach(({ item: r, index: f }) => {
+    c.added.push({ data: r, nextIndex: f });
+  }), c;
+};
+export {
+  x as arrayDiff,
+  j as deepEquals,
+  v as objectDiff
+};

package/dist/index.umd.cjs

@@ -0,0 +1 @@
+(function(p,u){typeof exports=="object"&&typeof module<"u"?u(exports):typeof define=="function"&&define.amd?define(["exports"],u):(p=typeof globalThis<"u"?globalThis:p||self,u(p["@potmot/diff"]={}))})(this,(function(p){"use strict";const u=(t,e)=>{if(t===e)return!0;if(t===null||e===null||t===void 0||e===void 0)return t===e;if(typeof t!=typeof e)return!1;if(typeof t!="object")return t===e;if(Array.isArray(t)&&Array.isArray(e)){if(t.length!==e.length)return!1;for(let o=0;o<t.length;o++)if(!u(t[o],e[o]))return!1;return!0}if(Array.isArray(t)||Array.isArray(e))return!1;const a=Object.keys(t),s=Object.keys(e);if(a.length!==s.length)return!1;for(const o of a)if(!s.includes(o)||!u(t[o],e[o]))return!1;return!0},v=(t,e,a=[u],s=new WeakSet,o=new WeakSet)=>{if((t==null||Object.keys(t).length===0)&&(e==null||Object.keys(e).length===0))return{type:"object"};if(t==null||typeof t!="object"){const r={};return e!=null&&typeof e=="object"&&Object.keys(e).forEach(f=>{const n=f;r[n]={propertyName:n,value:e[n]}}),{type:"object",added:r}}if(e==null||typeof e!="object"){const r={};return Object.keys(t).forEach(f=>{const n=f;r[n]={propertyName:n,value:t[n]}}),{type:"object",deleted:r}}if(typeof t=="object"){if(s.has(t))return{type:"circular reference"};s.add(t)}if(typeof e=="object"){if(o.has(e))return{type:"circular reference"};o.add(e)}const h={type:"object"},i={};for(const r in t)r in e||(i[r]={propertyName:r,value:t[r]});Object.keys(i).length>0&&(h.deleted=i);const j={};for(const r in e)r in t||(j[r]={propertyName:r,value:e[r]});Object.keys(j).length>0&&(h.added=j);const k={};for(const r in t)if(r in e){const f=r,n=r;if(!u(t[f],e[n])){const y=t[f],c=e[n];let d;Array.isArray(y)&&Array.isArray(c)?d=l(y,c,a,a):typeof y=="object"&&typeof c=="object"&&y!==null&&c!==null&&y!==void 0&&c!==void 0&&(d=v(y,c,a,s,o)),k[r]={propertyName:r,prevValue:t[f],nextValue:e[n],diff:d}}}return Object.keys(k).length>0&&(h.updated=k),h},l=(t,e,a,s=[u],o=new WeakSet,h=new WeakSet)=>{const i={type:"array",added:[],updated:[],deleted:[],moved:[],equals:[]};if(!t&&!e)return i;if(!t)return e?.forEach((r,f)=>{i.added.push({data:r,nextIndex:f})}),i;if(!e)return t?.forEach((r,f)=>{i.deleted.push({data:r,prevIndex:f})}),i;const j=new Set(t.map((r,f)=>({item:r,index:f}))),k=new Set(e.map((r,f)=>({item:r,index:f})));for(const r of a)for(const f of j){const{item:n,index:y}=f;let c;for(const d of k)r(n,d.item)&&(c=d);if(c!==void 0){const{item:d,index:m}=c;if(u(n,d))y===m?i.equals.push({data:d,index:m}):i.moved.push({data:d,prevIndex:y,nextIndex:m});else{const b=Array.isArray(n)&&Array.isArray(d)?l(n,d,s,s,o,h):typeof n=="object"&&typeof d=="object"?v(n,d,s,o,h):void 0;i.updated.push({prevData:n,prevIndex:y,nextData:d,nextIndex:m,diff:b})}j.delete(f),k.delete(c)}}return j.forEach(({item:r,index:f})=>{i.deleted.push({data:r,prevIndex:f})}),k.forEach(({item:r,index:f})=>{i.added.push({data:r,nextIndex:f})}),i};p.arrayDiff=l,p.deepEquals=u,p.objectDiff=v,Object.defineProperty(p,Symbol.toStringTag,{value:"Module"})}));

package/dist/objectDiff.d.ts

@@ -0,0 +1,2 @@
+import { CircularReferenceDiff, ObjectDiff } from './type/DiffItem';
+export declare const objectDiff: <T extends Record<string, unknown>, U extends Record<string, unknown> = T>(oldVal: T | undefined | null, newVal: U | undefined | null, deepMatchFnList?: ((a: any, b: any) => boolean)[], visitedOld?: WeakSet<object>, visitedNew?: WeakSet<object>) => ObjectDiff<T, U> | CircularReferenceDiff;

package/dist/type/DeepReadonly.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 深度只读类型 - 将对象及其所有嵌套属性都设置为只读
+ * 处理了多种特殊情况，包括数组、函数、Map、Set等
+ */
+export type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends ReadonlyMap<infer K, infer V> | Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlySet<infer U> | Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends ReadonlyArray<infer U> | Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;

package/dist/type/DiffItem.d.ts

@@ -0,0 +1,61 @@
+export type CircularReferenceDiff = {
+    type: "circular reference";
+};
+export type ObjectDiff<T extends Record<string, unknown>, U extends Record<string, unknown> = T> = {
+    type: "object";
+    updated?: {
+        [K in keyof T & keyof U]?: PropertyUpdatedDiffItem<T, U, K>;
+    };
+    added?: {
+        [K in Exclude<keyof U, keyof T>]?: PropertyAddedDiffItem<U, K>;
+    };
+    deleted?: {
+        [K in Exclude<keyof T, keyof U>]?: PropertyDeletedDiffItem<T, K>;
+    };
+};
+export type PropertyAddedDiffItem<T extends Record<string, unknown>, K extends keyof T = keyof T> = {
+    propertyName: K;
+    value: T[K];
+};
+export type PropertyDeletedDiffItem<T extends Record<string, unknown>, K extends keyof T = keyof T> = {
+    propertyName: K;
+    value: T[K];
+};
+export type PropertyUpdatedDiffItem<T extends Record<string, unknown>, U extends Record<string, unknown> = T, K extends (keyof T & keyof U) = (keyof T & keyof U)> = {
+    propertyName: K;
+    prevValue: T[K];
+    nextValue: U[K];
+    diff?: (T[K] & U[K]) extends Array<infer Item> | ReadonlyArray<infer Item> ? ArrayDiff<Item> : (T[K] & U[K]) extends Record<string, unknown> ? ObjectDiff<T[K] & U[K], T[K] & U[K]> | CircularReferenceDiff : never;
+};
+export type ArrayAddedDiffItem<T> = {
+    data: T;
+    nextIndex: number;
+};
+export type ArrayUpdatedDiffItem<T> = {
+    prevData: T;
+    prevIndex: number;
+    nextData: T;
+    nextIndex: number;
+    diff: T extends Array<infer Item> | ReadonlyArray<infer Item> ? ArrayDiff<Item> : T extends Record<string, unknown> ? ObjectDiff<T> | CircularReferenceDiff : never;
+};
+export type ArrayDeletedDiffItem<T> = {
+    data: T;
+    prevIndex: number;
+};
+export type ArrayMovedDiffItem<T> = {
+    data: T;
+    prevIndex: number;
+    nextIndex: number;
+};
+export type ArrayEqualsDiffItem<T> = {
+    data: T;
+    index: number;
+};
+export type ArrayDiff<T> = {
+    type: "array";
+    added: ArrayAddedDiffItem<T>[];
+    updated: ArrayUpdatedDiffItem<T>[];
+    deleted: ArrayDeletedDiffItem<T>[];
+    moved: ArrayMovedDiffItem<T>[];
+    equals: ArrayEqualsDiffItem<T>[];
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@potmot/diff",
+  "private": false,
+  "version": "0.0.0",
+  "description": "Lightweight deep diff tool for JavaScript objects and arrays.",
+  "keywords": ["diff"],
+  "homepage": "https://github.com/pot-mot/diff/blob/main/README.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pot-mot/diff.git",
+    "directory": "dist"
+  },
+  "bugs": {
+    "url": "https://github.com/pot-mot/diff/issues"
+  },
+  "type": "module",
+  "license": "MIT",
+  "author": "potmot",
+  "main": "./dist/index.umd.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.cjs"
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "package.json",
+    "README.md",
+    "LICENSE",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc & vite build",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.5",
+    "@types/node": "^25.2.3",
+    "typescript": "~5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18"
+  }
+}