@larablox/monolog 0.1.0

package/out/Monolog/Attribute/AsMonologProcessor.d.ts

@@ -0,0 +1,30 @@
+type Constructor = new (...args: Array<unknown>) => object;
+type Target = Constructor | object;
+/** PHP: `AsMonologProcessor`'s constructor parameters. */
+export interface AsMonologProcessorOptions {
+    /** The logging channel the processor should be pushed to. */
+    channel?: string;
+    /** The handler the processor should be pushed to. */
+    handler?: string;
+    /** The method that processes the records, if the decorator is used at the class level. */
+    method?: string;
+    /** The priority of the processor so the order can be determined. */
+    priority?: number;
+}
+/**
+ * PHP: `Monolog\Attribute\AsMonologProcessor`.
+ *
+ * A reusable class-or-method decorator to help configure a class or a method
+ * as a processor. Using it offers no guarantee: it needs to be leveraged by a
+ * Monolog third-party consumer. Using it with this library alone has no
+ * effect at all: processors still need to be turned into a callable and
+ * manually pushed to loggers and to processable handlers.
+ *
+ * PHP's `IS_REPEATABLE` lets the attribute be applied more than once to the
+ * same target; there is no attribute system here to grant that, so this
+ * stores an array of registrations per decorated target instead of one.
+ */
+export declare function AsMonologProcessor(options?: AsMonologProcessorOptions): (target: Target, propertyKey?: string) => void;
+/** Reads back every registration a class or method was decorated with. */
+export declare function getMonologProcessorRegistrations(target: Target): Array<AsMonologProcessorOptions>;
+export {};

package/out/Monolog/Attribute/AsMonologProcessor.luau

@@ -0,0 +1,59 @@
+-- Compiled with roblox-ts v3.0.0
+--* PHP: `AsMonologProcessor`'s constructor parameters. 
+local REGISTRATIONS = {}
+--[[
+	*
+	 * PHP: `Monolog\Attribute\AsMonologProcessor`.
+	 *
+	 * A reusable class-or-method decorator to help configure a class or a method
+	 * as a processor. Using it offers no guarantee: it needs to be leveraged by a
+	 * Monolog third-party consumer. Using it with this library alone has no
+	 * effect at all: processors still need to be turned into a callable and
+	 * manually pushed to loggers and to processable handlers.
+	 *
+	 * PHP's `IS_REPEATABLE` lets the attribute be applied more than once to the
+	 * same target; there is no attribute system here to grant that, so this
+	 * stores an array of registrations per decorated target instead of one.
+	 
+]]
+local function AsMonologProcessor(options)
+	if options == nil then
+		options = {}
+	end
+	return function(target, propertyKey)
+		local _object = {
+			channel = options.channel,
+			handler = options.handler,
+		}
+		local _left = "method"
+		local _condition = propertyKey
+		if _condition == nil then
+			_condition = options.method
+		end
+		_object[_left] = _condition
+		_object.priority = options.priority
+		local registration = _object
+		local _target = target
+		local _condition_1 = REGISTRATIONS[_target]
+		if _condition_1 == nil then
+			_condition_1 = {}
+		end
+		local existing = _condition_1
+		table.insert(existing, registration)
+		local _target_1 = target
+		REGISTRATIONS[_target_1] = existing
+	end
+end
+--* Reads back every registration a class or method was decorated with. 
+local function getMonologProcessorRegistrations(target)
+	local _target = target
+	local _condition = REGISTRATIONS[_target]
+	if _condition == nil then
+		_condition = {}
+	end
+	return _condition
+end
+return {
+	AsMonologProcessor = AsMonologProcessor,
+	getMonologProcessorRegistrations = getMonologProcessorRegistrations,
+}

package/out/Monolog/Attribute/WithMonologChannel.d.ts

@@ -0,0 +1,18 @@
+type Constructor = new (...args: Array<unknown>) => object;
+/**
+ * PHP: `Monolog\Attribute\WithMonologChannel`.
+ *
+ * A reusable class decorator to help configure a class as expecting a given
+ * logger channel. Using it offers no guarantee: it needs to be leveraged by a
+ * Monolog third-party consumer. Using it with this library alone has no
+ * effect at all: wiring a logger instance into other classes is not managed
+ * by Monolog.
+ *
+ * PHP attributes are read back through reflection; there is no reflection API
+ * on this platform, so the channel is recorded in a module-level map keyed by
+ * the decorated class instead, readable back with `getMonologChannel()`.
+ */
+export declare function WithMonologChannel(channel: string): (target: Constructor) => void;
+/** Reads back the channel a class was decorated with, if any. */
+export declare function getMonologChannel(target: Constructor): string | undefined;
+export {};

