@bazir/utils 0.1.0 → 0.1.2

package/out/Network.d.ts

@@ -0,0 +1,54 @@
+import { ReactiveCache } from "@bazir/state/out/State";
+declare const SECRET: unique symbol;
+declare namespace NetworkSystem {
+    export function generateHash(input: string): string;
+    export function createId(stackLevel?: number): string;
+    export function createNetworkId(stackLevel?: number): string;
+    type SignalListener<T extends unknown[]> = (...args: T) => void;
+    type RemoteEvent<T extends unknown[]> = Instance & {
+        FireClient: (this: RemoteEvent<T>, player: Player, ...args: T) => void;
+        FireServer: (this: RemoteEvent<T>, ...args: T) => void;
+        FireAllClients: (this: RemoteEvent<T>, ...args: T) => void;
+        OnServerEvent: RBXScriptSignal<(player: Player, ...args: T) => void>;
+        OnClientEvent: RBXScriptSignal<(...args: T) => void>;
+    };
+    type RemoteFunction<TReq extends unknown[], TRes> = Instance & {
+        InvokeClient: (this: RemoteFunction<TReq, TRes>, player: Player, ...args: TReq) => TRes;
+        InvokeServer: (this: RemoteFunction<TReq, TRes>, ...args: TReq) => TRes;
+        OnServerInvoke: (player: Player, ...args: TReq) => TRes;
+        OnClientInvoke: (...args: TReq) => TRes;
+    };
+    type RequestHandler<TReq extends unknown[], TRes> = (...args: TReq) => TRes;
+    export function createEvent<T extends unknown[]>(level?: number, parent?: LuaSourceContainer): RemoteEvent<T>;
+    export function onServer<T extends unknown[]>(instance: RemoteEvent<T>, listener: SignalListener<[player: Player, ...T]>): void;
+    export function onClient<T extends unknown[]>(instance: RemoteEvent<T>, listener: SignalListener<T>): void;
+    export function fireServer<T extends unknown[]>(instance: RemoteEvent<T>, ...args: T): void;
+    export function fireClient<T extends unknown[]>(instance: RemoteEvent<T>, player: Player, ...args: T): void;
+    export function broadcast<T extends unknown[]>(instance: RemoteEvent<T>, ...args: T): void;
+    export function createFunction<TReq extends unknown[], TRes>(level?: number, parent?: LuaSourceContainer): RemoteFunction<TReq, TRes>;
+    export function handleServer<TReq extends unknown[], TRes>(instance: RemoteFunction<TReq, TRes>, handler: RequestHandler<[player: Player, ...TReq], TRes>): void;
+    export function handleClient<TReq extends unknown[], TRes>(instance: RemoteFunction<TReq, TRes>, handler: RequestHandler<TReq, TRes>): void;
+    export function invokeServer<TReq extends unknown[], TRes>(instance: RemoteFunction<TReq, TRes>, ...args: TReq): TRes;
+    export function invokeClient<TReq extends unknown[], TRes>(instance: RemoteFunction<TReq, TRes>, player: Player, ...args: TReq): TRes;
+    export function createReplica<T>(initialValue: T, level?: number): ReactiveCache<T>;
+    interface SecretCache<T> extends ReactiveCache<T> {
+        [SECRET]: {
+            active: Set<Player>;
+            players: Map<Player, T>;
+            event: RemoteEvent<unknown[]>;
+        };
+    }
+    export function createSecret<T>(initialValue: T, level?: number): SecretCache<T>;
+    export function writePlayer<T>(secretCache: SecretCache<T>, player: Player, secret: T): void;
+    export function peekPlayer<T>(secretCache: SecretCache<T>, player: Player): T;
+    export function lazy<T>(importFn: () => T | Promise<T>): () => T;
+    type ActionFunction<Args extends unknown[], Return> = (...args: Args) => Promise<Return>;
+    export type ServerAction<Args extends unknown[], Return> = ActionFunction<Args, Return> & {
+        pending: ReactiveCache<boolean>;
+        error: ReactiveCache<string | undefined>;
+    };
+    export function createAction<Args extends unknown[], Return>(fn: (player: Player, ...args: Args) => Return | Promise<Return>): RemoteFunction<Args, Return>;
+    export function useAction<Args extends unknown[], Return>(actionHandler: RemoteFunction<Args, Return>): ServerAction<Args, Return>;
+    export {};
+}
+export = NetworkSystem;

package/out/Network.luau

