@mlightcad/common 1.2.3 → 1.2.4

package/lib/AcCmEventManager.js

@@ -0,0 +1,133 @@
+/**
+ * @fileoverview Simple event manager implementation for the AutoCAD Common library.
+ *
+ * This module provides a lightweight event management system for handling
+ * listeners and dispatching events with type-safe payload support.
+ *
+ * @module AcCmEventManager
+ * @version 1.0.0
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * Simple event manager for handling event listeners and dispatching events.
+ *
+ * Provides a lightweight alternative to the more complex AcCmEventDispatcher
+ * for cases where you need basic event handling with type-safe payloads.
+ *
+ * @template T - The type of the event payload.
+ *
+ * @example
+ * ```typescript
+ * // Create an event manager for string payloads
+ * const manager = new AcCmEventManager<string>()
+ *
+ * // Add a listener
+ * manager.addEventListener((message) => {
+ *   console.log('Received:', message)
+ * })
+ *
+ * // Dispatch an event
+ * manager.dispatch('Hello, World!')
+ *
+ * // For complex payloads
+ * interface LoadEvent {
+ *   url: string
+ *   progress: number
+ * }
+ *
+ * const loadManager = new AcCmEventManager<LoadEvent>()
+ * loadManager.addEventListener(({ url, progress }) => {
+ *   console.log(`Loading ${url}: ${progress}%`)
+ * })
+ * ```
+ */
+var AcCmEventManager = /** @class */ (function () {
+    function AcCmEventManager() {
+        this.listeners = [];
+    }
+    /**
+     * Add the event listener
+     * @param listener Input listener to be added
+     */
+    AcCmEventManager.prototype.addEventListener = function (listener) {
+        this.listeners.push(listener);
+    };
+    /**
+     * Remove the listener
+     * @param listener Input listener to be removed
+     */
+    AcCmEventManager.prototype.removeEventListener = function (listener) {
+        this.listeners = this.listeners.filter(function (s) { return s !== listener; });
+    };
+    /**
+     * Remove all listeners bound to the target and add one new listener
+     * @param listener Input listener to be added
+     */
+    AcCmEventManager.prototype.replaceEventListener = function (listener) {
+        this.removeEventListener(listener);
+        this.addEventListener(listener);
+    };
+    /**
+     * Notify all listeners
+     * @param payload Input payload passed to listener
+     */
+    AcCmEventManager.prototype.dispatch = function (payload) {
+        var e_1, _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        try {
+            for (var _b = __values(this.listeners), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                var listener = item;
+                listener.call.apply(listener, __spreadArray([null, payload], __read(args), false));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    return AcCmEventManager;
+}());
+export { AcCmEventManager };
+//# sourceMappingURL=AcCmEventManager.js.map

package/lib/AcCmEventManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcCmEventManager.js","sourceRoot":"","sources":["../src/AcCmEventManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAAA;QACU,cAAS,GAA6B,EAAE,CAAA;IAqClD,CAAC;IAnCC;;;OAGG;IACI,2CAAgB,GAAvB,UAAwB,QAA8B;QACpD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC/B,CAAC;IAED;;;OAGG;IACI,8CAAmB,GAA1B,UAA2B,QAA8B;QACvD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,KAAK,QAAQ,EAAd,CAAc,CAAC,CAAA;IAC7D,CAAC;IAED;;;OAGG;IACI,+CAAoB,GAA3B,UAA4B,QAA8B;QACxD,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAA;QAClC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IACjC,CAAC;IAED;;;OAGG;IACI,mCAAQ,GAAf,UAAgB,OAAW;;QAAE,cAAkB;aAAlB,UAAkB,EAAlB,qBAAkB,EAAlB,IAAkB;YAAlB,6BAAkB;;;YAC7C,KAAmB,IAAA,KAAA,SAAA,IAAI,CAAC,SAAS,CAAA,gBAAA,4BAAE,CAAC;gBAA/B,IAAM,IAAI,WAAA;gBACb,IAAM,QAAQ,GAAG,IAAoC,CAAA;gBACrD,QAAQ,CAAC,IAAI,OAAb,QAAQ,iBAAM,IAAI,EAAE,OAAO,UAAK,IAAI,WAAC;YACvC,CAAC;;;;;;;;;IACH,CAAC;IACH,uBAAC;AAAD,CAAC,AAtCD,IAsCC"}

package/lib/AcCmLodashUtils.d.ts

@@ -0,0 +1,145 @@
+/**
+ * @fileoverview Lightweight utility functions inspired by lodash-es.
+ *
+ * This module provides simplified implementations of commonly used lodash functions
+ * to reduce bundle size while maintaining essential functionality for object manipulation,
+ * comparison, and validation operations.
+ *
+ * @module AcCmLodashUtils
+ * @version 1.0.0
+ */
+/**
+ * Utility functions extracted from lodash-es to reduce bundle size
+ * These are simplified implementations of commonly used lodash functions
+ */
+/**
+ * Creates a shallow clone of an object or array.
+ *
+ * For primitive values, returns the value as-is. For objects and arrays,
+ * creates a new instance with the same properties or elements.
+ *
+ * @template T - The type of the object to clone.
+ * @param {T} obj - The object to clone.
+ * @returns {T} A shallow clone of the object.
+ *
+ * @example
+ * ```typescript
+ * import { clone } from './AcCmLodashUtils'
+ *
+ * const original = { a: 1, b: 2 }
+ * const cloned = clone(original)
+ * cloned.a = 3
+ * console.log(original.a) // 1 (unchanged)
+ * console.log(cloned.a)   // 3
+ *
+ * const arr = [1, 2, 3]
+ * const clonedArr = clone(arr) // [1, 2, 3]
+ * ```
+ */
+export declare function clone<T>(obj: T): T;
+/**
+ * Assigns own enumerable properties of source objects to the destination object
+ * for all destination properties that resolve to undefined.
+ *
+ * This function fills in undefined properties in an object with the first value
+ * present in any of the source objects. Source objects are applied from left to right.
+ *
+ * @param {Record<string, unknown>} obj - The destination object.
+ * @param {...Record<string, unknown>[]} sources - The source objects.
+ * @returns {Record<string, unknown>} The destination object.
+ *
+ * @example
+ * ```typescript
+ * import { defaults } from './AcCmLodashUtils'
+ *
+ * const object = { a: 1 }
+ * const result = defaults(object, { b: 2 }, { a: 3, c: 3 })
+ * console.log(result) // { a: 1, b: 2, c: 3 }
+ *
+ * // undefined properties are filled in
+ * const partial = { a: 1, b: undefined }
+ * defaults(partial, { b: 2, c: 3 })
+ * console.log(partial) // { a: 1, b: 2, c: 3 }
+ * ```
+ */
+export declare function defaults(obj: Record<string, unknown>, ...sources: Record<string, unknown>[]): Record<string, unknown>;
+/**
+ * Checks if path is a direct property of object.
+ *
+ * This function checks whether the specified property exists directly on the object
+ * (not inherited from its prototype chain).
+ *
+ * @param {Record<string, unknown>} obj - The object to query.
+ * @param {string} path - The path to check.
+ * @returns {boolean} Returns true if path exists, else false.
+ *
+ * @example
+ * ```typescript
+ * import { has } from './AcCmLodashUtils'
+ *
+ * const object = { a: 1, b: 2 }
+ * has(object, 'a')        // true
+ * has(object, 'c')        // false
+ * has(object, 'toString') // false (inherited property)
+ * ```
+ */
+export declare function has(obj: Record<string, unknown>, path: string): boolean;
+/**
+ * Checks if value is an empty object, collection, map, or set.
+ *
+ * Values are considered empty if they are:
+ * - null or undefined
+ * - Arrays or strings with length 0
+ * - Maps or Sets with size 0
+ * - Objects with no enumerable properties
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if value is empty, else false.
+ *
+ * @example
+ * ```typescript
+ * import { isEmpty } from './AcCmLodashUtils'
+ *
+ * isEmpty(null)           // true
+ * isEmpty(undefined)      // true
+ * isEmpty('')             // true
+ * isEmpty([])             // true
+ * isEmpty({})             // true
+ * isEmpty(new Map())      // true
+ * isEmpty(new Set())      // true
+ * isEmpty('hello')        // false
+ * isEmpty([1, 2, 3])      // false
+ * isEmpty({ a: 1 })       // false
+ * ```
+ */
+export declare function isEmpty(value: unknown): boolean;
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ *
+ * This function recursively compares objects and arrays, checking that all nested
+ * properties and elements are equal. Handles null/undefined values, primitive types,
+ * arrays, and plain objects.
+ *
+ * @param {unknown} value - The value to compare.
+ * @param {unknown} other - The other value to compare.
+ * @returns {boolean} Returns true if the values are equivalent, else false.
+ *
+ * @example
+ * ```typescript
+ * import { isEqual } from './AcCmLodashUtils'
+ *
+ * isEqual(1, 1)                    // true
+ * isEqual('hello', 'hello')        // true
+ * isEqual([1, 2], [1, 2])         // true
+ * isEqual({ a: 1 }, { a: 1 })     // true
+ * isEqual([1, 2], [2, 1])         // false
+ * isEqual({ a: 1 }, { a: 2 })     // false
+ *
+ * // Deep comparison
+ * const obj1 = { a: { b: 1 } }
+ * const obj2 = { a: { b: 1 } }
+ * isEqual(obj1, obj2)              // true
+ * ```
+ */
+export declare function isEqual(value: unknown, other: unknown): boolean;
+//# sourceMappingURL=AcCmLodashUtils.d.ts.map

package/lib/AcCmLodashUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcCmLodashUtils.d.ts","sourceRoot":"","sources":["../src/AcCmLodashUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAUlC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,GAAG,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GACpC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAczB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAkB/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAwD/D"}

package/lib/AcCmLodashUtils.js

@@ -0,0 +1,293 @@
+/**
+ * @fileoverview Lightweight utility functions inspired by lodash-es.
+ *
+ * This module provides simplified implementations of commonly used lodash functions
+ * to reduce bundle size while maintaining essential functionality for object manipulation,
+ * comparison, and validation operations.
+ *
+ * @module AcCmLodashUtils
+ * @version 1.0.0
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+/**
+ * Utility functions extracted from lodash-es to reduce bundle size
+ * These are simplified implementations of commonly used lodash functions
+ */
+/**
+ * Creates a shallow clone of an object or array.
+ *
+ * For primitive values, returns the value as-is. For objects and arrays,
+ * creates a new instance with the same properties or elements.
+ *
+ * @template T - The type of the object to clone.
+ * @param {T} obj - The object to clone.
+ * @returns {T} A shallow clone of the object.
+ *
+ * @example
+ * ```typescript
+ * import { clone } from './AcCmLodashUtils'
+ *
+ * const original = { a: 1, b: 2 }
+ * const cloned = clone(original)
+ * cloned.a = 3
+ * console.log(original.a) // 1 (unchanged)
+ * console.log(cloned.a)   // 3
+ *
+ * const arr = [1, 2, 3]
+ * const clonedArr = clone(arr) // [1, 2, 3]
+ * ```
+ */
+export function clone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return __spreadArray([], __read(obj), false);
+    }
+    return __assign({}, obj);
+}
+/**
+ * Assigns own enumerable properties of source objects to the destination object
+ * for all destination properties that resolve to undefined.
+ *
+ * This function fills in undefined properties in an object with the first value
+ * present in any of the source objects. Source objects are applied from left to right.
+ *
+ * @param {Record<string, unknown>} obj - The destination object.
+ * @param {...Record<string, unknown>[]} sources - The source objects.
+ * @returns {Record<string, unknown>} The destination object.
+ *
+ * @example
+ * ```typescript
+ * import { defaults } from './AcCmLodashUtils'
+ *
+ * const object = { a: 1 }
+ * const result = defaults(object, { b: 2 }, { a: 3, c: 3 })
+ * console.log(result) // { a: 1, b: 2, c: 3 }
+ *
+ * // undefined properties are filled in
+ * const partial = { a: 1, b: undefined }
+ * defaults(partial, { b: 2, c: 3 })
+ * console.log(partial) // { a: 1, b: 2, c: 3 }
+ * ```
+ */
+export function defaults(obj) {
+    var e_1, _a;
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    try {
+        for (var sources_1 = __values(sources), sources_1_1 = sources_1.next(); !sources_1_1.done; sources_1_1 = sources_1.next()) {
+            var source = sources_1_1.value;
+            if (source) {
+                for (var key in source) {
+                    if (Object.prototype.hasOwnProperty.call(source, key) &&
+                        obj[key] === undefined) {
+                        obj[key] = source[key];
+                    }
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (sources_1_1 && !sources_1_1.done && (_a = sources_1.return)) _a.call(sources_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return obj;
+}
+/**
+ * Checks if path is a direct property of object.
+ *
+ * This function checks whether the specified property exists directly on the object
+ * (not inherited from its prototype chain).
+ *
+ * @param {Record<string, unknown>} obj - The object to query.
+ * @param {string} path - The path to check.
+ * @returns {boolean} Returns true if path exists, else false.
+ *
+ * @example
+ * ```typescript
+ * import { has } from './AcCmLodashUtils'
+ *
+ * const object = { a: 1, b: 2 }
+ * has(object, 'a')        // true
+ * has(object, 'c')        // false
+ * has(object, 'toString') // false (inherited property)
+ * ```
+ */
+export function has(obj, path) {
+    return obj != null && Object.prototype.hasOwnProperty.call(obj, path);
+}
+/**
+ * Checks if value is an empty object, collection, map, or set.
+ *
+ * Values are considered empty if they are:
+ * - null or undefined
+ * - Arrays or strings with length 0
+ * - Maps or Sets with size 0
+ * - Objects with no enumerable properties
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if value is empty, else false.
+ *
+ * @example
+ * ```typescript
+ * import { isEmpty } from './AcCmLodashUtils'
+ *
+ * isEmpty(null)           // true
+ * isEmpty(undefined)      // true
+ * isEmpty('')             // true
+ * isEmpty([])             // true
+ * isEmpty({})             // true
+ * isEmpty(new Map())      // true
+ * isEmpty(new Set())      // true
+ * isEmpty('hello')        // false
+ * isEmpty([1, 2, 3])      // false
+ * isEmpty({ a: 1 })       // false
+ * ```
+ */
+export function isEmpty(value) {
+    if (value == null) {
+        return true;
+    }
+    if (Array.isArray(value) || typeof value === 'string') {
+        return value.length === 0;
+    }
+    if (value instanceof Map || value instanceof Set) {
+        return value.size === 0;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ *
+ * This function recursively compares objects and arrays, checking that all nested
+ * properties and elements are equal. Handles null/undefined values, primitive types,
+ * arrays, and plain objects.
+ *
+ * @param {unknown} value - The value to compare.
+ * @param {unknown} other - The other value to compare.
+ * @returns {boolean} Returns true if the values are equivalent, else false.
+ *
+ * @example
+ * ```typescript
+ * import { isEqual } from './AcCmLodashUtils'
+ *
+ * isEqual(1, 1)                    // true
+ * isEqual('hello', 'hello')        // true
+ * isEqual([1, 2], [1, 2])         // true
+ * isEqual({ a: 1 }, { a: 1 })     // true
+ * isEqual([1, 2], [2, 1])         // false
+ * isEqual({ a: 1 }, { a: 2 })     // false
+ *
+ * // Deep comparison
+ * const obj1 = { a: { b: 1 } }
+ * const obj2 = { a: { b: 1 } }
+ * isEqual(obj1, obj2)              // true
+ * ```
+ */
+export function isEqual(value, other) {
+    var e_2, _a;
+    if (value === other) {
+        return true;
+    }
+    if (value == null || other == null) {
+        return value === other;
+    }
+    if (typeof value !== typeof other) {
+        return false;
+    }
+    if (typeof value !== 'object') {
+        return value === other;
+    }
+    if (Array.isArray(value) !== Array.isArray(other)) {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        if (value.length !== other.length) {
+            return false;
+        }
+        for (var i = 0; i < value.length; i++) {
+            if (!isEqual(value[i], other[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    var valueKeys = Object.keys(value);
+    var otherKeys = Object.keys(other);
+    if (valueKeys.length !== otherKeys.length) {
+        return false;
+    }
+    try {
+        for (var valueKeys_1 = __values(valueKeys), valueKeys_1_1 = valueKeys_1.next(); !valueKeys_1_1.done; valueKeys_1_1 = valueKeys_1.next()) {
+            var key = valueKeys_1_1.value;
+            if (!Object.prototype.hasOwnProperty.call(other, key) ||
+                !isEqual(value[key], other[key])) {
+                return false;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (valueKeys_1_1 && !valueKeys_1_1.done && (_a = valueKeys_1.return)) _a.call(valueKeys_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return true;
+}
+//# sourceMappingURL=AcCmLodashUtils.js.map

package/lib/AcCmLodashUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcCmLodashUtils.js","sourceRoot":"","sources":["../src/AcCmLodashUtils.ts"],"names":[],"mappings":"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"}

package/lib/AcCmLogUtil.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Logging utilities for the AutoCAD Common library.
+ *
+ * This module provides a centralized logging interface using the loglevel library,
+ * with configurable log levels for development and production environments.
+ *
+ * @module AcCmLogUtil
+ * @version 1.0.0
+ */
+import * as loglevel from 'loglevel';
+/**
+ * Flag indicating whether debug mode is enabled.
+ * When true, sets log level to 'debug'; otherwise sets to 'warn'.
+ *
+ * @constant {boolean}
+ */
+export declare const DEBUG_MODE = true;
+/**
+ * The main logging instance from the loglevel library.
+ * Provides standard logging methods: trace, debug, info, warn, error.
+ *
+ * @constant {loglevel.Logger}
+ *
+ * @example
+ * ```typescript
+ * import { log } from './AcCmLogUtil'
+ *
+ * log.debug('Debug message')
+ * log.info('Info message')
+ * log.warn('Warning message')
+ * log.error('Error message')
+ * ```
+ */
+export declare const log: {
+    default: loglevel.RootLogger;
+    noConflict(): any;
+    getLogger(name: string | symbol): loglevel.Logger;
+    getLoggers(): {
+        [name: string]: loglevel.Logger;
+    };
+    levels: loglevel.LogLevel;
+    methodFactory: loglevel.MethodFactory;
+    trace(...msg: any[]): void;
+    debug(...msg: any[]): void;
+    log(...msg: any[]): void;
+    info(...msg: any[]): void;
+    warn(...msg: any[]): void;
+    error(...msg: any[]): void;
+    setLevel(level: loglevel.LogLevelDesc, persist?: boolean): void;
+    getLevel(): loglevel.LogLevel[keyof loglevel.LogLevel];
+    setDefaultLevel(level: loglevel.LogLevelDesc): void;
+    resetLevel(): void;
+    enableAll(persist?: boolean): void;
+    disableAll(persist?: boolean): void;
+    rebuild(): void;
+};
+/**
+ * Sets the log level for the logging system.
+ *
+ * Valid log levels are: 'trace', 'debug', 'info', 'warn', 'error', 'silent'.
+ * If an invalid level is provided, the level will default to 'error' and an error will be logged.
+ *
+ * @param {string} level - The log level to set.
+ *
+ * @example
+ * ```typescript
+ * import { setLogLevel } from './AcCmLogUtil'
+ *
+ * // Set to debug level for development
+ * setLogLevel('debug')
+ *
+ * // Set to error level for production
+ * setLogLevel('error')
+ *
+ * // Silent all logging
+ * setLogLevel('silent')
+ * ```
+ */
+export declare const setLogLevel: (level: string) => void;
+//# sourceMappingURL=AcCmLogUtil.d.ts.map

package/lib/AcCmLogUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcCmLogUtil.d.ts","sourceRoot":"","sources":["../src/AcCmLogUtil.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,UAAU,OAAO,CAAA;AAE9B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;CAAW,CAAA;AAQ3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,SAOxC,CAAA"}