package/out/Monolog/Attribute/WithMonologChannel.luau

@@ -0,0 +1,33 @@
+-- Compiled with roblox-ts v3.0.0
+local CHANNELS = {}
+--[[
+	*
+	 * PHP: `Monolog\Attribute\WithMonologChannel`.
+	 *
+	 * A reusable class decorator to help configure a class as expecting a given
+	 * logger channel. Using it offers no guarantee: it needs to be leveraged by a
+	 * Monolog third-party consumer. Using it with this library alone has no
+	 * effect at all: wiring a logger instance into other classes is not managed
+	 * by Monolog.
+	 *
+	 * PHP attributes are read back through reflection; there is no reflection API
+	 * on this platform, so the channel is recorded in a module-level map keyed by
+	 * the decorated class instead, readable back with `getMonologChannel()`.
+	 
+]]
+local function WithMonologChannel(channel)
+	return function(target)
+		local _target = target
+		local _channel = channel
+		CHANNELS[_target] = _channel
+	end
+end
+--* Reads back the channel a class was decorated with, if any. 
+local function getMonologChannel(target)
+	local _target = target
+	return CHANNELS[_target]
+end
+return {
+	WithMonologChannel = WithMonologChannel,
+	getMonologChannel = getMonologChannel,
+}

package/out/Monolog/Formatter/FormatterInterface.d.ts

@@ -0,0 +1,8 @@
+import type { LogRecord } from "../LogRecord";
+/** PHP: `Monolog\Formatter\FormatterInterface`. */
+export interface FormatterInterface {
+    /** Formats a log record. */
+    format(record: LogRecord): string;
+    /** Formats a set of log records. */
+    formatBatch(records: Array<LogRecord>): string;
+}

package/out/Monolog/Formatter/FormatterInterface.luau

@@ -0,0 +1,3 @@
+-- Compiled with roblox-ts v3.0.0
+--* PHP: `Monolog\Formatter\FormatterInterface`. 
+return nil

package/out/Monolog/Formatter/HtmlFormatter.d.ts

@@ -0,0 +1,23 @@
+import { Level } from "../Level";
+import { NormalizerFormatter } from "./NormalizerFormatter";
+import type { LogRecord } from "../LogRecord";
+/**
+ * PHP: `Monolog\Formatter\HtmlFormatter`.
+ *
+ * There is no `htmlspecialchars()` on this platform; `escapeHtml()` below
+ * escapes the same characters PHP's `ENT_NOQUOTES` mode does (`&`, `<`, `>`),
+ * leaving single/double quotes alone exactly as `ENT_NOQUOTES` does.
+ */
+export declare class HtmlFormatter extends NormalizerFormatter {
+    /** Translates Monolog log levels to HTML color priorities. */
+    protected getLevelColor(level: Level): string;
+    /** Creates an HTML table row. */
+    protected addRow(th: string, td?: string, escapeTd?: boolean): string;
+    /** Create an HTML h1 tag. */
+    protected addTitle(title: string, level: Level): string;
+    /** Formats a log record. */
+    format(record: LogRecord): string;
+    /** Formats a set of log records. */
+    formatBatch(records: Array<LogRecord>): string;
+    protected convertToString(data: unknown): string;
+}

package/out/Monolog/Formatter/HtmlFormatter.luau