@@ -0,0 +1,434 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _Error = TS.import(script, TS.getModule(script, "@bazir", "core").out.Error)
+local report = _Error.report
+local createError = _Error.createError
+local _Platform = TS.import(script, TS.getModule(script, "@bazir", "core").out.Platform)
+local getDebugInfo = _Platform.getDebugInfo
+local isRunningOnServer = _Platform.isRunningOnServer
+local _State = TS.import(script, TS.getModule(script, "@bazir", "state").out.State)
+local value = _State.value
+local subscribe = _State.subscribe
+local peek = _State.peek
+local update = _State.update
+local write = _State.write
+local waitForOrCreate = TS.import(script, TS.getModule(script, "@bazir", "ui").out.Instance).waitForOrCreate
+local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
+--[[
+	*
+	 * Assigns a call signature to an object.
+	 *
+	 * @param callback The function to assign.
+	 * @param object The object to assign the function to.
+	 * @returns A callable object.
+	 
+]]
+local function callable(callback, object)
+	return setmetatable(object, {
+		__call = function(_, ...)
+			local args = { ... }
+			return callback(unpack(args))
+		end,
+	})
+end
+local SECRET = "__secret"
+local NetworkSystem = {}
+do
+	local _container = NetworkSystem
+	local NONE = {
+		__none = "__none",
+	}
+	local function isEmpty(state)
+		return next(state) == nil
+	end
+	local function isNone(state)
+		local _state = state
+		local _condition = type(_state) == "table"
+		if _condition then
+			_condition = state[NONE.__none] ~= nil
+		end
+		if _condition then
+			return state.__none == NONE.__none
+		end
+		return false
+	end
+	local function diff(prevState, nextState)
+		if prevState == nextState then
+			return nil
+		elseif nextState == nil then
+			return NONE
+		else
+			local _prevState = prevState
+			local _condition = not (type(_prevState) == "table")
+			if not _condition then
+				local _nextState = nextState
+				_condition = not (type(_nextState) == "table")
+			end
+			if _condition then
+				return nextState
+			elseif isEmpty(prevState) and isEmpty(nextState) then
+				return nil
+			end
+		end
+		local _object = {}
+		if nextState then
+			for _k, _v in nextState do
+				_object[_k] = _v
+			end
+		end
+		local patches = _object
+		for key, previous in pairs(prevState) do
+			patches[key] = diff(previous, nextState[key])
+		end
+		if isEmpty(patches) then
+			return nil
+		end
+		return patches
+	end
+	local function apply(state, patches)
+		if isNone(patches) then
+			return nil
+		else
+			local _state = state
+			local _condition = not (type(_state) == "table")
+			if not _condition then
+				local _patches = patches
+				_condition = not (type(_patches) == "table")
+			end
+			if _condition then
+				return patches
+			end
+		end
+		local _object = {}
+		if state then
+			for _k, _v in state do
+				_object[_k] = _v
+			end
+		end
+		local nextState = _object
+		local stateIsArray = nextState[1] ~= nil
+		-- eslint-disable-next-line prefer-const
+		for key, patch in pairs(patches) do
+			local _condition = stateIsArray
+			if _condition then
+				local _key = key
+				_condition = type(_key) == "string"
+			end
+			if _condition then
+				local _condition_1 = tonumber(key)
+				if _condition_1 == nil then
+					_condition_1 = key
+				end
+				key = _condition_1
+			end
+			nextState[key] = apply(nextState[key], patch)
+		end
+		return nextState
+	end
+	local identifierCounts = {}
+	local function getSourceLocation(level)
+		local scriptPath, lineNumber = getDebugInfo(level)
+		return `{scriptPath}:{lineNumber}`
+	end
+	local function getAndIncrementCount(location)
+		local _location = location
+		local _condition = identifierCounts[_location]
+		if _condition == nil then
+			_condition = 0
+		end
+		local currentCount = _condition
+		local _location_1 = location
+		local _arg1 = currentCount + 1
+		identifierCounts[_location_1] = _arg1
+		return currentCount
+	end
+	local function generateHash(input)
+		local hash = 0
+		for i = 0, #input - 1 do
+			local byteValue = string.byte(input, i + 1)
+			hash = (bit32.lshift(hash, 5)) - hash + byteValue
+			hash = bit32.band(hash, hash)
+		end
+		return tostring(math.abs(hash))
+	end
+	_container.generateHash = generateHash
+	local function createId(stackLevel)
+		if stackLevel == nil then
+			stackLevel = 0
+		end
+		local sourceLocation = getSourceLocation(stackLevel + 3)
+		local currentCount = getAndIncrementCount(sourceLocation)
+		return `{sourceLocation}-{currentCount}`
+	end
+	_container.createId = createId
+	local function createNetworkId(stackLevel)
+		if stackLevel == nil then
+			stackLevel = 0
+		end
+		return generateHash(createId(stackLevel + 1))
+	end
+	_container.createNetworkId = createNetworkId
+	local function createEvent(level, parent)
+		if level == nil then
+			level = 0
+		end
+		if parent == nil then
+			parent = script
+		end
+		local id = `Event@{createNetworkId(level + 1)}`
+		return waitForOrCreate("RemoteEvent", parent, id)
+	end
+	_container.createEvent = createEvent
+	local function onServer(instance, listener)
+		instance.OnServerEvent:Connect(listener)
+	end
+	_container.onServer = onServer
+	local function onClient(instance, listener)
+		instance.OnClientEvent:Connect(listener)
+	end
+	_container.onClient = onClient
+	local function fireServer(instance, ...)
+		local args = { ... }
+		instance:FireServer(unpack(args))
+	end
+	_container.fireServer = fireServer
+	local function fireClient(instance, player, ...)
+		local args = { ... }
+		instance:FireClient(player, unpack(args))
+	end
+	_container.fireClient = fireClient
+	local function broadcast(instance, ...)
+		local args = { ... }
+		instance:FireAllClients(unpack(args))
+	end
+	_container.broadcast = broadcast
+	local function createFunction(level, parent)
+		if level == nil then
+			level = 0
+		end
+		if parent == nil then
+			parent = script
+		end
+		local id = `Function@{createNetworkId(level + 1)}`
+		return waitForOrCreate("RemoteFunction", parent, id)
+	end
+	_container.createFunction = createFunction
+	local function handleServer(instance, handler)
+		instance.OnServerInvoke = handler
+	end
+	_container.handleServer = handleServer
+	local function handleClient(instance, handler)
+		instance.OnClientInvoke = handler
+	end
+	_container.handleClient = handleClient
+	local function invokeServer(instance, ...)
+		local args = { ... }
+		return instance:InvokeServer(unpack(args))
+	end
+	_container.invokeServer = invokeServer
+	local function invokeClient(instance, player, ...)
+		local args = { ... }
+		return instance:InvokeClient(player, unpack(args))
+	end
+	_container.invokeClient = invokeClient
+	local function createReplica(initialValue, level)
+		if level == nil then
+			level = 0
+		end
+		local connectPatches = createEvent(level + 1)
+		local applyPatches = createEvent(level + 1)
+		local state = value(initialValue)
+		if isRunningOnServer() then
+			local activePlayers = {}
+			Players.PlayerRemoving:Connect(function(player)
+				local _player = player
+				activePlayers[_player] = nil
+			end)
+			subscribe(state, function(newValue, prevValue)
+				local patches = diff(prevValue, newValue)
+				if patches == nil then
+					return nil
+				end
+				for player in activePlayers do
+					fireClient(applyPatches, player, patches)
+				end
+			end)
+			onServer(connectPatches, function(player)
+				local patches = diff(initialValue, peek(state))
+				if patches ~= nil then
+					fireClient(applyPatches, player, patches)
+				end
+				if player:IsDescendantOf(game) then
+					local _player = player
+					activePlayers[_player] = true
+				end
+			end)
+		else
+			onClient(applyPatches, function(patches)
+				update(state, function(current)
+					return apply(current, patches)
+				end)
+			end)
+			fireServer(connectPatches)
+		end
+		return state
+	end
+	_container.createReplica = createReplica
+	local function createSecret(initialValue, level)
+		if level == nil then
+			level = 0
+		end
+		local connectPatches = createEvent(level + 1)
+		local applyPatches = createEvent(level + 1)
+		local state = value(initialValue)
+		if isRunningOnServer() then
+			state[SECRET] = {
+				active = {},
+				players = {},
+				event = applyPatches,
+			}
+			local _binding = (state[SECRET])
+			local active = _binding.active
+			local players = _binding.players
+			Players.PlayerRemoving:Connect(function(player)
+				local _player = player
+				active[_player] = nil
+				local _player_1 = player
+				players[_player_1] = nil
+			end)
+			onServer(connectPatches, function(player)
+				local _exp = initialValue
+				local _player = player
+				local _condition = players[_player]
+				if _condition == nil then
+					_condition = peek(state)
+				end
+				local patches = diff(_exp, _condition)
+				if patches ~= nil then
+					fireClient(applyPatches, player, patches)
+				end
+				if player:IsDescendantOf(game) then
+					local _player_1 = player
+					active[_player_1] = true
+				end
+			end)
+		else
+			onClient(applyPatches, function(patches)
+				update(state, function(current)
+					return apply(current, patches)
+				end)
+			end)
+			fireServer(connectPatches)
+		end
+		return state
+	end
+	_container.createSecret = createSecret
+	local function writePlayer(secretCache, player, secret)
+		local _binding = secretCache[SECRET]
+		local active = _binding.active
+		local players = _binding.players
+		local event = _binding.event
+		local _player = player
+		if not (active[_player] ~= nil) then
+			return nil
+		end
+		local _player_1 = player
+		local _condition = players[_player_1]
+		if _condition == nil then
+			_condition = peek(secretCache)
+		end
+		local lastSecret = _condition
+		local patches = diff(lastSecret, secret)
+		if patches == nil then
+			local _player_2 = player
+			local _secret = secret
+			players[_player_2] = _secret
+			fireClient(event, player, patches)
+		end
+	end
+	_container.writePlayer = writePlayer
+	local function peekPlayer(secretCache, player)
+		local _binding = secretCache[SECRET]
+		local players = _binding.players
+		local _player = player
+		local _condition = players[_player]
+		if _condition == nil then
+			_condition = peek(secretCache)
+		end
+		return _condition
+	end
+	_container.peekPlayer = peekPlayer
+	local function lazy(importFn)
+		local cached
+		return function()
+			if not isRunningOnServer() then
+				error("lazy can only be called on the server")
+			end
+			if cached == nil then
+				local result = importFn()
+				cached = if TS.Promise.is(result) then result:expect() else result
+			end
+			return cached
+		end
+	end
+	_container.lazy = lazy
+	-- Create server action (server-side)
+	local function createAction(fn)
+		local handler = createFunction(1)
+		if isRunningOnServer() then
+			handleServer(handler, function(...)
+				local args = { ... }
+				local _exitType, _returns = TS.try(function()
+					local result = fn(unpack(args))
+					return TS.TRY_RETURN, { if TS.Promise.is(result) then result:expect() else result }
+				end, function(err)
+					report(createError(tostring(err), {
+						code = "SERVER_ACTION_FAILED",
+						context = {
+							args = args,
+						},
+					}))
+					error(err)
+				end)
+				if _exitType then
+					return unpack(_returns)
+				end
+			end)
+		end
+		return handler
+	end
+	_container.createAction = createAction
+	-- Create action caller (client-side)
+	local function useAction(actionHandler)
+		if isRunningOnServer() then
+			error("useAction can only be called on the client")
+		end
+		local pending = value(false)
+		local errorMessage = value(nil)
+		local actionCaller = TS.async(function(...)
+			local args = { ... }
+			write(pending, true)
+			write(errorMessage, nil)
+			local lastError
+			local _exitType, _returns = TS.try(function()
+				local result = invokeServer(actionHandler, unpack(args))
+				write(pending, false)
+				return TS.TRY_RETURN, { result }
+			end, function(err)
+				lastError = err
+			end)
+			if _exitType then
+				return unpack(_returns)
+			end
+			write(pending, false)
+			write(errorMessage, tostring(lastError))
+			error(lastError)
+		end)
+		return callable(actionCaller, {
+			pending = pending,
+			error = errorMessage,
+		})
+	end
+	_container.useAction = useAction
+end
+return NetworkSystem

