@atlassian/clientside-extensions-debug 2.4.0-69e0f9e-kugbhrvw

package/dist/esm/logger/default-logger.js

@@ -0,0 +1,46 @@
+import { consoleLogger } from './console';
+import { observeDebugSubject } from '../debug-subjects';
+import { _loggerSubject } from './logger';
+/**
+ * We need to keep and expose the "observeLogger" function for a legacy reason.
+ * It should be removed in CSEv3
+ *
+ * @deprecated
+ */
+export const observeLogger = (observer) => {
+    return observeDebugSubject("logger" /* Logger */, observer);
+};
+const registerConsoleLogger = () => {
+    // Singleton workaround as this module may be executed more than once.
+    // We only ever want one global default logger, however.
+    if (window.____c_p_d_l_d !== undefined) {
+        return window.____c_p_d_l_d;
+    }
+    window.____c_p_d_l_d = observeLogger(consoleLogger);
+    return window.____c_p_d_l_d;
+};
+const deregisterLogger = () => {
+    if (window.____c_p_d_l_d === undefined) {
+        return;
+    }
+    window.____c_p_d_l_d.unsubscribe();
+};
+export const defaultLogger = registerConsoleLogger();
+/**
+ * Added in CSE 2.1.0
+ *
+ * @param logger
+ * @public
+ */
+export const setLogger = (logger) => {
+    if (typeof logger !== 'function') {
+        throw new Error(`Client-side Extension: The provided logger needs to be a function`);
+    }
+    deregisterLogger();
+    _loggerSubject.prune();
+    observeDebugSubject("logger" /* Logger */, logger);
+};
+const deregisterDefaultLogger = () => defaultLogger.unsubscribe();
+// @VisibleForTesting
+export { deregisterDefaultLogger as _deregisterDefaultLogger };
+//# sourceMappingURL=default-logger.js.map

package/dist/esm/logger/default-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-logger.js","sourceRoot":"","sources":["../../../lib/logger/default-logger.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAiB,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAS1C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,QAAiC,EAAgB,EAAE;IAC7E,OAAO,mBAAmB,wBAAsC,QAAQ,CAAC,CAAC;AAC9E,CAAC,CAAC;AAEF,MAAM,qBAAqB,GAAG,GAAiB,EAAE;IAC7C,sEAAsE;IACtE,wDAAwD;IACxD,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE;QACpC,OAAO,MAAM,CAAC,aAAa,CAAC;KAC/B;IAED,MAAM,CAAC,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;IAEpD,OAAO,MAAM,CAAC,aAAa,CAAC;AAChC,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,GAAS,EAAE;IAChC,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE;QACpC,OAAO;KACV;IAED,MAAM,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;AACvC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,qBAAqB,EAAE,CAAC;AAErD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,MAA+B,EAAQ,EAAE;IAC/D,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;KACxF;IAED,gBAAgB,EAAE,CAAC;IACnB,cAAc,CAAC,KAAK,EAAE,CAAC;IAEvB,mBAAmB,wBAAsC,MAAM,CAAC,CAAC;AACrE,CAAC,CAAC;AAEF,MAAM,uBAAuB,GAAG,GAAG,EAAE,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;AAElE,qBAAqB;AACrB,OAAO,EAAE,uBAAuB,IAAI,wBAAwB,EAAE,CAAC","sourcesContent":["/* eslint-disable no-underscore-dangle */\nimport type { Observer, Subscription } from '@atlassian/clientside-extensions-base';\nimport { consoleLogger } from './console';\nimport { DebugSubjects, observeDebugSubject } from '../debug-subjects';\nimport type { LoggerPayload } from './logger';\nimport { _loggerSubject } from './logger';\n\ndeclare global {\n    interface Window {\n        // clientside extension default logging deregister\n        ____c_p_d_l_d?: Subscription;\n    }\n}\n\n/**\n * We need to keep and expose the \"observeLogger\" function for a legacy reason.\n * It should be removed in CSEv3\n *\n * @deprecated\n */\nexport const observeLogger = (observer: Observer<LoggerPayload>): Subscription => {\n    return observeDebugSubject<LoggerPayload>(DebugSubjects.Logger, observer);\n};\n\nconst registerConsoleLogger = (): Subscription => {\n    // Singleton workaround as this module may be executed more than once.\n    // We only ever want one global default logger, however.\n    if (window.____c_p_d_l_d !== undefined) {\n        return window.____c_p_d_l_d;\n    }\n\n    window.____c_p_d_l_d = observeLogger(consoleLogger);\n\n    return window.____c_p_d_l_d;\n};\n\nconst deregisterLogger = (): void => {\n    if (window.____c_p_d_l_d === undefined) {\n        return;\n    }\n\n    window.____c_p_d_l_d.unsubscribe();\n};\n\nexport const defaultLogger = registerConsoleLogger();\n\n/**\n * Added in CSE 2.1.0\n *\n * @param logger\n * @public\n */\nexport const setLogger = (logger: Observer<LoggerPayload>): void => {\n    if (typeof logger !== 'function') {\n        throw new Error(`Client-side Extension: The provided logger needs to be a function`);\n    }\n\n    deregisterLogger();\n    _loggerSubject.prune();\n\n    observeDebugSubject<LoggerPayload>(DebugSubjects.Logger, logger);\n};\n\nconst deregisterDefaultLogger = () => defaultLogger.unsubscribe();\n\n// @VisibleForTesting\nexport { deregisterDefaultLogger as _deregisterDefaultLogger };\n"]}

package/dist/esm/logger/logger.js

@@ -0,0 +1,14 @@
+import { ReplaySubject } from '@atlassian/clientside-extensions-base';
+import { registerDebugSubject } from '../debug-subjects';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["debug"] = "DEBUG";
+    LogLevel["error"] = "ERROR";
+    LogLevel["warn"] = "WARN";
+    LogLevel["deprecation"] = "DEPRECATION";
+    LogLevel["info"] = "INFO";
+})(LogLevel || (LogLevel = {}));
+const loggerSubject = registerDebugSubject("logger" /* Logger */, () => new ReplaySubject(20));
+// Exported for internal use only
+export { loggerSubject as _loggerSubject };
+//# sourceMappingURL=logger.js.map

