@trioforge/crucible 0.0.0-stage → 0.1.0

package/out/internal/binding.luau

@@ -0,0 +1,610 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local runtimeDiagnostic = TS.import(script, script.Parent, "diagnostics").runtimeDiagnostic
+local _construction_claim = TS.import(script, script.Parent, "construction-claim")
+local clearClaim = _construction_claim.clearClaim
+local setClaim = _construction_claim.setClaim
+local _lifecycle = TS.import(script, script.Parent, "lifecycle")
+local drain = _lifecycle.drain
+local fault = _lifecycle.fault
+local hasEnded = _lifecycle.hasEnded
+local isDraining = _lifecycle.isDraining
+local isLive = _lifecycle.isLive
+local notePairs = _lifecycle.notePairs
+local request = _lifecycle.request
+local track = _lifecycle.track
+local recordOf = TS.import(script, script.Parent, "registry").recordOf
+local call = TS.import(script, script.Parent, "runner").call
+local installed
+local pairsByRecord = {}
+local wrongClasses = {}
+local byTag = {}
+local queued = {}
+local scheduled = false
+local getWarnings = {}
+local scopeRejected = false
+local scopeTarget
+local function port()
+	return installed or error("Crucible binding used before boot")
+end
+--* @internal 
+local function useEngine(engine)
+	installed = engine
+end
+--* @internal 
+local function defaultAccepts(instance)
+	local ok = port().bindingScope(instance)
+	if not ok and instance == scopeTarget then
+		scopeRejected = true
+	end
+	return ok
+end
+--* @internal 
+local function construct(state)
+	local record = state.record
+	local _exp = record.resolved
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	local _callback = function(dep)
+		local _result
+		if dep.all then
+			_result = dep.set
+		else
+			local _result_1 = dep.record.state
+			if _result_1 ~= nil then
+				_result_1 = _result_1.object
+			end
+			_result = _result_1
+		end
+		return _result
+	end
+	for _k, _v in _exp do
+		_newValue[_k] = _callback(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local args = _newValue
+	local worker
+	local result, value = call(function()
+		worker = coroutine.running()
+		setClaim(state)
+		return record.klass.new(unpack(args))
+	end, nil, nil, state)
+	-- The constructor worker can be cancelled before its own cleanup runs.
+	if worker ~= nil then
+		clearClaim(worker)
+	end
+	if result ~= 0 then
+		error(value, 0)
+	end
+	return value
+end
+local function pairFor(record, instance)
+	local _record = record
+	local instances = pairsByRecord[_record]
+	if instances == nil then
+		instances = {}
+		local _record_1 = record
+		local _instances = instances
+		pairsByRecord[_record_1] = _instances
+	end
+	local _instances = instances
+	local _instance = instance
+	local pair = _instances[_instance]
+	if pair == nil then
+		local _object = {
+			record = record,
+			instance = instance,
+			queued = false,
+			parked = false,
+			running = false,
+			reset = false,
+			rejected = nil,
+		}
+		local _left = "wrongClass"
+		local _record_1 = record
+		local _result = wrongClasses[_record_1]
+		if _result ~= nil then
+			local _instance_1 = instance
+			_result = _result[_instance_1] ~= nil
+		end
+		local _condition = _result
+		if _condition == nil then
+			_condition = false
+		end
+		_object[_left] = _condition
+		_object.warnings = {}
+		pair = _object
+		local _instances_1 = instances
+		local _instance_1 = instance
+		local _pair = pair
+		_instances_1[_instance_1] = _pair
+	end
+	return pair
+end
+local function queue(pair)
+	if pair.running then
+		return nil
+	end
+	if pair.rejected == "accepts" then
+		pair.rejected = nil
+	end
+	if pair.parked then
+		pair.parked = false
+		pair.queued = false
+	end
+	if not pair.queued then
+		pair.queued = true
+		local _queued = queued
+		local _pair = pair
+		table.insert(_queued, _pair)
+	end
+	notePairs()
+end
+local function schedule()
+	if scheduled then
+		return nil
+	end
+	scheduled = true
+	port().defer(function()
+		scheduled = false
+		drain()
+	end)
+end
+local function disconnect(pair)
+	local connections = pair.connections
+	pair.connections = nil
+	if connections ~= nil then
+		for _, stop in connections do
+			stop()
+		end
+	end
+end
+local function warning(pair, field, condition, message)
+	local _warnings = pair.warnings
+	local _field = field
+	if _warnings[_field] == condition then
+		return nil
+	end
+	local _warnings_1 = pair.warnings
+	local _field_1 = field
+	local _condition = condition
+	_warnings_1[_field_1] = _condition
+	runtimeDiagnostic("warning", message)
+end
+local function valueFor(pair, field, state)
+	local _descriptor = pair.record.attributes
+	if _descriptor ~= nil then
+		local _field = field
+		_descriptor = _descriptor[_field]
+	end
+	local descriptor = _descriptor
+	if descriptor == nil then
+		return true, nil
+	end
+	local value = port().getAttribute(pair.instance, descriptor.name)
+	local valid = if value == nil then not descriptor.required else descriptor.check(value)
+	if valid then
+		local _warnings = pair.warnings
+		local _field = field
+		_warnings[_field] = nil
+		return true, value
+	end
+	local condition = typeof(value)
+	warning(pair, field, condition, `{pair.record.id} on {port().describe(pair.instance)}: attribute {descriptor.name} is invalid ({condition}); {if state == nil then "not bound" else "keeping the last valid value"}`)
+	return false, value
+end
+--* @internal 
+local function applyAttribute(state, field)
+	local record = state.record
+	if record.kind ~= 1 or state.instance == nil or state.attributes == nil then
+		return nil
+	end
+	local pair = pairFor(record, state.instance)
+	local valid, value = valueFor(pair, field, state)
+	if not valid then
+		return nil
+	end
+	state.attributes[field] = value
+	if state.object ~= nil then
+		(state.object)[field] = value
+	end
+end
+local reset
+local function connect(pair)
+	if pair.connections ~= nil then
+		return nil
+	end
+	local _binding = pair
+	local record = _binding.record
+	local instance = _binding.instance
+	pair.connections = { port().onAncestryChanged(instance, function()
+		if not port().inWorld(instance) then
+			reset(pair)
+		end
+		queue(pair)
+		schedule()
+	end) }
+	for field, descriptor in record.attributes or {} do
+		local _connections = pair.connections
+		local _arg0 = port().onAttributeChanged(instance, descriptor.name, function()
+			local state = record.bound[instance]
+			if state ~= nil and not hasEnded(state) then
+				applyAttribute(state, field)
+			else
+				queue(pair)
+				schedule()
+			end
+		end)
+		table.insert(_connections, _arg0)
+	end
+	local state = record.bound[instance]
+	if state ~= nil then
+		for field in record.attributes or {} do
+			applyAttribute(state, field)
+		end
+	end
+end
+function reset(pair)
+	pair.reset = true
+	local _suppressed = pair.record.suppressed
+	local _instance = pair.instance
+	_suppressed[_instance] = nil
+	table.clear(pair.warnings)
+	disconnect(pair)
+end
+local function callAccepts(klass, instance)
+	return klass:accepts(instance)
+end
+local function accepted(pair, state)
+	local result, value = call(callAccepts, pair.record.klass, pair.instance, state)
+	if result == 0 then
+		return value == true
+	end
+	local _suppressed = pair.record.suppressed
+	local _instance = pair.instance
+	_suppressed[_instance] = true
+	if state ~= nil then
+		fault(state, 7, value)
+	else
+		runtimeDiagnostic("error", `{pair.record.id}.accepts failed on {port().describe(pair.instance)}: {value}`)
+	end
+	return false
+end
+local function evaluate(pair)
+	local _binding = pair
+	local record = _binding.record
+	local instance = _binding.instance
+	local engine = port()
+	pair.rejected = nil
+	local present = engine.inWorld(instance) and engine.hasTag(instance, record.tag)
+	if not present then
+		reset(pair)
+	end
+	local have = record.bound[instance]
+	if have ~= nil then
+		if present then
+			connect(pair)
+		end
+		if pair.reset or not present or record.suppressed[instance] ~= nil then
+			request(have, 2)
+			return nil
+		end
+		scopeRejected = false
+		scopeTarget = instance
+		local ok = accepted(pair, have)
+		if not ok then
+			pair.rejected = if scopeRejected then "scope" else "accepts"
+		end
+		if not ok or pair.reset or not engine.inWorld(instance) or not engine.hasTag(instance, record.tag) or record.suppressed[instance] ~= nil then
+			request(have, 2)
+		end
+		return nil
+	end
+	if pair.reset then
+		pair.reset = false
+		record.suppressed[instance] = nil
+	end
+	if not present then
+		local _result = pairsByRecord[record]
+		if _result ~= nil then
+			_result[instance] = nil
+		end
+		return nil
+	end
+	connect(pair)
+	if record.suppressed[instance] ~= nil then
+		return nil
+	end
+	local _exp = record.instanceClasses
+	-- ▼ ReadonlyArray.some ▼
+	local _result = false
+	local _callback = function(name)
+		return engine.isA(instance, name)
+	end
+	for _k, _v in _exp do
+		if _callback(_v, _k - 1, _exp) then
+			_result = true
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.some ▲
+	if not _result then
+		pair.rejected = "class"
+		if not pair.wrongClass then
+			pair.wrongClass = true
+			local warned = wrongClasses[record]
+			if warned == nil then
+				warned = setmetatable({}, {
+					__mode = "k",
+				})
+				local _warned = warned
+				wrongClasses[record] = _warned
+			end
+			warned[instance] = true
+			local _exp_1 = string.split(record.id, ":")
+			-- ▼ Array.pop ▼
+			local _length = #_exp_1
+			local _result_1 = _exp_1[_length]
+			_exp_1[_length] = nil
+			-- ▲ Array.pop ▲
+			local _condition = _result_1
+			if _condition == nil then
+				_condition = record.id
+			end
+			local className = _condition
+			runtimeDiagnostic("warning", `{engine.describe(instance)} is a {instance.ClassName}; {className} needs a {table.concat(record.instanceClasses, " or ")}`)
+		end
+		return nil
+	end
+	local attributes = {}
+	local valid = true
+	for field in record.attributes or {} do
+		local ok, value = valueFor(pair, field)
+		if not ok then
+			valid = false
+		end
+		attributes[field] = value
+	end
+	if not valid then
+		pair.rejected = "attributes"
+		return nil
+	end
+	scopeRejected = false
+	scopeTarget = instance
+	if not accepted(pair) then
+		pair.rejected = if scopeRejected then "scope" else "accepts"
+		return nil
+	end
+	if pair.reset or not engine.inWorld(instance) or not engine.hasTag(instance, record.tag) or record.suppressed[instance] ~= nil then
+		return nil
+	end
+	local state = track(record, instance, attributes)
+	record.bound[instance] = state
+	return state
+end
+--* @internal 
+local function reconcile()
+	local taken = queued
+	queued = {}
+	local created = {}
+	for _, pair in taken do
+		pair.queued = false
+		pair.running = true
+		local state = evaluate(pair)
+		pair.running = false
+		local _condition = pair.reset
+		if _condition then
+			local _bound = pair.record.bound
+			local _instance = pair.instance
+			_condition = not (_bound[_instance] ~= nil)
+		end
+		if _condition then
+			queue(pair)
+		end
+		if state ~= nil then
+			table.insert(created, state)
+		end
+	end
+	return created
+end
+--* @internal 
+local function watch(records)
+	local connections = {}
+	for _, record in records do
+		local _tag = record.tag
+		local list = byTag[_tag]
+		if list == nil then
+			local _tag_1 = record.tag
+			local _arg1 = { record }
+			byTag[_tag_1] = _arg1
+		else
+			table.insert(list, record)
+		end
+	end
+	for tag, records in byTag do
+		local _arg0 = port().onTagAdded(tag, function(instance)
+			for _, record in records do
+				queue(pairFor(record, instance))
+			end
+			schedule()
+		end)
+		table.insert(connections, _arg0)
+		local _arg0_1 = port().onTagRemoved(tag, function(instance)
+			for _, record in records do
+				local pair = pairFor(record, instance)
+				reset(pair)
+				queue(pair)
+			end
+			schedule()
+		end)
+		table.insert(connections, _arg0_1)
+		for _, instance in port().tagged(tag) do
+			for _1, record in records do
+				queue(pairFor(record, instance))
+			end
+		end
+	end
+	return function()
+		for _, stop in connections do
+			stop()
+		end
+		for _, instances in pairsByRecord do
+			for _1, pair in instances do
+				disconnect(pair)
+			end
+		end
+		table.clear(byTag)
+	end
+end
+--* @internal 
+local function refresh(instance)
+	for tag, records in byTag do
+		for _, record in records do
+			local _condition = port().hasTag(instance, tag)
+			if not _condition then
+				local _bound = record.bound
+				local _instance = instance
+				_condition = _bound[_instance] ~= nil
+			end
+			if _condition then
+				queue(pairFor(record, instance))
+			end
+		end
+	end
+	drain()
+end
+--* @internal 
+local function boundTo(klass, instance)
+	local record = recordOf(klass)
+	if record == nil or record.kind ~= 1 then
+		return nil
+	end
+	local pair = pairFor(record, instance)
+	if isDraining() then
+		local _bound = record.bound
+		local _instance = instance
+		local state = _bound[_instance]
+		local attributesValid = true
+		if pair.rejected == "attributes" then
+			for _, descriptor in record.attributes or {} do
+				local value = port().getAttribute(instance, descriptor.name)
+				if if value == nil then descriptor.required else not descriptor.check(value) then
+					attributesValid = false
+				end
+			end
+		end
+		local _condition = (state == nil or not isLive(state)) and (pair.rejected == nil or (pair.rejected == "attributes" and attributesValid) or (pair.rejected == "scope" and port().bindingScope(instance))) and port().inWorld(instance) and port().hasTag(instance, record.tag)
+		if _condition then
+			local _suppressed = record.suppressed
+			local _instance_1 = instance
+			_condition = not (_suppressed[_instance_1] ~= nil)
+		end
+		if _condition then
+			local source, line = debug.info(3, "sl")
+			local site = `{source}:{line}`
+			if not (getWarnings[site] ~= nil) then
+				getWarnings[site] = true
+				runtimeDiagnostic("warning", `Crucible get pending at {site}`)
+			end
+		end
+		local rejected = pair.rejected
+		queue(pair)
+		pair.rejected = rejected
+	else
+		queue(pair)
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(other)
+			return other ~= pair
+		end
+		local _length = 0
+		for _k, _v in queued do
+			if _callback(_v, _k - 1, queued) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		local held = _newValue
+		for _, other in held do
+			other.parked = true
+		end
+		queued = { pair }
+		drain()
+		local _array = {}
+		local _length_1 = #_array
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue_1 = {}
+		local _callback_1 = function(other)
+			return other.parked
+		end
+		local _length_2 = 0
+		for _k, _v in held do
+			if _callback_1(_v, _k - 1, held) == true then
+				_length_2 += 1
+				_newValue_1[_length_2] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		local _Length = #_newValue_1
+		table.move(_newValue_1, 1, _Length, _length_1 + 1, _array)
+		_length_1 += _Length
+		table.move(queued, 1, #queued, _length_1 + 1, _array)
+		queued = _array
+		for _, other in held do
+			other.parked = false
+		end
+		if #queued > 0 then
+			notePairs()
+			schedule()
+		end
+	end
+	local _bound = record.bound
+	local _instance = instance
+	return _bound[_instance]
+end
+--* @internal 
+local function remove(state)
+	local record = state.record
+	if record.kind == 1 and state.instance ~= nil and not hasEnded(state) then
+		local _suppressed = record.suppressed
+		local _instance = state.instance
+		_suppressed[_instance] = true
+	end
+	request(state, 2)
+end
+--* @internal 
+local function forget(state)
+	local record = state.record
+	if record.kind ~= 1 or state.instance == nil then
+		return nil
+	end
+	local _bound = record.bound
+	local _instance = state.instance
+	if _bound[_instance] == state then
+		local _bound_1 = record.bound
+		local _instance_1 = state.instance
+		_bound_1[_instance_1] = nil
+	end
+	local pair = pairFor(record, state.instance)
+	if state.phase == 5 and not pair.reset then
+		local _suppressed = record.suppressed
+		local _instance_1 = state.instance
+		_suppressed[_instance_1] = true
+	end
+	if pair.reset then
+		queue(pair)
+	end
+end
+return {
+	useEngine = useEngine,
+	defaultAccepts = defaultAccepts,
+	construct = construct,
+	applyAttribute = applyAttribute,
+	reconcile = reconcile,
+	watch = watch,
+	refresh = refresh,
+	boundTo = boundTo,
+	remove = remove,
+	forget = forget,
+}

package/out/internal/boot.d.ts

@@ -0,0 +1 @@
+export {};