@larablox/monolog 0.1.0

package/out/Monolog/Formatter/LineFormatter.luau

@@ -0,0 +1,228 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local NormalizerFormatter = TS.import(script, script.Parent, "NormalizerFormatter").NormalizerFormatter
+--[[
+	*
+	 * 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.
+	 
+]]
+local copyBag
+local LineFormatter
+do
+	local super = NormalizerFormatter
+	LineFormatter = setmetatable({}, {
+		__tostring = function()
+			return "LineFormatter"
+		end,
+		__index = super,
+	})
+	LineFormatter.__index = LineFormatter
+	function LineFormatter.new(...)
+		local self = setmetatable({}, LineFormatter)
+		return self:constructor(...) or self
+	end
+	function LineFormatter:constructor(format_, dateFormat, allowInlineLineBreaks, ignoreEmptyContextAndExtra, includeStacktraces)
+		if format_ == nil then
+			format_ = LineFormatter.SIMPLE_FORMAT
+		end
+		if dateFormat == nil then
+			dateFormat = LineFormatter.SIMPLE_DATE
+		end
+		if allowInlineLineBreaks == nil then
+			allowInlineLineBreaks = false
+		end
+		if ignoreEmptyContextAndExtra == nil then
+			ignoreEmptyContextAndExtra = false
+		end
+		if includeStacktraces == nil then
+			includeStacktraces = false
+		end
+		super.constructor(self, dateFormat)
+		self.format_ = format_
+		self.includeStacktracesFlag = false
+		self.indentStacktracesValue = ""
+		self.allowInlineLineBreaksFlag = allowInlineLineBreaks
+		self.ignoreEmptyContextAndExtraFlag = ignoreEmptyContextAndExtra
+		self:includeStacktraces(includeStacktraces)
+	end
+	function LineFormatter:includeStacktraces(include, parser)
+		if include == nil then
+			include = true
+		end
+		self.includeStacktracesFlag = include
+		self.stacktracesParser = parser
+		if self.includeStacktracesFlag then
+			self.allowInlineLineBreaksFlag = true
+		end
+		return self
+	end
+	function LineFormatter:indentStacktraces(indent)
+		self.indentStacktracesValue = indent
+		return self
+	end
+	function LineFormatter:allowInlineLineBreaks(allow)
+		if allow == nil then
+			allow = true
+		end
+		self.allowInlineLineBreaksFlag = allow
+		return self
+	end
+	function LineFormatter:ignoreEmptyContextAndExtra(ignore)
+		if ignore == nil then
+			ignore = true
+		end
+		self.ignoreEmptyContextAndExtraFlag = ignore
+		return self
+	end
+	function LineFormatter:setMaxLevelNameLength(maxLevelNameLength)
+		self.maxLevelNameLength = maxLevelNameLength
+		return self
+	end
+	function LineFormatter:format(record)
+		-- Upstream calls `parent::format($record)` here for the normalized
+		-- array; this port's `NormalizerFormatter.format()` returns a JSON
+		-- *string* instead (see that file's class comment), so the protected
+		-- `normalizeRecord()` is called directly instead, exactly as upstream's
+		-- own `JsonFormatter` already does.
+		local vars = self:normalizeRecord(record)
+		if self.maxLevelNameLength ~= nil then
+			local _exp = (vars.level_name)
+			local _maxLevelNameLength = self.maxLevelNameLength
+			vars.level_name = string.sub(_exp, 1, _maxLevelNameLength)
+		end
+		local output = self.format_
+		local extra = copyBag(vars.extra)
+		local context = copyBag(vars.context)
+		for key, value in pairs(extra) do
+			local placeholder = `%extra.{key}%`
+			if (string.find(output, placeholder, 1, true)) ~= nil then
+				local _exp = string.split(output, placeholder)
+				local _arg0 = self:stringify(value)
+				-- ▼ ReadonlyArray.join ▼
+				local _arg0_1 = _arg0
+				if _arg0_1 == nil then
+					_arg0_1 = ", "
+				end
+				-- ▲ ReadonlyArray.join ▲
+				output = table.concat(_exp, _arg0_1)
+				extra[key] = nil
+			end
+		end
+		for key, value in pairs(context) do
+			local placeholder = `%context.{key}%`
+			if (string.find(output, placeholder, 1, true)) ~= nil then
+				local _exp = string.split(output, placeholder)
+				local _arg0 = self:stringify(value)
+				-- ▼ ReadonlyArray.join ▼
+				local _arg0_1 = _arg0
+				if _arg0_1 == nil then
+					_arg0_1 = ", "
+				end
+				-- ▲ ReadonlyArray.join ▲
+				output = table.concat(_exp, _arg0_1)
+				context[key] = nil
+			end
+		end
+		if self.ignoreEmptyContextAndExtraFlag then
+			if (next(context)) == nil then
+				output = table.concat(string.split(output, "%context%"), "")
+			end
+			if (next(extra)) == nil then
+				output = table.concat(string.split(output, "%extra%"), "")
+			end
+		end
+		vars.context = context
+		vars.extra = extra
+		for key, value in pairs(vars) do
+			local placeholder = `%{key}%`
+			if (string.find(output, placeholder, 1, true)) ~= nil then
+				local _exp = string.split(output, placeholder)
+				local _arg0 = self:stringify(value)
+				-- ▼ ReadonlyArray.join ▼
+				local _arg0_1 = _arg0
+				if _arg0_1 == nil then
+					_arg0_1 = ", "
+				end
+				-- ▲ ReadonlyArray.join ▲
+				output = table.concat(_exp, _arg0_1)
+			end
+		end
+		-- Leftover `%extra.xxx%`/`%context.xxx%` placeholders: upstream removes
+		-- them with a single PCRE alternation; Lua patterns have no `|`
+		-- alternation, so this is two passes instead of one.
+		local cleaned = string.gsub(output, "%%extra%.[^%%]-%%", "")
+		cleaned = string.gsub(cleaned, "%%context%.[^%%]-%%", "")
+		return cleaned
+	end
+	function LineFormatter:formatBatch(records)
+		local lines = {}
+		for _, record in records do
+			local _arg0 = self:format(record)
+			table.insert(lines, _arg0)
+		end
+		return table.concat(lines, "\n")
+	end
+	function LineFormatter:stringify(value)
+		return self:replaceNewlines(self:convertToString(value))
+	end
+	function LineFormatter:convertToString(data)
+		if data == nil then
+			return "null"
+		end
+		local _data = data
+		if type(_data) == "boolean" then
+			return if data then "true" else "false"
+		end
+		local _data_1 = data
+		local _condition = type(_data_1) == "string"
+		if not _condition then
+			local _data_2 = data
+			_condition = type(_data_2) == "number"
+		end
+		if _condition then
+			return tostring(data)
+		end
+		return self:toJson(data)
+	end
+	function LineFormatter:replaceNewlines(str)
+		if self.allowInlineLineBreaksFlag then
+			-- Upstream also unescapes literal `\r`/`\n` sequences inside a
+			-- JSON-looking string here via a PCRE; there is no PCRE on this
+			-- platform, so that step is dropped and the string passes through.
+			return str
+		end
+		local out = string.gsub(str, "\r\n", " ")
+		out = string.gsub(out, "\r", " ")
+		out = string.gsub(out, "\n", " ")
+		return out
+	end
+	LineFormatter.SIMPLE_FORMAT = "[%datetime%] %channel%.%level_name%: %message% %context% %extra%"
+	LineFormatter.SIMPLE_DATE = "%Y-%m-%d %H:%M:%S"
+end
+--* Shallow-copy a `RecordBag` so `format()` can drop matched placeholder keys without mutating the normalized record. 
+function copyBag(bag)
+	local copy = {}
+	for key, value in pairs(bag) do
+		copy[key] = value
+	end
+	return copy
+end
+return {
+	LineFormatter = LineFormatter,
+}

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

@@ -0,0 +1,87 @@
+import type { FormatterInterface } from "./FormatterInterface";
+import type { LogRecord, RecordBag } from "../LogRecord";
+/**
+ * PHP: `Monolog\Formatter\NormalizerFormatter`.
+ *
+ * Normalizes a record's context/extra into plain scalars/tables so it can be
+ * dumped to a string. Upstream's `normalize()` recognizes PHP object kinds one
+ * by one (`Throwable`, `JsonSerializable`, `__PHP_Incomplete_Class`,
+ * `is_resource`) -- none of that exists here, so anything that is not a scalar
+ * or a plain data table (a Luau table with no metatable) collapses to
+ * `tostring()`, the same way an unrecognized PHP object type would. There is
+ * no established "this is how an exception looks in a record" convention
+ * anywhere in this codebase (checked -- nothing under `src/Monolog` treats
+ * `context.exception` specially), so `normalizeException()`'s field-by-field
+ * shape (`class`/`message`/`code`/`file`/`trace`/`previous`) is not ported:
+ * there is no structured exception object to pull those fields from.
+ *
+ * `format()` is narrowed to return `string` here (this port's
+ * `FormatterInterface`, unlike upstream's `mixed`-returning one, already
+ * commits to that) rather than the raw normalized record upstream returns; it
+ * JSON-encodes `normalizeRecord()`'s result instead. Subclasses that need the
+ * raw record (`LineFormatter`, `JsonFormatter`, `ScalarFormatter`) call the
+ * protected `normalizeRecord()` directly, exactly as upstream's `JsonFormatter`
+ * already does rather than going through `parent::format()`.
+ */
+export declare class NormalizerFormatter implements FormatterInterface {
+    static readonly SIMPLE_DATE: string;
+    protected dateFormat: string;
+    protected maxNormalizeDepth: number;
+    protected maxNormalizeItemCount: number;
+    /** Toggled by `setJsonPrettyPrint()`; the only `jsonEncodeOptions` bit this port's encoder understands. */
+    private prettyPrint;
+    /**
+     * PHP: `NormalizerFormatter::$basePath`. Kept for API-shape parity: there
+     * is no PHP exception/stack-trace file path to shorten with it here, so
+     * it is stored and otherwise unused.
+     */
+    protected basePath: string;
+    constructor(dateFormat?: string);
+    /** Formats a log record. */
+    format(record: LogRecord): string;
+    /** Normalize an arbitrary value to a scalar/table/undefined. */
+    normalizeValue(data: unknown): unknown;
+    /**
+     * Formats a set of log records. Upstream returns an array of normalized
+     * records (`mixed`, per its `FormatterInterface`); this JSON-encodes that
+     * same array once, for the same `string`-return reason `format()` does.
+     */
+    formatBatch(records: Array<LogRecord>): string;
+    getDateFormat(): string;
+    setDateFormat(dateFormat: string): this;
+    /** The maximum number of normalization levels to go through. */
+    getMaxNormalizeDepth(): number;
+    setMaxNormalizeDepth(maxNormalizeDepth: number): this;
+    /** The maximum number of items to normalize per level. */
+    getMaxNormalizeItemCount(): number;
+    setMaxNormalizeItemCount(maxNormalizeItemCount: number): this;
+    /** Enables pretty-printed JSON output. */
+    setJsonPrettyPrint(enable: boolean): this;
+    /**
+     * Setting a base path would hide it from exception/stack-trace file names
+     * to shorten them upstream; there is nothing here that produces either, so
+     * this only stores the value.
+     */
+    setBasePath(path?: string): this;
+    /**
+     * Provided as an extension point, as upstream: `normalize()` is called
+     * with sub-values of context data etc., so `normalizeRecord()` can be
+     * overridden when data needs to be appended to the record but not to other
+     * normalized data (see `JsonFormatter`).
+     */
+    protected normalizeRecord(record: LogRecord): RecordBag;
+    protected normalize(data: unknown, depth?: number): unknown;
+    /** Return the JSON representation of a value. */
+    protected toJson(data: unknown): string;
+    protected formatDate(date: number): string;
+    /**
+     * PHP bitflag `json_encode` options have no equivalent when there is no
+     * `json_encode` to pass them to -- `toJson()` never consults this set, it
+     * exists only so callers ported against the upstream API have somewhere to
+     * put a call. Use `setJsonPrettyPrint()` for the one option this port's
+     * encoder actually understands.
+     */
+    private jsonEncodeOptions;
+    addJsonEncodeOption(option: unknown): this;
+    removeJsonEncodeOption(option: unknown): this;
+}

package/out/Monolog/Formatter/NormalizerFormatter.luau

@@ -0,0 +1,214 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Utils = TS.import(script, script.Parent.Parent, "Utils").Utils
+--[[
+	*
+	 * PHP: `Monolog\Formatter\NormalizerFormatter`.
+	 *
+	 * Normalizes a record's context/extra into plain scalars/tables so it can be
+	 * dumped to a string. Upstream's `normalize()` recognizes PHP object kinds one
+	 * by one (`Throwable`, `JsonSerializable`, `__PHP_Incomplete_Class`,
+	 * `is_resource`) -- none of that exists here, so anything that is not a scalar
+	 * or a plain data table (a Luau table with no metatable) collapses to
+	 * `tostring()`, the same way an unrecognized PHP object type would. There is
+	 * no established "this is how an exception looks in a record" convention
+	 * anywhere in this codebase (checked -- nothing under `src/Monolog` treats
+	 * `context.exception` specially), so `normalizeException()`'s field-by-field
+	 * shape (`class`/`message`/`code`/`file`/`trace`/`previous`) is not ported:
+	 * there is no structured exception object to pull those fields from.
+	 *
+	 * `format()` is narrowed to return `string` here (this port's
+	 * `FormatterInterface`, unlike upstream's `mixed`-returning one, already
+	 * commits to that) rather than the raw normalized record upstream returns; it
+	 * JSON-encodes `normalizeRecord()`'s result instead. Subclasses that need the
+	 * raw record (`LineFormatter`, `JsonFormatter`, `ScalarFormatter`) call the
+	 * protected `normalizeRecord()` directly, exactly as upstream's `JsonFormatter`
+	 * already does rather than going through `parent::format()`.
+	 
+]]
+local NormalizerFormatter
+do
+	NormalizerFormatter = setmetatable({}, {
+		__tostring = function()
+			return "NormalizerFormatter"
+		end,
+	})
+	NormalizerFormatter.__index = NormalizerFormatter
+	function NormalizerFormatter.new(...)
+		local self = setmetatable({}, NormalizerFormatter)
+		return self:constructor(...) or self
+	end
+	function NormalizerFormatter:constructor(dateFormat)
+		self.maxNormalizeDepth = 9
+		self.maxNormalizeItemCount = 1000
+		self.prettyPrint = false
+		self.basePath = ""
+		self.jsonEncodeOptions = {}
+		local _condition = dateFormat
+		if _condition == nil then
+			_condition = NormalizerFormatter.SIMPLE_DATE
+		end
+		self.dateFormat = _condition
+	end
+	function NormalizerFormatter:format(record)
+		return self:toJson(self:normalizeRecord(record))
+	end
+	function NormalizerFormatter:normalizeValue(data)
+		return self:normalize(data)
+	end
+	function NormalizerFormatter:formatBatch(records)
+		local normalized = {}
+		for _, record in records do
+			local _arg0 = self:normalizeRecord(record)
+			table.insert(normalized, _arg0)
+		end
+		return self:toJson(normalized)
+	end
+	function NormalizerFormatter:getDateFormat()
+		return self.dateFormat
+	end
+	function NormalizerFormatter:setDateFormat(dateFormat)
+		self.dateFormat = dateFormat
+		return self
+	end
+	function NormalizerFormatter:getMaxNormalizeDepth()
+		return self.maxNormalizeDepth
+	end
+	function NormalizerFormatter:setMaxNormalizeDepth(maxNormalizeDepth)
+		self.maxNormalizeDepth = maxNormalizeDepth
+		return self
+	end
+	function NormalizerFormatter:getMaxNormalizeItemCount()
+		return self.maxNormalizeItemCount
+	end
+	function NormalizerFormatter:setMaxNormalizeItemCount(maxNormalizeItemCount)
+		self.maxNormalizeItemCount = maxNormalizeItemCount
+		return self
+	end
+	function NormalizerFormatter:setJsonPrettyPrint(enable)
+		self.prettyPrint = enable
+		return self
+	end
+	function NormalizerFormatter:setBasePath(path)
+		if path == nil then
+			path = ""
+		end
+		self.basePath = path
+		return self
+	end
+	function NormalizerFormatter:normalizeRecord(record)
+		local normalized = self:normalize(record:toArray())
+		-- `datetime` is a plain Unix timestamp, not a `DateTimeInterface`
+		-- upstream's `normalize()` can recognize among arbitrary values by type
+		-- -- there is nothing to `instanceof`-check here, so it is formatted
+		-- explicitly instead of relying on that recursive detection.
+		normalized.datetime = self:formatDate(record.datetime)
+		return normalized
+	end
+	function NormalizerFormatter:normalize(data, depth)
+		if depth == nil then
+			depth = 0
+		end
+		if depth > self.maxNormalizeDepth then
+			return `Over {self.maxNormalizeDepth} levels deep, aborting normalization`
+		end
+		if data == nil then
+			return nil
+		end
+		local _data = data
+		local _condition = type(_data) == "string"
+		if not _condition then
+			local _data_1 = data
+			_condition = type(_data_1) == "boolean"
+		end
+		if _condition then
+			return data
+		end
+		local _data_1 = data
+		if type(_data_1) == "number" then
+			if data ~= data then
+				return "NaN"
+			end
+			if data == math.huge then
+				return "INF"
+			end
+			if data == -math.huge then
+				return "-INF"
+			end
+			return data
+		end
+		local _data_2 = data
+		if type(_data_2) == "table" then
+			-- A table with a metatable is a class instance (a Roblox `Instance`,
+			-- an OOP object elsewhere in this codebase, etc.) rather than plain
+			-- record data -- there is no PHP object/`Throwable`/`JsonSerializable`
+			-- system to special-case one against, so it collapses to a string the
+			-- same way an unrecognized PHP object type would.
+			if getmetatable(data) ~= nil then
+				return tostring(data)
+			end
+			local list = data
+			if #list > 0 then
+				-- `Array<T>.push()` requires `T extends defined` (Luau arrays
+				-- cannot reliably hold a `nil` mid-list); a normalized value is
+				-- rarely actually `undefined`, but cast rather than narrow the
+				-- element type to `unknown`, which `push()` itself rejects.
+				local normalized = {}
+				local count = 0
+				for _, item in list do
+					count += 1
+					if count > self.maxNormalizeItemCount then
+						local _arg0 = `Over {self.maxNormalizeItemCount} items ({#list} total), aborting normalization`
+						table.insert(normalized, _arg0)
+						break
+					end
+					local _arg0 = self:normalize(item, depth + 1)
+					table.insert(normalized, _arg0)
+				end
+				return normalized
+			end
+			local bag = data
+			local keys = {}
+			for key in pairs(bag) do
+				local _arg0 = tostring(key)
+				table.insert(keys, _arg0)
+			end
+			table.sort(keys)
+			local normalized = {}
+			local count = 0
+			for _, key in keys do
+				count += 1
+				if count > self.maxNormalizeItemCount then
+					normalized["..."] = `Over {self.maxNormalizeItemCount} items ({#keys} total), aborting normalization`
+					break
+				end
+				normalized[key] = self:normalize(bag[key], depth + 1)
+			end
+			return normalized
+		end
+		-- Function/thread/opaque instance: nothing left to reflect on.
+		return tostring(data)
+	end
+	function NormalizerFormatter:toJson(data)
+		return Utils:jsonEncode(data, self.prettyPrint)
+	end
+	function NormalizerFormatter:formatDate(date)
+		return os.date(self.dateFormat, date)
+	end
+	function NormalizerFormatter:addJsonEncodeOption(option)
+		local _jsonEncodeOptions = self.jsonEncodeOptions
+		local _option = option
+		_jsonEncodeOptions[_option] = true
+		return self
+	end
+	function NormalizerFormatter:removeJsonEncodeOption(option)
+		local _jsonEncodeOptions = self.jsonEncodeOptions
+		local _option = option
+		_jsonEncodeOptions[_option] = nil
+		return self
+	end
+	NormalizerFormatter.SIMPLE_DATE = "%Y-%m-%dT%H:%M:%S%z"
+end
+return {
+	NormalizerFormatter = NormalizerFormatter,
+}

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

@@ -0,0 +1,19 @@
+import { NormalizerFormatter } from "./NormalizerFormatter";
+import type { LogRecord, RecordBag } from "../LogRecord";
+/**
+ * PHP: `Monolog\Formatter\ScalarFormatter`.
+ *
+ * Formats data into a map of scalar (or `undefined`) values; anything
+ * non-scalar is JSON-encoded instead. Upstream's `format()` returns that map
+ * directly; this port's `FormatterInterface.format()` is narrowed to `string`
+ * (see `NormalizerFormatter`'s class comment), so `format()` here JSON-encodes
+ * it, and the map itself is exposed as `toScalarRecord()` for callers that
+ * want the structured form.
+ */
+export declare class ScalarFormatter extends NormalizerFormatter {
+    /** Formats a log record. */
+    format(record: LogRecord): string;
+    /** PHP: `ScalarFormatter::format()`'s actual return value. */
+    toScalarRecord(record: LogRecord): RecordBag;
+    protected toScalar(value: unknown): unknown;
+}

package/out/Monolog/Formatter/ScalarFormatter.luau

@@ -0,0 +1,53 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local NormalizerFormatter = TS.import(script, script.Parent, "NormalizerFormatter").NormalizerFormatter
+--[[
+	*
+	 * PHP: `Monolog\Formatter\ScalarFormatter`.
+	 *
+	 * Formats data into a map of scalar (or `undefined`) values; anything
+	 * non-scalar is JSON-encoded instead. Upstream's `format()` returns that map
+	 * directly; this port's `FormatterInterface.format()` is narrowed to `string`
+	 * (see `NormalizerFormatter`'s class comment), so `format()` here JSON-encodes
+	 * it, and the map itself is exposed as `toScalarRecord()` for callers that
+	 * want the structured form.
+	 
+]]
+local ScalarFormatter
+do
+	local super = NormalizerFormatter
+	ScalarFormatter = setmetatable({}, {
+		__tostring = function()
+			return "ScalarFormatter"
+		end,
+		__index = super,
+	})
+	ScalarFormatter.__index = ScalarFormatter
+	function ScalarFormatter.new(...)
+		local self = setmetatable({}, ScalarFormatter)
+		return self:constructor(...) or self
+	end
+	function ScalarFormatter:constructor(...)
+		super.constructor(self, ...)
+	end
+	function ScalarFormatter:format(record)
+		return self:toJson(self:toScalarRecord(record))
+	end
+	function ScalarFormatter:toScalarRecord(record)
+		local result = {}
+		for key, value in pairs(record:toArray()) do
+			result[key] = self:toScalar(value)
+		end
+		return result
+	end
+	function ScalarFormatter:toScalar(value)
+		local normalized = self:normalize(value)
+		if type(normalized) == "table" then
+			return self:toJson(normalized)
+		end
+		return normalized
+	end
+end
+return {
+	ScalarFormatter = ScalarFormatter,
+}

package/out/Monolog/Handler/AbstractHandler.d.ts

@@ -0,0 +1,22 @@
+import { Handler } from "./Handler";
+import { Level } from "../Level";
+import type { LogRecord } from "../LogRecord";
+import type { ResettableInterface } from "../ResettableInterface";
+/** PHP: `Monolog\Handler\AbstractHandler`. */
+export declare abstract class AbstractHandler extends Handler implements ResettableInterface {
+    protected level: Level;
+    protected bubble: boolean;
+    constructor(level?: Level, bubble?: boolean);
+    /** Checks whether the given record will be handled by this handler. */
+    isHandling(record: LogRecord): boolean;
+    /** Sets minimum logging level at which this handler will be triggered. */
+    setLevel(level: Level): this;
+    /** Gets minimum logging level at which this handler will be triggered. */
+    getLevel(): Level;
+    /** Sets the bubbling behavior. */
+    setBubble(bubble: boolean): this;
+    /** Gets the bubbling behavior. */
+    getBubble(): boolean;
+    /** Resets the handler's state. */
+    reset(): void;
+}

package/out/Monolog/Handler/AbstractHandler.luau

@@ -0,0 +1,50 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Handler = TS.import(script, script.Parent, "Handler").Handler
+local Level = TS.import(script, script.Parent.Parent, "Level").Level
+--* PHP: `Monolog\Handler\AbstractHandler`. 
+local AbstractHandler
+do
+	local super = Handler
+	AbstractHandler = setmetatable({}, {
+		__tostring = function()
+			return "AbstractHandler"
+		end,
+		__index = super,
+	})
+	AbstractHandler.__index = AbstractHandler
+	function AbstractHandler:constructor(level, bubble)
+		if level == nil then
+			level = Level.Debug
+		end
+		if bubble == nil then
+			bubble = true
+		end
+		super.constructor(self)
+		self.level = level
+		self.bubble = bubble
+	end
+	function AbstractHandler:isHandling(record)
+		return record.level >= self.level
+	end
+	function AbstractHandler:setLevel(level)
+		self.level = level
+		return self
+	end
+	function AbstractHandler:getLevel()
+		return self.level
+	end
+	function AbstractHandler:setBubble(bubble)
+		self.bubble = bubble
+		return self
+	end
+	function AbstractHandler:getBubble()
+		return self.bubble
+	end
+	function AbstractHandler:reset()
+		--
+	end
+end
+return {
+	AbstractHandler = AbstractHandler,
+}