@@ -0,0 +1,128 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _Level = TS.import(script, script.Parent.Parent, "Level")
+local Level = _Level.Level
+local Levels = _Level.Levels
+local NormalizerFormatter = TS.import(script, script.Parent, "NormalizerFormatter").NormalizerFormatter
+local Utils = TS.import(script, script.Parent.Parent, "Utils").Utils
+local LEVEL_COLORS = {
+	[Level.Debug] = "#CCCCCC",
+	[Level.Info] = "#28A745",
+	[Level.Notice] = "#17A2B8",
+	[Level.Warning] = "#FFC107",
+	[Level.Error] = "#FD7E14",
+	[Level.Critical] = "#DC3545",
+	[Level.Alert] = "#821722",
+	[Level.Emergency] = "#000000",
+}
+local function escapeHtml(value)
+	local out = string.gsub(value, "&", "&")
+	out = string.gsub(out, "<", "&lt;")
+	out = string.gsub(out, ">", "&gt;")
+	return out
+end
+--[[
+	*
+	 * PHP: `Monolog\Formatter\HtmlFormatter`.
+	 *
+	 * There is no `htmlspecialchars()` on this platform; `escapeHtml()` below
+	 * escapes the same characters PHP's `ENT_NOQUOTES` mode does (`&`, `<`, `>`),
+	 * leaving single/double quotes alone exactly as `ENT_NOQUOTES` does.
+	 
+]]
+local HtmlFormatter
+do
+	local super = NormalizerFormatter
+	HtmlFormatter = setmetatable({}, {
+		__tostring = function()
+			return "HtmlFormatter"
+		end,
+		__index = super,
+	})
+	HtmlFormatter.__index = HtmlFormatter
+	function HtmlFormatter.new(...)
+		local self = setmetatable({}, HtmlFormatter)
+		return self:constructor(...) or self
+	end
+	function HtmlFormatter:constructor(...)
+		super.constructor(self, ...)
+	end
+	function HtmlFormatter:getLevelColor(level)
+		local _level = level
+		local _condition = LEVEL_COLORS[_level]
+		if _condition == nil then
+			_condition = "#000000"
+		end
+		return _condition
+	end
+	function HtmlFormatter:addRow(th, td, escapeTd)
+		if td == nil then
+			td = " "
+		end
+		if escapeTd == nil then
+			escapeTd = true
+		end
+		local heading = escapeHtml(th)
+		local cell = if escapeTd then `<pre>{escapeHtml(td)}</pre>` else td
+		return `<tr style="padding: 4px;text-align: left;">\n<th style="vertical-align: top;background: #ccc;color: #000" width="100">{heading}:</th>\n<td style="padding: 4px;text-align: left;vertical-align: top;background: #eee;color: #000">{cell}</td>\n</tr>`
+	end
+	function HtmlFormatter:addTitle(title, level)
+		return `<h1 style="background: {self:getLevelColor(level)};color: #ffffff;padding: 5px;" class="monolog-output">{escapeHtml(title)}</h1>`
+	end
+	function HtmlFormatter:format(record)
+		local output = self:addTitle(Levels:getName(record.level), record.level)
+		output ..= '<table cellspacing="1" width="100%" class="monolog-output">'
+		output ..= self:addRow("Message", record.message)
+		output ..= self:addRow("Time", self:formatDate(record.datetime))
+		output ..= self:addRow("Channel", record.channel)
+		if (next(record.context)) ~= nil then
+			local embedded = '<table cellspacing="1" width="100%">'
+			for key, value in pairs(record.context) do
+				embedded ..= self:addRow(tostring(key), self:convertToString(value))
+			end
+			embedded ..= "</table>"
+			output ..= self:addRow("Context", embedded, false)
+		end
+		if (next(record.extra)) ~= nil then
+			local embedded = '<table cellspacing="1" width="100%">'
+			for key, value in pairs(record.extra) do
+				embedded ..= self:addRow(tostring(key), self:convertToString(value))
+			end
+			embedded ..= "</table>"
+			output ..= self:addRow("Extra", embedded, false)
+		end
+		return `{output}</table>`
+	end
+	function HtmlFormatter:formatBatch(records)
+		local message = ""
+		for _, record in records do
+			message ..= self:format(record)
+		end
+		return message
+	end
+	function HtmlFormatter:convertToString(data)
+		local _condition = data == nil
+		if not _condition then
+			local _data = data
+			_condition = type(_data) == "string"
+			if not _condition then
+				local _data_1 = data
+				_condition = type(_data_1) == "number"
+				if not _condition then
+					local _data_2 = data
+					_condition = type(_data_2) == "boolean"
+				end
+			end
+		end
+		if _condition then
+			return if data == nil then "" else tostring(data)
+		end
+		-- Upstream always pretty-prints here regardless of the formatter's own
+		-- `setJsonPrettyPrint()` toggle -- call the encoder directly instead of
+		-- going through `toJson()`, which would use that toggle's value.
+		return Utils:jsonEncode(self:normalize(data), true)
+	end
+end
+return {
+	HtmlFormatter = HtmlFormatter,
+}

package/out/Monolog/Formatter/JsonFormatter.d.ts