package/dist/esm/logger/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../../lib/logger/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAiB,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAExE,MAAM,CAAN,IAAY,QAMX;AAND,WAAY,QAAQ;IAChB,2BAAe,CAAA;IACf,2BAAe,CAAA;IACf,yBAAa,CAAA;IACb,uCAA2B,CAAA;IAC3B,yBAAa,CAAA;AACjB,CAAC,EANW,QAAQ,KAAR,QAAQ,QAMnB;AAaD,MAAM,aAAa,GAAG,oBAAoB,wBAAuB,GAAG,EAAE,CAAC,IAAI,aAAa,CAAgB,EAAE,CAAC,CAAC,CAAC;AAE7G,iCAAiC;AACjC,OAAO,EAAE,aAAa,IAAI,cAAc,EAAE,CAAC","sourcesContent":["import { ReplaySubject } from '@atlassian/clientside-extensions-base';\nimport { DebugSubjects, registerDebugSubject } from '../debug-subjects';\n\nexport enum LogLevel {\n    debug = 'DEBUG', // Logs all the things\n    error = 'ERROR',\n    warn = 'WARN',\n    deprecation = 'DEPRECATION',\n    info = 'INFO', // The lowest level\n}\n\nexport type LoggerCallback = (levels: typeof LogLevel) => LoggerPayload;\n\nexport type LoggerPayload = {\n    level: LogLevel;\n    message: string;\n    components?: string | string[];\n    meta?: {\n        [key: string]: unknown;\n    };\n};\n\nconst loggerSubject = registerDebugSubject(DebugSubjects.Logger, () => new ReplaySubject<LoggerPayload>(20));\n\n// Exported for internal use only\nexport { loggerSubject as _loggerSubject };\n"]}

package/dist/types/debug-state-env.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debug-state-env.test.d.ts.map

package/dist/types/debug-state-env.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-state-env.test.d.ts","sourceRoot":"","sources":["../../lib/debug-state-env.test.ts"],"names":[],"mappings":""}

package/dist/types/debug-state.d.ts

@@ -0,0 +1,41 @@
+import type { Observer } from '@atlassian/clientside-extensions-base';
+import { LogLevel } from './logger/logger';
+declare enum ClientExtensionDebugTypes {
+    debug = "debug",
+    logging = "logging",
+    validation = "validation",
+    discovery = "discovery",
+    /** @since 2.1.0 */
+    logLevel = "logLevel"
+}
+declare type DebugTypeKeys = Exclude<keyof typeof ClientExtensionDebugTypes, 'logLevel'>;
+export declare type ClientExtensionDebug = {
+    [key in DebugTypeKeys]: boolean;
+} & {
+    [ClientExtensionDebugTypes.logLevel]: LogLevel;
+};
+export declare type ExposedClientExtensionDebug = {
+    [key in keyof ClientExtensionDebug]: PropertyDescriptor;
+} & {
+    __initialized: PropertyDescriptor;
+};
+declare global {
+    interface Window {
+        ____c_p_d: ExposedClientExtensionDebug;
+    }
+}
+export declare const observeStateChange: (observer: Observer<ClientExtensionDebug>) => import("@atlassian/clientside-extensions-base").Subscription;
+export declare const isDebugEnabled: () => boolean;
+export declare const isLoggingEnabled: () => boolean;
+export declare const isValidationEnabled: () => boolean;
+export declare const isDiscoveryEnabled: () => boolean;
+/** @since 2.1.0 */
+export declare const getLogLevel: () => LogLevel;
+export declare const setDebugEnabled: (value: boolean) => void;
+export declare const setLoggingEnabled: (value: boolean) => void;
+export declare const setValidationEnabled: (value: boolean) => void;
+export declare const setDiscoveryEnabled: (value: boolean) => void;
+/** @since 2.1.0 */
+export declare const setLogLevel: (value: string) => void;
+export {};
+//# sourceMappingURL=debug-state.d.ts.map

package/dist/types/debug-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-state.d.ts","sourceRoot":"","sources":["../../lib/debug-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uCAAuC,CAAC;AAGtE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,aAAK,yBAAyB;IAC1B,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,mBAAmB;IACnB,QAAQ,aAAa;CACxB;AAED,aAAK,aAAa,GAAG,OAAO,CAAC,MAAM,OAAO,yBAAyB,EAAE,UAAU,CAAC,CAAC;AAEjF,oBAAY,oBAAoB,GAAG;KAC9B,GAAG,IAAI,aAAa,GAAG,OAAO;CAClC,GAAG;IACA,CAAC,yBAAyB,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CAClD,CAAC;AAEF,oBAAY,2BAA2B,GAAG;KAAG,GAAG,IAAI,MAAM,oBAAoB,GAAG,kBAAkB;CAAE,GAAG;IACpG,aAAa,EAAE,kBAAkB,CAAC;CACrC,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IAEX,UAAU,MAAM;QAGZ,SAAS,EAAE,2BAA2B,CAAC;KAC1C;CACJ;AAmHD,eAAO,MAAM,kBAAkB,aAAc,QAAQ,CAAC,oBAAoB,CAAC,iEACC,CAAC;AAE7E,eAAO,MAAM,cAAc,eAE1B,CAAC;AAEF,eAAO,MAAM,gBAAgB,eAE5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,eAE/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,eAE9B,CAAC;AAEF,mBAAmB;AACnB,eAAO,MAAM,WAAW,QAAO,QAI9B,CAAC;AAEF,eAAO,MAAM,eAAe,UAAW,OAAO,SAE7C,CAAC;AAEF,eAAO,MAAM,iBAAiB,UAAW,OAAO,SAE/C,CAAC;AAEF,eAAO,MAAM,oBAAoB,UAAW,OAAO,SAElD,CAAC;AAEF,eAAO,MAAM,mBAAmB,UAAW,OAAO,SAEjD,CAAC;AAEF,mBAAmB;AACnB,eAAO,MAAM,WAAW,UAAW,MAAM,SAIxC,CAAC"}

package/dist/types/debug-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debug-state.test.d.ts.map

package/dist/types/debug-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-state.test.d.ts","sourceRoot":"","sources":["../../lib/debug-state.test.ts"],"names":[],"mappings":""}

package/dist/types/debug-subjects.d.ts

@@ -0,0 +1,25 @@
+import type { Observer, Subject } from '@atlassian/clientside-extensions-base';
+declare type ExposedClientExtensionSubjects = {
+    __initialized: PropertyDescriptor;
+    subjects: PropertyDescriptor;
+};
+export declare const enum DebugSubjects {
+    Logger = "logger",
+    State = "state"
+}
+declare global {
+    interface Window {
+        ____c_p_s: ExposedClientExtensionSubjects;
+    }
+}
+declare type UnpackPayloadType<SubjectType> = SubjectType extends Subject<infer U> ? U : never;
+/**
+ * Registers a debug subject as singleton
+ *
+ * @param key
+ * @param subjectFactory
+ */
+export declare const registerDebugSubject: <SubjectType extends Subject<PayloadType>, PayloadType = UnpackPayloadType<SubjectType>>(key: DebugSubjects, subjectFactory: () => SubjectType) => SubjectType;
+export declare const observeDebugSubject: <PayloadType>(key: DebugSubjects, observer: Observer<PayloadType>) => import("@atlassian/clientside-extensions-base").Subscription;
+export {};
+//# sourceMappingURL=debug-subjects.d.ts.map

package/dist/types/debug-subjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-subjects.d.ts","sourceRoot":"","sources":["../../lib/debug-subjects.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAE/E,aAAK,8BAA8B,GAAG;IAClC,aAAa,EAAE,kBAAkB,CAAC;IAClC,QAAQ,EAAE,kBAAkB,CAAC;CAChC,CAAC;AAEF,0BAAkB,aAAa;IAC3B,MAAM,WAAW;IACjB,KAAK,UAAU;CAClB;AAMD,OAAO,CAAC,MAAM,CAAC;IAEX,UAAU,MAAM;QAEZ,SAAS,EAAE,8BAA8B,CAAC;KAC7C;CACJ;AAuBD,aAAK,iBAAiB,CAAC,WAAW,IAAI,WAAW,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEvF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,gGACxB,aAAa,mDAYrB,CAAC;AAEF,eAAO,MAAM,mBAAmB,qBAAsB,aAAa,kGAQlE,CAAC"}

package/dist/types/debug-subjects.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debug-subjects.test.d.ts.map

package/dist/types/debug-subjects.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-subjects.test.d.ts","sourceRoot":"","sources":["../../lib/debug-subjects.test.ts"],"names":[],"mappings":""}

package/dist/types/debug.d.ts

@@ -0,0 +1,3 @@
+import type { LoggerCallback } from './logger/logger';
+export declare const onDebug: (callback: LoggerCallback) => void;
+//# sourceMappingURL=debug.d.ts.map

package/dist/types/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../lib/debug.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,iBAAiB,CAAC;AAIrE,eAAO,MAAM,OAAO,aAAc,cAAc,SAiB/C,CAAC"}

package/dist/types/debug.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debug.test.d.ts.map

package/dist/types/debug.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.test.d.ts","sourceRoot":"","sources":["../../lib/debug.test.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export { onDebug } from './debug';
+export type { LoggerPayload } from './logger/logger';
+export { LogLevel } from './logger/logger';
+export { 
+/** @deprecated in 2.1.0 */ observeLogger, 
+/** @since in 2.1.0 */ setLogger, _deregisterDefaultLogger, } from './logger/default-logger';
+export { /** @since in 2.1.0 */ consoleLogger } from './logger/console';
+export { isDebugEnabled, isLoggingEnabled, isDiscoveryEnabled, isValidationEnabled, setDebugEnabled, setLoggingEnabled, setDiscoveryEnabled, setValidationEnabled, observeStateChange, } from './debug-state';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,OAAO;AACH,2BAA2B,CAAC,aAAa;AACzC,sBAAsB,CAAC,SAAS,EAChC,wBAAwB,GAC3B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,sBAAsB,CAAC,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAExE,OAAO,EACH,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,GACrB,MAAM,eAAe,CAAC"}

package/dist/types/logger/console.d.ts

@@ -0,0 +1,3 @@
+import type { LoggerPayload } from './logger';
+export declare const consoleLogger: (payload: LoggerPayload) => void;
+//# sourceMappingURL=console.d.ts.map

package/dist/types/logger/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../lib/logger/console.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AA8C9C,eAAO,MAAM,aAAa,YAAa,aAAa,SA0BnD,CAAC"}

package/dist/types/logger/console.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=console.test.d.ts.map

package/dist/types/logger/console.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.test.d.ts","sourceRoot":"","sources":["../../../lib/logger/console.test.ts"],"names":[],"mappings":""}

package/dist/types/logger/default-logger.d.ts

@@ -0,0 +1,25 @@
+import type { Observer, Subscription } from '@atlassian/clientside-extensions-base';
+import type { LoggerPayload } from './logger';
+declare global {
+    interface Window {
+        ____c_p_d_l_d?: Subscription;
+    }
+}
+/**
+ * We need to keep and expose the "observeLogger" function for a legacy reason.
+ * It should be removed in CSEv3
+ *
+ * @deprecated
+ */
+export declare const observeLogger: (observer: Observer<LoggerPayload>) => Subscription;
+export declare const defaultLogger: Subscription;
+/**
+ * Added in CSE 2.1.0
+ *
+ * @param logger
+ * @public
+ */
+export declare const setLogger: (logger: Observer<LoggerPayload>) => void;
+declare const deregisterDefaultLogger: () => void;
+export { deregisterDefaultLogger as _deregisterDefaultLogger };
+//# sourceMappingURL=default-logger.d.ts.map

package/dist/types/logger/default-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-logger.d.ts","sourceRoot":"","sources":["../../../lib/logger/default-logger.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAGpF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG9C,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QAEZ,aAAa,CAAC,EAAE,YAAY,CAAC;KAChC;CACJ;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,aAAc,QAAQ,CAAC,aAAa,CAAC,KAAG,YAEjE,CAAC;AAsBF,eAAO,MAAM,aAAa,cAA0B,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,WAAY,QAAQ,CAAC,aAAa,CAAC,KAAG,IAS3D,CAAC;AAEF,QAAA,MAAM,uBAAuB,YAAoC,CAAC;AAGlE,OAAO,EAAE,uBAAuB,IAAI,wBAAwB,EAAE,CAAC"}

package/dist/types/logger/logger.d.ts

@@ -0,0 +1,20 @@
+import { ReplaySubject } from '@atlassian/clientside-extensions-base';
+export declare enum LogLevel {
+    debug = "DEBUG",
+    error = "ERROR",
+    warn = "WARN",
+    deprecation = "DEPRECATION",
+    info = "INFO"
+}
+export declare type LoggerCallback = (levels: typeof LogLevel) => LoggerPayload;
+export declare type LoggerPayload = {
+    level: LogLevel;
+    message: string;
+    components?: string | string[];
+    meta?: {
+        [key: string]: unknown;
+    };
+};
+declare const loggerSubject: ReplaySubject<LoggerPayload>;
+export { loggerSubject as _loggerSubject };
+//# sourceMappingURL=logger.d.ts.map

package/dist/types/logger/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../lib/logger/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAGtE,oBAAY,QAAQ;IAChB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,IAAI,SAAS;IACb,WAAW,gBAAgB;IAC3B,IAAI,SAAS;CAChB;AAED,oBAAY,cAAc,GAAG,CAAC,MAAM,EAAE,OAAO,QAAQ,KAAK,aAAa,CAAC;AAExE,oBAAY,aAAa,GAAG;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,IAAI,CAAC,EAAE;QACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KAC1B,CAAC;CACL,CAAC;AAEF,QAAA,MAAM,aAAa,8BAAyF,CAAC;AAG7G,OAAO,EAAE,aAAa,IAAI,cAAc,EAAE,CAAC"}

package/lib/__mocks__/debug-state.mock.ts

@@ -0,0 +1,7 @@
+const observeStateChange = jest.fn();
+const isDebugEnabled = jest.fn();
+const isLoggingEnabled = jest.fn();
+const isValidationEnabled = jest.fn();
+const isDiscoveryEnabled = jest.fn();
+
+export { observeStateChange, isDebugEnabled, isLoggingEnabled, isValidationEnabled, isDiscoveryEnabled };

package/lib/__mocks__/debug-subjects.mock.ts

@@ -0,0 +1,4 @@
+const observeDebugSubject = jest.fn();
+const registerDebugSubject = jest.fn();
+
+export { observeDebugSubject, registerDebugSubject };

package/lib/debug-state-env.test.ts

@@ -0,0 +1,53 @@
+/* eslint-disable  no-underscore-dangle */
+import { LogLevel } from './logger/logger';
+
+/**
+ * Using async imports in order to test process.env.NODE_ENV usage in module
+ * https://stackoverflow.com/a/48042799
+ */
+describe('debug-state initialization', () => {
+    const ORIGINAL_NODE_ENV = process.env.NODE_ENV;
+
+    beforeEach(() => {
+        // reset NODE_ENV to whatever it was.
+        process.env.NODE_ENV = ORIGINAL_NODE_ENV;
+        // reset cache of loaded modules. This will ensure that the module is re-initialized
+        // with the new NODE_ENV value
+        delete window.____c_p_d;
+        jest.resetModules();
+    });
+
+    it('should be set to FALSE if process.env.NODE_ENV is "production"', async () => {
+        process.env.NODE_ENV = 'production';
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const debugStateModule = await import('./debug-state');
+
+        expect(window.____c_p_d.__initialized).toBe(true);
+
+        expect(window.____c_p_d.debug).toBe(false);
+        expect(window.____c_p_d.logging).toBe(false);
+        expect(window.____c_p_d.validation).toBe(false);
+        expect(window.____c_p_d.discovery).toBe(false);
+    });
+
+    it('should set the default log level to "ERROR" if process.env.NODE_ENV is "production"', async () => {
+        process.env.NODE_ENV = 'production';
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        await import('./debug-state');
+
+        expect(window.____c_p_d.__initialized).toBe(true);
+        expect(window.____c_p_d.logLevel).toBe(LogLevel.error);
+    });
+
+    it('should be set the default log level to "INFO" if process.env.NODE_ENV is different than "production"', async () => {
+        process.env.NODE_ENV = 'development';
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        await import('./debug-state');
+
+        expect(window.____c_p_d.__initialized).toBe(true);
+        expect(window.____c_p_d.logLevel).toBe(LogLevel.info);
+    });
+});

package/lib/debug-state.test.ts

@@ -0,0 +1,87 @@
+/* eslint-disable no-underscore-dangle, jest/no-standalone-expect */
+import cases from 'jest-in-case';
+import type { ExposedClientExtensionDebug } from './debug-state';
+import { isDebugEnabled, isDiscoveryEnabled, isLoggingEnabled, isValidationEnabled, getLogLevel, setLogLevel } from './debug-state';
+import { LogLevel } from './logger/logger';
+
+describe('debug utils', () => {
+    beforeEach(() => {
+        (window.____c_p_d as unknown) = false;
+    });
+
+    cases(
+        'should be active if respective flag is set to TRUE',
+        (opts) => {
+            expect(opts.isUtil()).toBe(false);
+
+            // switch flag to TRUE
+            (window.____c_p_d as unknown) = { [opts.key]: true };
+
+            expect(opts.isUtil()).toBe(true);
+
+            // switch ALL false
+            (window.____c_p_d as unknown) = false;
+
+            expect(opts.isUtil()).toBe(false);
+
+            // switch ALL true
+            (window.____c_p_d as unknown) = true;
+
+            expect(opts.isUtil()).toBe(true);
+        },
+        {
+            isDebugEnabled: { isUtil: isDebugEnabled, key: 'debug' },
+            isLoggingEnabled: { isUtil: isLoggingEnabled, key: 'logging' },
+            isValidationEnabled: { isUtil: isValidationEnabled, key: 'validation' },
+            isDiscoveryEnabled: { isUtil: isDiscoveryEnabled, key: 'discovery' },
+        },
+    );
+
+    describe('log levels', () => {
+        let prevDebugState: ExposedClientExtensionDebug;
+
+        beforeEach(() => {
+            prevDebugState = window.____c_p_d;
+        });
+
+        afterEach(() => {
+            window.____c_p_d = prevDebugState;
+        });
+
+        it('should allow to change the default log level using utils', () => {
+            expect(getLogLevel()).toBe(LogLevel.info);
+
+            setLogLevel(LogLevel.debug);
+
+            expect(getLogLevel()).toBe(LogLevel.debug);
+        });
+
+        it('should allow to change log level using global variable', () => {
+            // Change with enum
+            (window.____c_p_d.logLevel as LogLevel) = LogLevel.error;
+            expect(getLogLevel()).toBe(LogLevel.error);
+
+            // Change with string value
+            (window.____c_p_d.logLevel as string) = 'warn';
+            expect(getLogLevel()).toBe(LogLevel.warn);
+        });
+
+        it('should fallback to a default "INFO" level when using unsupported runtime value', () => {
+            (window.____c_p_d.logLevel as string) = 'show-me-all-the-things';
+
+            expect(getLogLevel()).toBe(LogLevel.info);
+        });
+    });
+
+    describe('compatibility mode', () => {
+        it('should fallback to a default "INFO" level when "logLevel" property is missing e.g. CSE < 2.1.0', () => {
+            Object.defineProperty(window, '____c_p_d', {
+                value: {},
+                configurable: true,
+                writable: true,
+            });
+
+            expect(getLogLevel()).toBe(LogLevel.info);
+        });
+    });
+});

package/lib/debug-state.ts

@@ -0,0 +1,198 @@
+/* eslint-disable no-underscore-dangle */
+
+import type { Observer } from '@atlassian/clientside-extensions-base';
+import { ReplaySubject } from '@atlassian/clientside-extensions-base';
+import { DebugSubjects, observeDebugSubject, registerDebugSubject } from './debug-subjects';
+import { LogLevel } from './logger/logger';
+
+enum ClientExtensionDebugTypes {
+    debug = 'debug',
+    logging = 'logging',
+    validation = 'validation',
+    discovery = 'discovery',
+    /** @since 2.1.0 */
+    logLevel = 'logLevel',
+}
+
+type DebugTypeKeys = Exclude<keyof typeof ClientExtensionDebugTypes, 'logLevel'>;
+
+export type ClientExtensionDebug = {
+    [key in DebugTypeKeys]: boolean;
+} & {
+    [ClientExtensionDebugTypes.logLevel]: LogLevel;
+};
+
+export type ExposedClientExtensionDebug = { [key in keyof ClientExtensionDebug]: PropertyDescriptor } & {
+    __initialized: PropertyDescriptor;
+};
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface Window {
+        // The global ____c_p_d is a primitive boolean value that holds additional properties
+        // Due to historical name changes the "p" still represents the old "plugin" nomenclature
+        ____c_p_d: ExposedClientExtensionDebug;
+    }
+}
+
+const defineDebugGlobal = (previousGlobal: unknown) => {
+    // initialize as boolean
+    const debugGlobal = Object.create(null);
+    const debugStates: ClientExtensionDebug = {
+        debug: false,
+        logging: false,
+        validation: false,
+        discovery: false,
+        /** @since 2.1.0 */
+        // In dev mode we set default loglevel to INFO
+        logLevel: process.env.NODE_ENV === 'production' ? LogLevel.error : LogLevel.info,
+    };
+
+    const debugStateSubject = registerDebugSubject(DebugSubjects.State, () => new ReplaySubject(1));
+
+    const properties: ExposedClientExtensionDebug = {
+        debug: {
+            get() {
+                return debugStates.debug;
+            },
+            set(val: unknown) {
+                debugStates.debug = Boolean(val);
+                debugStateSubject.notify(debugStates);
+            },
+        },
+        logging: {
+            get() {
+                return debugStates.logging;
+            },
+            set(val: unknown) {
+                debugStates.logging = Boolean(val);
+                debugStateSubject.notify(debugStates);
+            },
+        },
+        validation: {
+            get() {
+                return debugStates.validation;
+            },
+            set(val: unknown) {
+                debugStates.validation = Boolean(val);
+                debugStateSubject.notify(debugStates);
+            },
+        },
+        discovery: {
+            get() {
+                return debugStates.discovery;
+            },
+            set(val: unknown) {
+                debugStates.discovery = Boolean(val);
+                debugStateSubject.notify(debugStates);
+            },
+        },
+        /** @since 2.1.0 */
+        logLevel: {
+            get() {
+                return debugStates.logLevel;
+            },
+            set(val: unknown) {
+                let level = String(val).toUpperCase() as LogLevel;
+
+                // Handle runtime errors
+                if (!Object.values(LogLevel).includes(level)) {
+                    level = LogLevel.info;
+                }
+
+                debugStates.logLevel = level;
+                debugStateSubject.notify(debugStates);
+            },
+        },
+        __initialized: { value: true, writable: false },
+    };
+    Object.defineProperties(debugGlobal, properties);
+
+    Object.defineProperty(window, '____c_p_d', {
+        configurable: true, // needed for testing :(
+        get() {
+            return debugGlobal;
+        },
+        set(val) {
+            // its a boolean
+            if (val === true || val === false) {
+                debugGlobal.debug = val;
+                debugGlobal.logging = val;
+                debugGlobal.validation = val;
+                debugGlobal.discovery = val;
+                return;
+            }
+
+            // we can handle booleans - like above
+            // or objects (except null) and nothing else.
+            if (typeof val !== 'object' || val === null) {
+                return;
+            }
+
+            const clientExtensionDebugKeys = Object.keys(ClientExtensionDebugTypes) as (keyof ClientExtensionDebug)[];
+
+            clientExtensionDebugKeys.forEach((key) => {
+                if (key in val) {
+                    debugGlobal[key] = val[key];
+                }
+            });
+        },
+    });
+
+    // Now, we can use the previous value e.g. boolean, to set the value for all flags
+    window.____c_p_d = previousGlobal as ExposedClientExtensionDebug;
+};
+
+// Register global value only once
+if (!('____c_p_d' in window) || !window.____c_p_d.__initialized) {
+    defineDebugGlobal(window.____c_p_d ?? process.env.NODE_ENV !== 'production');
+}
+
+export const observeStateChange = (observer: Observer<ClientExtensionDebug>) =>
+    observeDebugSubject<ClientExtensionDebug>(DebugSubjects.State, observer);
+
+export const isDebugEnabled = () => {
+    return window.____c_p_d.debug as boolean;
+};
+
+export const isLoggingEnabled = () => {
+    return window.____c_p_d.logging as boolean;
+};
+
+export const isValidationEnabled = () => {
+    return window.____c_p_d.validation as boolean;
+};
+
+export const isDiscoveryEnabled = () => {
+    return window.____c_p_d.discovery as boolean;
+};
+
+/** @since 2.1.0 */
+export const getLogLevel = (): LogLevel => {
+    const logLevel = window.____c_p_d.logLevel as LogLevel;
+
+    return logLevel ?? LogLevel.info;
+};
+
+export const setDebugEnabled = (value: boolean) => {
+    (window.____c_p_d.debug as boolean) = value;
+};
+
+export const setLoggingEnabled = (value: boolean) => {
+    (window.____c_p_d.logging as boolean) = value;
+};
+
+export const setValidationEnabled = (value: boolean) => {
+    (window.____c_p_d.validation as boolean) = value;
+};
+
+export const setDiscoveryEnabled = (value: boolean) => {
+    (window.____c_p_d.discovery as boolean) = value;
+};
+
+/** @since 2.1.0 */
+export const setLogLevel = (value: string) => {
+    const level = value.toUpperCase() as LogLevel;
+
+    (window.____c_p_d.logLevel as LogLevel) = level;
+};