feat: add deep freeze flag, misc refactors

Author: littensy

benches/patch.bench.luau

@@ -1,4 +1,6 @@
-local CharmSync = require("../packages/charm-sync/src")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local CharmSync = require(ReplicatedStorage.packages["charm-sync"].src)
 
 local patch = CharmSync.patch
 

packages/charm/src/__tests__/core/atom.spec.luau

@@ -0,0 +1,40 @@
+local core = require("../../core")
+local suite = require("../../../../../test/suite")
+
+local atom = core.atom
+local effect = core.effect
+local test = suite.test
+
+test("should accept equality function", function()
+	local calls = {}
+	local src = atom(0, function(current, incoming)
+		return current == incoming or incoming % 2 == 1
+	end)
+
+	effect(function()
+		table.insert(calls, src())
+	end)
+
+	src(2)
+	src(3)
+	assert(src() == 2, "should skip odd value")
+
+	src(4)
+	src(5)
+	assert(src() == 4, "should skip odd value")
+	assert(table.concat(calls) == "024", `should only call on even updates, got {table.concat(calls)}`)
+end)
+
+test("should enforce immutability", function()
+	local src = atom({ nested = {} })
+	assert(not pcall(function()
+		src().nested.a = 1
+	end), "should not allow mutation of initial value")
+
+	src({ nested = { a = 1 } })
+	assert(not pcall(function()
+		src().nested.a = 2
+	end), "should not allow mutation of new value")
+end)
+
+return {}

packages/charm/src/__tests__/core/computed.spec.luau

@@ -1,8 +1,9 @@
 local core = require("../../core")
 local suite = require("../../../../../test/suite")
 
-local computed = core.computed
 local atom = core.atom
+local computed = core.computed
+local effect = core.effect
 local test = suite.test
 
 test("should correctly propagate changes through computed core", function()
@@ -80,4 +81,27 @@ test("should not update if the atom value is reverted", function()
 	assert(times == 1, "computed ran when it should not")
 end)
 
+test("should accept equality function", function()
+	local calls = {}
+	local src = atom(0)
+	local c1 = computed(function()
+		return src()
+	end, function(current, incoming)
+		return current == incoming or incoming % 2 == 1
+	end)
+
+	effect(function()
+		table.insert(calls, c1())
+	end)
+
+	src(2)
+	src(3)
+	assert(c1() == 2, "should skip odd value")
+
+	src(4)
+	src(5)
+	assert(c1() == 4, "should skip odd value")
+	assert(table.concat(calls) == "024", `should only call on even updates, got {table.concat(calls)}`)
+end)
+
 return {}

packages/charm/src/__tests__/core/gc.spec.luau

@@ -8,49 +8,44 @@ local effectScope = core.effectScope
 local test = suite.test
 
 --- Creates a weak reference to a value.
---- @return Function to dereference the value.
-local function weakRef<T>(value: T): () -> T?
-	local ref = setmetatable({ value = value }, { __mode = "v" })
-	return function()
-		return ref.value
-	end
+local function weakRef<T>(value: T): { value: T? }
+	return setmetatable({ value = value }, { __mode = "v" }) :: any
 end
 
---- Triggers garbage collection by allocating excessive memory.
+--- Triggers garbage collection by creating a large number of tables.
 local function gc()
 	for _ = 1, 1000 do
 		local _ = table.create(100, 0)
 	end
 end
 
 --- In alien-signals, a computed value unlinks from dependencies when its last
---- parent scope is disposed. Calling a computed value outside of a scope links
---- it to dependencies, but the dependencies hold strong references to the
---- computed value, so it won't GC until called in a scope and disposed.
+--- parent scope is disposed. However, calling a computed value outside of a
+--- scope still links it to dependencies, which act as strong references.
+--- Computed values called in this way won't GC until unlinked from a scope.
 ---
 --- This function releases a computed value by linking it to a scope and then
 --- immediately closing it, causing alien-signals to unlink the computed value
---- and allow it to be garbage collected.
-local function release(getter: () -> ())
+--- from its dependencies and allow it to be garbage collected.
+local function unlink(getter: () -> ())
 	effectScope(function()
 		getter()
 	end)()
 end
 
 test("should release computed cache", function()
 	local srcRef = weakRef({})
-	local src = atom(srcRef())
-
+	local src = atom(srcRef.value)
 	local c = computed(function()
 		return src()
 	end)
 
 	c() -- cache src value
 	src(nil) -- release value
-	c = release(c) -- release computed
+	c = unlink(c) -- release computed
 
 	gc()
-	assert(srcRef() == nil, "should release computed cache")
+	assert(srcRef.value == nil, "should release computed cache")
 end)
 
 test("should not release effect for atom", function()
@@ -61,7 +56,6 @@ test("should not release effect for atom", function()
 		effectCalls += 1
 		src()
 	end)
-
 	assert(effectCalls == 1, "should call effect once")
 
 	gc()

packages/charm/src/__tests__/core/issue_48.spec.luau

@@ -98,4 +98,21 @@ test("should track inner subs", function()
 	assert(table.concat(order) == "", `bad order: {table.concat(order)}`)
 end)
 
+test("should skip redundant updates", function()
+	local order = {}
+	local a = atom(0)
+
+	listen(function(): "even" | "odd"
+		return if a() % 2 == 0 then "even" else "odd"
+	end, function(value)
+		table.insert(order, value)
+	end)
+
+	a(1)
+	a(3)
+	a(4)
+	a(6)
+	assert(table.concat(order) == "evenoddeven", `bad order: {table.concat(order)}`)
+end)
+
 return {}