package/out/index.d.ts

@@ -0,0 +1,6 @@
+import Network from './Network';
+export { Network };
+declare const _default: {
+    Network: typeof Network;
+};
+export default _default;

package/out/init.luau

@@ -0,0 +1,11 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Utility exports
+local Network = TS.import(script, script, "Network")
+local default = {
+	Network = Network,
+}
+return {
+	Network = Network,
+	default = default,
+}

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@bazir/utils",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Utility functions for Bazir framework",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
+  "main": "out/init.lua",
+  "types": "out/index.d.ts",
   "files": [
-    "dist",
+    "out",
     "!**/*.tsbuildinfo"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "git-checks": false
   },
   "keywords": [
     "roblox",
@@ -24,12 +21,18 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@bazir/core": "^0.1.0",
+    "@bazir/core": "^0.1.2",
+    "@bazir/state": "^0.1.2",
+    "@bazir/ui": "^0.1.2",
     "@rbxts/services": "^1.5.5"
   },
   "devDependencies": {
     "@rbxts/compiler-types": "3.0.0-types.0",
-    "@rbxts/types": "^1.0.813",
-    "typescript": "^5.7.2"
+    "@rbxts/types": "^1.0.840",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "build": "rbxtsc",
+    "watch": "rbxtsc -w"
   }
 }