@@ -0,0 +1,34 @@
+import { NormalizerFormatter } from "./NormalizerFormatter";
+import type { LogRecord, RecordBag } from "../LogRecord";
+/**
+ * PHP: `Monolog\Formatter\JsonFormatter`.
+ *
+ * Upstream marks an empty `context`/`extra` with `new \stdClass` so it
+ * encodes as `{}` rather than `[]`; there is no `\stdClass` here, so
+ * `markAsJsonObject()` marks the (still-empty) `RecordBag` instead -- see
+ * that function's comment in `Utils.ts`.
+ */
+export declare class JsonFormatter extends NormalizerFormatter {
+    protected batchMode: number;
+    protected appendNewline: boolean;
+    protected ignoreEmptyContextAndExtra: boolean;
+    static readonly BATCH_MODE_JSON = 1;
+    static readonly BATCH_MODE_NEWLINES = 2;
+    private includeStacktracesFlag;
+    constructor(batchMode?: number, appendNewline?: boolean, ignoreEmptyContextAndExtra?: boolean, includeStacktraces?: boolean);
+    /** The batch mode option configures the formatting style for multiple records. */
+    getBatchMode(): number;
+    /** True if newlines are appended to every formatted record. */
+    isAppendingNewlines(): boolean;
+    /** Formats a log record. */
+    format(record: LogRecord): string;
+    /** Formats a set of log records. */
+    formatBatch(records: Array<LogRecord>): string;
+    /** Kept for signature parity; there is no PHP trace string here -- see `LineFormatter`'s class comment. */
+    includeStacktraces(include?: boolean): this;
+    protected normalizeRecord(record: LogRecord): RecordBag;
+    /** Returns a JSON-encoded array of records. */
+    protected formatBatchJson(records: Array<LogRecord>): string;
+    /** Uses new lines to separate records instead of a JSON-encoded array. */
+    protected formatBatchNewlines(records: Array<LogRecord>): string;
+}

package/out/Monolog/Formatter/JsonFormatter.luau

@@ -0,0 +1,114 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local NormalizerFormatter = TS.import(script, script.Parent, "NormalizerFormatter").NormalizerFormatter
+local markAsJsonObject = TS.import(script, script.Parent.Parent, "Utils").markAsJsonObject
+local function isEmptyBag(bag)
+	local key = next(bag)
+	return key == nil
+end
+--[[
+	*
+	 * PHP: `Monolog\Formatter\JsonFormatter`.
+	 *
+	 * Upstream marks an empty `context`/`extra` with `new \stdClass` so it
+	 * encodes as `{}` rather than `[]`; there is no `\stdClass` here, so
+	 * `markAsJsonObject()` marks the (still-empty) `RecordBag` instead -- see
+	 * that function's comment in `Utils.ts`.
+	 
+]]
+local JsonFormatter
+do
+	local super = NormalizerFormatter
+	JsonFormatter = setmetatable({}, {
+		__tostring = function()
+			return "JsonFormatter"
+		end,
+		__index = super,
+	})
+	JsonFormatter.__index = JsonFormatter
+	function JsonFormatter.new(...)
+		local self = setmetatable({}, JsonFormatter)
+		return self:constructor(...) or self
+	end
+	function JsonFormatter:constructor(batchMode, appendNewline, ignoreEmptyContextAndExtra, includeStacktraces)
+		if batchMode == nil then
+			batchMode = JsonFormatter.BATCH_MODE_JSON
+		end
+		if appendNewline == nil then
+			appendNewline = true
+		end
+		if ignoreEmptyContextAndExtra == nil then
+			ignoreEmptyContextAndExtra = false
+		end
+		if includeStacktraces == nil then
+			includeStacktraces = false
+		end
+		super.constructor(self)
+		self.batchMode = batchMode
+		self.appendNewline = appendNewline
+		self.ignoreEmptyContextAndExtra = ignoreEmptyContextAndExtra
+		self.includeStacktracesFlag = includeStacktraces
+	end
+	function JsonFormatter:getBatchMode()
+		return self.batchMode
+	end
+	function JsonFormatter:isAppendingNewlines()
+		return self.appendNewline
+	end
+	function JsonFormatter:format(record)
+		local normalized = self:normalizeRecord(record)
+		return self:toJson(normalized) .. (if self.appendNewline then "\n" else "")
+	end
+	function JsonFormatter:formatBatch(records)
+		return if self.batchMode == JsonFormatter.BATCH_MODE_NEWLINES then self:formatBatchNewlines(records) else self:formatBatchJson(records)
+	end
+	function JsonFormatter:includeStacktraces(include)
+		if include == nil then
+			include = true
+		end
+		self.includeStacktracesFlag = include
+		return self
+	end
+	function JsonFormatter:normalizeRecord(record)
+		local normalized = super.normalizeRecord(self, record)
+		if isEmptyBag(normalized.context) then
+			if self.ignoreEmptyContextAndExtra then
+				normalized.context = nil
+			else
+				normalized.context = markAsJsonObject({})
+			end
+		end
+		if isEmptyBag(normalized.extra) then
+			if self.ignoreEmptyContextAndExtra then
+				normalized.extra = nil
+			else
+				normalized.extra = markAsJsonObject({})
+			end
+		end
+		return normalized
+	end
+	function JsonFormatter:formatBatchJson(records)
+		local normalized = {}
+		for _, record in records do
+			local _arg0 = self:normalizeRecord(record)
+			table.insert(normalized, _arg0)
+		end
+		return self:toJson(normalized)
+	end
+	function JsonFormatter:formatBatchNewlines(records)
+		local oldAppendNewline = self.appendNewline
+		self.appendNewline = false
+		local lines = {}
+		for _, record in records do
+			local _arg0 = self:format(record)
+			table.insert(lines, _arg0)
+		end
+		self.appendNewline = oldAppendNewline
+		return table.concat(lines, "\n")
+	end
+	JsonFormatter.BATCH_MODE_JSON = 1
+	JsonFormatter.BATCH_MODE_NEWLINES = 2
+end
+return {
+	JsonFormatter = JsonFormatter,
+}

