@larablox/monolog 0.1.0

package/out/Monolog/Utils.luau

@@ -0,0 +1,181 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Utils`.
+	 *
+	 * Not ported: `getClass` (no PHP class-name reflection to normalize -- callers
+	 * that need "what kind of value is this" use `typeOf`/`tostring` directly),
+	 * `substr`/`canonicalizePath` (mbstring- and filesystem-specific), and
+	 * `expandIniShorthandBytes`/`detectAndCleanUtf8` (`php.ini` shorthand and
+	 * mbstring UTF-8 repair, neither of which apply on this platform).
+	 
+]]
+--* A table produced by `markAsJsonObject` always encodes as `{}`, even empty. 
+local FORCE_OBJECT_KEY = "__monolog_json_object__"
+--[[
+	*
+	 * Marks a table so `jsonEncode` renders it as a JSON object (`{}`) rather than
+	 * an array (`[]`) when it is empty. Luau tables can't tell an empty array from
+	 * an empty object apart the way PHP's `\stdClass` vs `[]` can -- see
+	 * `JsonFormatter.ts`, which is the one caller that needs this.
+	 
+]]
+local function markAsJsonObject(value)
+	value[FORCE_OBJECT_KEY] = true
+	return value
+end
+local function isForcedObject(value)
+	return value[FORCE_OBJECT_KEY] == true
+end
+local function escapeJsonString(value)
+	local out = string.gsub(value, "\\", "\\\\")
+	out = string.gsub(out, '"', '\\"')
+	out = string.gsub(out, "\n", "\\n")
+	out = string.gsub(out, "\r", "\\r")
+	out = string.gsub(out, "\t", "\\t")
+	return out
+end
+local function encodeNumber(value)
+	if value ~= value then
+		return '"NaN"'
+	end
+	if value == math.huge then
+		return '"INF"'
+	end
+	if value == -math.huge then
+		return '"-INF"'
+	end
+	return tostring(value)
+end
+local function indent(depth, pretty)
+	local _result
+	if pretty then
+		local _depth = depth
+		_result = string.rep("    ", _depth)
+	else
+		_result = ""
+	end
+	return _result
+end
+local wrapList, wrapObject
+local function encodeValue(value, pretty, depth)
+	if value == nil then
+		return "null"
+	end
+	local _value = value
+	if type(_value) == "string" then
+		return `"{escapeJsonString(value)}"`
+	end
+	local _value_1 = value
+	if type(_value_1) == "number" then
+		return encodeNumber(value)
+	end
+	local _value_2 = value
+	if type(_value_2) == "boolean" then
+		return if value then "true" else "false"
+	end
+	local _value_3 = value
+	if not (type(_value_3) == "table") then
+		-- No object/resource system to reflect on -- render anything else, such
+		-- as a function or an opaque instance, the way an unrecognized PHP value
+		-- would end up rendered: as a string.
+		return `"{escapeJsonString(tostring(value))}"`
+	end
+	local bag = value
+	local list = value
+	local forceObject = isForcedObject(bag)
+	if not forceObject and #list > 0 then
+		local items = {}
+		for _, item in list do
+			local _arg0 = encodeValue(item, pretty, depth + 1)
+			table.insert(items, _arg0)
+		end
+		return wrapList(items, pretty, depth)
+	end
+	local keys = {}
+	for key in pairs(bag) do
+		if key == FORCE_OBJECT_KEY then
+			continue
+		end
+		local _arg0 = tostring(key)
+		table.insert(keys, _arg0)
+	end
+	table.sort(keys)
+	if #keys == 0 then
+		-- An empty Luau table is indistinguishable from an empty array, so it
+		-- defaults to encoding as `[]` -- matching PHP's own `json_encode([])`,
+		-- which is what upstream relies on for an empty context/extra bag.
+		-- `markAsJsonObject` opts a specific empty table into `{}` instead
+		-- (see `JsonFormatter.ts`, the one caller that needs that).
+		return if forceObject then "{}" else "[]"
+	end
+	local pieces = {}
+	for _, key in keys do
+		local encodedValue = encodeValue(bag[key], pretty, depth + 1)
+		local separator = if pretty then ": " else ":"
+		local _arg0 = `{indent(depth + 1, pretty)}"{escapeJsonString(key)}"{separator}{encodedValue}`
+		table.insert(pieces, _arg0)
+	end
+	return wrapObject(pieces, pretty, depth)
+end
+function wrapList(items, pretty, depth)
+	if #items == 0 then
+		return "[]"
+	end
+	if not pretty then
+		return `[{table.concat(items, ",")}]`
+	end
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#items)
+	local _callback = function(item)
+		return `{indent(depth + 1, true)}{item}`
+	end
+	for _k, _v in items do
+		_newValue[_k] = _callback(_v, _k - 1, items)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local inner = table.concat(_newValue, ",\n")
+	return `[\n{inner}\n{indent(depth, true)}]`
+end
+function wrapObject(pieces, pretty, depth)
+	if not pretty then
+		return `\{{table.concat(pieces, ",")}\}`
+	end
+	return `\{\n{table.concat(pieces, ",\n")}\n{indent(depth, true)}\}`
+end
+local Utils
+do
+	Utils = setmetatable({}, {
+		__tostring = function()
+			return "Utils"
+		end,
+	})
+	Utils.__index = Utils
+	function Utils.new(...)
+		local self = setmetatable({}, Utils)
+		return self:constructor(...) or self
+	end
+	function Utils:constructor()
+	end
+	function Utils:jsonEncode(data, pretty)
+		if pretty == nil then
+			pretty = false
+		end
+		return encodeValue(data, pretty, 0)
+	end
+	function Utils:getRecordMessageForException(record)
+		local context = ""
+		local extra = ""
+		if (next(record.context)) ~= nil then
+			context = `\nContext: {Utils:jsonEncode(record.context)}`
+		end
+		if (next(record.extra)) ~= nil then
+			extra = `\nExtra: {Utils:jsonEncode(record.extra)}`
+		end
+		return `\nThe exception occurred while attempting to log: {record.message}{context}{extra}`
+	end
+end
+return {
+	markAsJsonObject = markAsJsonObject,
+	Utils = Utils,
+}

package/out/index.d.ts

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

package/package.json

@@ -0,0 +1,51 @@
+{
+    "$schema": "https://www.schemastore.org/package.json",
+    "name": "@larablox/monolog",
+    "version": "0.1.0",
+    "description": "The Larablox port of Monolog.",
+    "license": "MIT",
+    "keywords": ["monolog", "logging", "larablox", "roblox-ts"],
+    "homepage": "https://github.com/larablox/monolog",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/larablox/monolog.git"
+    },
+    "bugs": {
+        "url": "https://github.com/larablox/monolog/issues"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": ["out/Monolog", "out/index.d.ts"],
+    "types": "out/index.d.ts",
+    "type": "module",
+    "scripts": {
+        "build": "rbxtsc",
+        "test:build": "rbxtsc -p tsconfig.tests.json --rojo test.project.json",
+        "test:watch": "npm run test:build -- -w",
+        "test:serve": "rojo serve test.project.json",
+        "clean": "rimraf out out-tests include sourcemap.json tsconfig.tsbuildinfo",
+        "watch": "rbxtsc -w",
+        "dev": "npm run watch",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "types:roblox": "curl -sSL -o globalTypes.None.d.luau https://raw.githubusercontent.com/JohnnyMorganz/luau-lsp/main/scripts/globalTypes.None.d.luau",
+        "sourcemap": "rojo sourcemap default.project.json --output sourcemap.json",
+        "analyze": "npm run build && npm run sourcemap && luau-lsp analyze --platform=roblox --sourcemap=sourcemap.json --definitions=globalTypes.None.d.luau --base-luaurc=.luaurc --settings=luau-lsp.settings.json --ignore=\"**/include/**\" --ignore=\"**/node_modules/**\" out"
+    },
+    "devDependencies": {
+        "@rbxts/compiler-types": "^3.0.0-types.0",
+        "@rbxts/testez": "^0.4.2-ts.0",
+        "@rbxts/types": "^1.0.943",
+        "@typescript-eslint/eslint-plugin": "^8.67.0",
+        "@typescript-eslint/parser": "^8.67.0",
+        "eslint": "^10.8.1",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-prettier": "^5.5.6",
+        "eslint-plugin-roblox-ts": "^1.4.1",
+        "prettier": "^3.9.6",
+        "rimraf": "^6.1.3",
+        "roblox-ts": "^3.0.0",
+        "typescript": "^5.9.3"
+    }
+}