mirror of
https://github.com/littensy/charm.git
synced 2026-10-20 17:51:37 +00:00
124 lines
3.7 KiB
Text
124 lines
3.7 KiB
Text
local Charm = require("../Charm")
|
|
local config = require("./config")
|
|
local types = require("./types")
|
|
local validate = require("./validate")
|
|
|
|
local globals = Charm.globals
|
|
|
|
export type None = types.None
|
|
|
|
--- A special symbol that denotes the absence of a value. Used to represent
|
|
--- deleted values in patches.
|
|
local None: None = { __none = "__none" }
|
|
|
|
--- Checks whether a value is `None`. If `true`, the value is scheduled to be
|
|
--- removed from the state when the patch is applied.
|
|
---
|
|
--- @param value The value to check.
|
|
--- @return `true` if the value is `None`, otherwise `false`.
|
|
local function isNone(value: any): boolean
|
|
return type(value) == "table" and value.__none == "__none"
|
|
end
|
|
|
|
--- Converts `nil` values to the special `None` symbol. This is useful when
|
|
--- preparing data for serialization, since `nil` can represent both the absence
|
|
--- of a value and the removal of a value in patches.
|
|
local function nilToNone<T>(value: T?): T | None
|
|
return if value == nil then None else value
|
|
end
|
|
|
|
--- JSON serialization can drop the last values of a sparse array. For example,
|
|
--- `{ [1] = 1, [3] = 3 }` becomes `[1]` in some cases. Ambiguity in the
|
|
--- serialization of sparse arrays can be resolved by converting them to
|
|
--- dictionaries with string keys.
|
|
---
|
|
--- The `apply` function will convert these dictionaries back into arrays as
|
|
--- long as the target array is not sparse. This function ensures that the diff
|
|
--- function produces a patch that can be correctly applied.
|
|
local function stringifySparseArray(object: { any }): { [string | number]: any }
|
|
local maxn = table.maxn(object)
|
|
|
|
if maxn == 0 or maxn == #object then
|
|
-- The object is either not an array or a dense array
|
|
return object
|
|
end
|
|
|
|
local dictionary = {}
|
|
|
|
for index, value in object do
|
|
dictionary[tostring(index)] = value
|
|
end
|
|
|
|
return dictionary
|
|
end
|
|
|
|
--- Compares two states and returns a patch that can be applied to the current
|
|
--- state to produce the next state.
|
|
---
|
|
--- @param currentState The current state.
|
|
--- @param nextState The next state.
|
|
--- @return A patch that can be applied to the current state.
|
|
local function diff(currentState: any, nextState: any): any
|
|
if currentState == nextState then
|
|
return nil
|
|
elseif nextState == nil then
|
|
return None
|
|
elseif type(currentState) ~= "table" or type(nextState) ~= "table" then
|
|
return nextState
|
|
end
|
|
|
|
local patches: { [any]: any } = table.clone(nextState)
|
|
|
|
for key, previous in currentState do
|
|
patches[key] = diff(previous, nextState[key])
|
|
end
|
|
|
|
if config.fixArrays then
|
|
-- Convert sparse array patches that could be misserialized
|
|
if currentState[1] ~= nil or nextState[1] ~= nil then
|
|
patches = stringifySparseArray(patches)
|
|
end
|
|
|
|
if globals.strict and config.validatePatches then
|
|
validate(patches)
|
|
end
|
|
end
|
|
|
|
return patches
|
|
end
|
|
|
|
--- Applies a patch to a state and returns the resulting value.
|
|
---
|
|
--- @param currentState The current state.
|
|
--- @param statePatch The patches to apply.
|
|
--- @return The new state with the patch applied.
|
|
local function apply(currentState: any, statePatch: any): any
|
|
if isNone(statePatch) then
|
|
return nil
|
|
elseif type(currentState) ~= "table" or type(statePatch) ~= "table" then
|
|
return statePatch
|
|
end
|
|
|
|
local nextState = table.clone(currentState)
|
|
local stateIsArray = currentState[1] ~= nil
|
|
|
|
for key, value in statePatch do
|
|
-- Diff-checking an array produces a sparse array, which will not be
|
|
-- preserved when converted to JSON. To prevent this, we turn string
|
|
-- keys back into numeric keys.
|
|
if stateIsArray and type(key) == "string" then
|
|
key = tonumber(key) or key
|
|
end
|
|
|
|
nextState[key] = apply(nextState[key], value)
|
|
end
|
|
|
|
return nextState
|
|
end
|
|
|
|
return {
|
|
isNone = isNone,
|
|
nilToNone = nilToNone,
|
|
diff = diff,
|
|
apply = apply,
|
|
}
|