@rbxts/diff 1.0.0

package/README.md

@@ -0,0 +1,27 @@
+# @rbxts/diff
+
+[![CI Status](https://github.com/R-unic/diff/actions/workflows/test.yml/badge.svg)](https://github.com/R-unic/diff/actions/workflows)
+[![Coverage Status](https://coveralls.io/repos/github/R-unic/diff/badge.svg?branch=master)](https://coveralls.io/github/R-unic/diff)
+
+Calculate diffs between objects and apply diffs to objects
+
+## Example
+
+```ts
+import { createDiff, applyDiff } from "@rbxts/diff";
+
+interface Foo {
+  readonly blah?: string;
+  readonly bar: {
+    readonly baz: number;
+  };
+}
+
+const a: Foo = { blah: "yas", bar: { baz: 420 } };
+const b: Foo = { bar: { baz: 69 } };
+const diff = createDiff(a, b);
+print(diff) // { changed = { bar = { baz = 69 } }, removed = { blah = true } }
+
+const newObject = applyDiff(a, diff); // this will turn a into b
+print(newObject) // { bar = { baz = 69 } }
+```

package/out/index.d.ts

@@ -0,0 +1,23 @@
+type GenericRecord = Record<string | number, unknown>;
+type Primitive = string | number | boolean | undefined;
+type Length<T> = T extends {
+    length: infer N extends number;
+} ? N : never;
+type IsTuple<T> = T extends readonly unknown[] ? Length<T> extends never ? false : true : false;
+type NonSymbolKeys<T> = Exclude<keyof T, symbol>;
+type DeepPartial<T> = T extends Primitive ? T : T extends readonly (infer U)[] ? IsTuple<T> extends true ? {
+    readonly [K in keyof T]?: DeepPartial<T[K]>;
+} : readonly DeepPartial<U>[] : T extends object ? {
+    readonly [K in NonSymbolKeys<T>]?: DeepPartial<T[K]>;
+} : T;
+type RemovalTag<T> = true | (T extends object ? DeepKeys<T> : never);
+type DeepKeys<T> = T extends readonly (infer U)[] ? readonly (RemovalTag<U> | undefined)[] : {
+    readonly [K in NonSymbolKeys<T>]?: RemovalTag<T[K]>;
+};
+export interface Diff<T> {
+    readonly changed?: DeepPartial<T>;
+    readonly removed?: DeepKeys<T>;
+}
+export declare function createDiff<T extends GenericRecord | unknown[]>(oldData: T, newData: T): Diff<T>;
+export declare function applyDiff<T extends {}>(base: T, diff: Diff<T>): T;
+export {};

package/out/init.luau

@@ -0,0 +1,104 @@
+-- Compiled with roblox-ts v3.0.0
+local function createDiff(oldData, newData)
+	if oldData == newData then
+		return {}
+	end
+	local _oldData = oldData
+	local _arg0 = type(_oldData) == "table"
+	assert(_arg0, "attempt to create diff of non-table objects")
+	local _newData = newData
+	local _arg0_1 = type(_newData) == "table"
+	assert(_arg0_1, "attempt to create diff of non-table objects")
+	local changed = {}
+	local removed = {}
+	for key in pairs(oldData) do
+		if newData[key] ~= nil then
+			continue
+		end
+		removed[key] = true
+	end
+	for key, newValue in pairs(newData) do
+		local oldValue = oldData[key]
+		if oldValue == nil then
+			changed[key] = newValue
+			continue
+		end
+		if (not (type(oldValue) == "table") or not (type(newValue) == "table")) and oldValue ~= newValue then
+			changed[key] = newValue
+			continue
+		end
+		local childDiff = createDiff(oldValue, newValue)
+		if childDiff.changed ~= nil then
+			changed[key] = childDiff.changed or newValue
+		end
+		if childDiff.removed ~= nil then
+			removed[key] = childDiff.removed
+		end
+	end
+	local changedCount = 0
+	local removedCount = 0
+	for _element, _element_1 in pairs(changed) do
+		local _ = { _element, _element_1 }
+		changedCount += 1
+	end
+	for _element, _element_1 in pairs(removed) do
+		local _ = { _element, _element_1 }
+		removedCount += 1
+	end
+	return {
+		changed = if changedCount > 0 then changed else nil,
+		removed = if removedCount > 0 then removed else nil,
+	}
+end
+local function applyDiff(base, diff)
+	local _base = base
+	local _arg0 = type(_base) == "table"
+	assert(_arg0, "attempt to apply diff to non-table object")
+	local result = table.clone(base)
+	if diff.removed ~= nil then
+		for key, value in pairs(diff.removed) do
+			if value == true then
+				result[key] = nil
+				continue
+			end
+			local _exp = base[key]
+			local _object = {}
+			local _left = "changed"
+			local _result = diff.changed
+			if _result ~= nil then
+				_result = _result[key]
+			end
+			_object[_left] = _result
+			local _left_1 = "removed"
+			local _result_1 = diff.removed
+			if _result_1 ~= nil then
+				_result_1 = _result_1[key]
+			end
+			_object[_left_1] = _result_1
+			result[key] = applyDiff(_exp, _object)
+		end
+	end
+	if diff.changed ~= nil then
+		for key, value in pairs(diff.changed) do
+			local baseValue = base[key]
+			if not (type(value) == "table") or not (type(baseValue) == "table") then
+				result[key] = value
+				continue
+			end
+			local _removed = diff.removed
+			if _removed ~= nil then
+				_removed = _removed[key]
+			end
+			local removed = _removed
+			result[key] = applyDiff(baseValue, {
+				changed = value,
+				removed = removed,
+			})
+		end
+	end
+	return result
+end
+return {
+	createDiff = createDiff,
+	applyDiff = applyDiff,
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@rbxts/diff",
+  "version": "1.0.0",
+  "description": "Calculate diffs between objects and apply diffs to objects",
+  "author": "runicly",
+  "main": "out/init.lua",
+  "scripts": {
+    "setup-rokit": "rokit trust lune-org/lune && rokit trust rojo-rbx/rojo && rokit install",
+    "build": "npm run setup-rokit && rbxtsc ",
+    "dev": "npm run build -- -w",
+    "prepublishOnly": "npm test",
+    "test": "npm run build && npm run build -- -p tests && rojo build tests -o tests/test-environment.rbxl && lune run tests tests/test-environment.rbxl",
+    "coverage": "nyc report && lune run fix-lcov-paths"
+  },
+  "keywords": [
+    "roblox",
+    "rbxts",
+    "diff"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/R-unic/diff.git"
+  },
+  "license": "ISC",
+  "types": "out/index.d.ts",
+  "files": [
+    "out",
+    "!**/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@rbxts/compiler-types": "^3.0.0-types.0",
+    "@rbxts/types": "^1.0.919",
+    "nyc": "^17.1.0",
+    "roblox-ts": "=3.0.0",
+    "typescript": "=5.5.3"
+  }
+}