package/out/Monolog/Formatter/LineFormatter.d.ts

@@ -0,0 +1,52 @@
+import { NormalizerFormatter } from "./NormalizerFormatter";
+import type { LogRecord } from "../LogRecord";
+/**
+ * PHP: `Monolog\Formatter\LineFormatter`.
+ *
+ * The default format drops PHP's trailing newline -- `print` and `warn` add
+ * their own.
+ *
+ * `includeStacktraces`/`indentStacktraces`/`stacktracesParser` are kept for
+ * API-shape parity but have nothing to act on: they format PHP's
+ * `getTraceAsString()` output, and there is no PHP exception/stack-trace
+ * object on this platform for `NormalizerFormatter.normalize()` to have kept
+ * a trace from in the first place (see that file's class comment). Setting
+ * them changes bookkeeping only, never formatted output.
+ *
+ * TypeScript can't have a property and a method share a name the way PHP's
+ * `$ignoreEmptyContextAndExtra`/`ignoreEmptyContextAndExtra()` (and similarly
+ * `allowInlineLineBreaks`, `includeStacktraces`) do -- each such flag's
+ * backing field is suffixed (`...Flag`/`...Value`) below; the public method
+ * names match upstream exactly.
+ */
+export declare class LineFormatter extends NormalizerFormatter {
+    protected readonly format_: string;
+    static readonly SIMPLE_FORMAT = "[%datetime%] %channel%.%level_name%: %message% %context% %extra%";
+    static readonly SIMPLE_DATE: string;
+    private allowInlineLineBreaksFlag;
+    private ignoreEmptyContextAndExtraFlag;
+    private includeStacktracesFlag;
+    private indentStacktracesValue;
+    private stacktracesParser?;
+    private maxLevelNameLength?;
+    constructor(format_?: string, dateFormat?: string, allowInlineLineBreaks?: boolean, ignoreEmptyContextAndExtra?: boolean, includeStacktraces?: boolean);
+    /** Kept for signature parity; there is no PHP trace string to reformat -- see the class comment. */
+    includeStacktraces(include?: boolean, parser?: (record: LogRecord) => string): this;
+    /** Kept for signature parity; there is no stack trace here to indent -- see the class comment. */
+    indentStacktraces(indent: string): this;
+    allowInlineLineBreaks(allow?: boolean): this;
+    ignoreEmptyContextAndExtra(ignore?: boolean): this;
+    /** Allows cutting the level name to fixed-length levels, e.g. "INF" for "INFO" if set to 3. */
+    setMaxLevelNameLength(maxLevelNameLength?: number): this;
+    /** Formats a log record. */
+    format(record: LogRecord): string;
+    /**
+     * Upstream concatenates records with no separator, relying on
+     * `SIMPLE_FORMAT`'s trailing `\n`; this port's `SIMPLE_FORMAT` drops that
+     * newline (see the class comment), so records are joined with one instead.
+     */
+    formatBatch(records: Array<LogRecord>): string;
+    stringify(value: unknown): string;
+    protected convertToString(data: unknown): string;
+    protected replaceNewlines(str: string): string;
+}