standard-log 7.1.0 → 9.0.0

package/esm/platform.browser.js

@@ -0,0 +1,6 @@
+export const toInspectLogEntry = (e) => e;
+export function isConsoleDebugAvailable() {
+    return true;
+}
+export const polyfill = {};
+//# sourceMappingURL=platform.browser.js.map

package/esm/platform.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.browser.js","sourceRoot":"","sources":["../ts/platform.browser.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAW,EAAE,EAAE,CAAC,CAAC,CAAA;AACnD,MAAM,UAAU,uBAAuB;IACrC,OAAO,IAAI,CAAA;AACb,CAAC;AAED,MAAM,CAAC,MAAM,QAAQ,GAA8B,EAAE,CAAA","sourcesContent":["import type { ConsoleLike, LogEntry } from './types.js'\n\nexport const toInspectLogEntry = (e: LogEntry) => e\nexport function isConsoleDebugAvailable() {\n  return true\n}\n\nexport const polyfill: { console?: ConsoleLike } = {}\n"]}

package/esm/platform.d.ts

@@ -0,0 +1,8 @@
+import type { ConsoleLike, LogEntry } from './types.js';
+export declare function semverGt(versionString: string, version: [number, number, number]): boolean;
+export declare function isConsoleDebugAvailable(): boolean;
+export declare const toInspectLogEntry: (e: LogEntry) => LogEntry;
+export declare const polyfill: {
+    console?: ConsoleLike;
+};
+//# sourceMappingURL=platform.d.ts.map

package/esm/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../ts/platform.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAEvD,wBAAgB,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WAOhF;AAGD,wBAAgB,uBAAuB,YAKtC;AAED,eAAO,MAAM,iBAAiB,MAAO,QAAQ,aAEzC,CAAA;AAEJ,eAAO,MAAM,QAAQ,EAAE;IAAE,OAAO,CAAC,EAAE,WAAW,CAAA;CAAO,CAAA"}

package/esm/platform.js

@@ -0,0 +1,20 @@
+import { inspect } from 'util';
+export function semverGt(versionString, version) {
+    const actual = versionString.split('.').reverse().reduce((p, v, i) => {
+        p += Number.parseInt(v, 10) * Math.pow(100, i);
+        return p;
+    }, 0);
+    return actual > (version[0] * 10000 + version[1] * 100 + version[2]);
+}
+// istanbul ignore next
+export function isConsoleDebugAvailable() {
+    // without this, systemJs will complain `process is not defined`
+    if (!global.process)
+        return true;
+    const versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version;
+    return semverGt(versionString, [9, 3, 0]);
+}
+export const toInspectLogEntry = (e) => (e.args = e.args.map(value => typeof value === 'object' && value !== null ? inspect(value) : value),
+    e);
+export const polyfill = {};
+//# sourceMappingURL=platform.js.map

package/esm/platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","sourceRoot":"","sources":["../ts/platform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAG9B,MAAM,UAAU,QAAQ,CAAC,aAAqB,EAAE,OAAiC;IAC/E,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QACnE,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;QAC9C,OAAO,CAAC,CAAA;IACV,CAAC,EAAE,CAAC,CAAC,CAAA;IAEL,OAAO,MAAM,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;AACtE,CAAC;AAED,uBAAuB;AACvB,MAAM,UAAU,uBAAuB;IACrC,gEAAgE;IAChE,IAAI,CAAC,MAAM,CAAC,OAAO;QAAE,OAAO,IAAI,CAAA;IAChC,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAA;IAClG,OAAO,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAC3C,CAAC;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAW,EAAE,EAAE,CAAC,CAChD,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAClG,CAAC,CAAC,CAAA;AAEJ,MAAM,CAAC,MAAM,QAAQ,GAA8B,EAAE,CAAA","sourcesContent":["import { inspect } from 'util'\nimport type { ConsoleLike, LogEntry } from './types.js'\n\nexport function semverGt(versionString: string, version: [number, number, number]) {\n  const actual = versionString.split('.').reverse().reduce((p, v, i) => {\n    p += Number.parseInt(v, 10) * Math.pow(100, i)\n    return p\n  }, 0)\n\n  return actual > (version[0] * 10000 + version[1] * 100 + version[2])\n}\n\n// istanbul ignore next\nexport function isConsoleDebugAvailable() {\n  // without this, systemJs will complain `process is not defined`\n  if (!global.process) return true\n  const versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version\n  return semverGt(versionString, [9, 3, 0])\n}\n\nexport const toInspectLogEntry = (e: LogEntry) => (\n  e.args = e.args.map(value => typeof value === 'object' && value !== null ? inspect(value) : value),\n  e)\n\nexport const polyfill: { console?: ConsoleLike } = {}\n"]}

package/esm/platform.spec.d.ts

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

package/esm/platform.spec.d.ts.map

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

package/esm/platform.spec.js

@@ -0,0 +1,20 @@
+import { semverGt } from './platform.js';
+test('9.3.0 returns false', () => {
+    expect(semverGt('9.3.0', [9, 3, 0])).toBe(false);
+});
+test('9.3.1 returns true', () => {
+    expect(semverGt('9.3.1', [9, 3, 0])).toBe(true);
+});
+test('9.3.1 returns true', () => {
+    expect(semverGt('9.3.1', [9, 3, 0])).toBe(true);
+});
+test('9.4.0 returns true', () => {
+    expect(semverGt('9.4.0', [9, 3, 0])).toBe(true);
+});
+test('9.10.0 returns true', () => {
+    expect(semverGt('9.10.0', [9, 3, 0])).toBe(true);
+});
+test('10.0.0 returns true', () => {
+    expect(semverGt('10.0.0', [9, 3, 0])).toBe(true);
+});
+//# sourceMappingURL=platform.spec.js.map

package/esm/platform.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.spec.js","sourceRoot":"","sources":["../ts/platform.spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,IAAI,CAAC,qBAAqB,EAAE,GAAG,EAAE;IAC/B,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AAClD,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAC9B,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACjD,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAC9B,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACjD,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAC9B,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACjD,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,qBAAqB,EAAE,GAAG,EAAE;IAC/B,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAClD,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,qBAAqB,EAAE,GAAG,EAAE;IAC/B,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAClD,CAAC,CAAC,CAAA","sourcesContent":["import { semverGt } from './platform.js'\n\ntest('9.3.0 returns false', () => {\n  expect(semverGt('9.3.0', [9, 3, 0])).toBe(false)\n})\n\ntest('9.3.1 returns true', () => {\n  expect(semverGt('9.3.1', [9, 3, 0])).toBe(true)\n})\n\ntest('9.3.1 returns true', () => {\n  expect(semverGt('9.3.1', [9, 3, 0])).toBe(true)\n})\n\ntest('9.4.0 returns true', () => {\n  expect(semverGt('9.4.0', [9, 3, 0])).toBe(true)\n})\n\ntest('9.10.0 returns true', () => {\n  expect(semverGt('9.10.0', [9, 3, 0])).toBe(true)\n})\n\ntest('10.0.0 returns true', () => {\n  expect(semverGt('10.0.0', [9, 3, 0])).toBe(true)\n})\n"]}

package/esm/standardLog.d.ts

@@ -0,0 +1,21 @@
+import { StackTraceMeta } from '@just-func/types';
+import type { Logger, LoggerOptions, LogLevel, LogMethodNames, StandardLogOptions } from './types.js';
+export interface StandardLog<N extends string = LogMethodNames> {
+    readonly logLevel: number;
+    toLogLevelName(level: number): string;
+    toLogLevel(name: N): number;
+    getLogger(params: [id: string, options?: LoggerOptions], meta?: StackTraceMeta): Logger<N>;
+}
+export declare function createStandardLog<N extends string = LogMethodNames>(options?: Partial<StandardLogOptions<N>>, _meta?: StackTraceMeta): Readonly<StandardLog<N>>;
+export declare function createStandardLogForTest(logLevel?: LogLevel): {
+    reporter: import("./memory.js").MemoryLogReporter;
+    logLevel: number;
+    toLogLevelName: (level: number) => string;
+    toLogLevel: (name: LogMethodNames) => number;
+    getLogger: (params: [id: string, options?: LoggerOptions | undefined], meta?: StackTraceMeta | undefined) => Logger<LogMethodNames>;
+};
+/**
+ * Suppress logging within the code block.
+ */
+export declare function suppressLogs<R>(block: () => R, log: Logger, ...logs: Logger[]): R;
+//# sourceMappingURL=standardLog.d.ts.map

package/esm/standardLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardLog.d.ts","sourceRoot":"","sources":["../ts/standardLog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAMjD,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAErG,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,MAAM,GAAG,cAAc;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,UAAU,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC;IAC5B,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;CAC3F;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,cAAc,EACjE,OAAO,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,cAAc,GAC/D,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAkB1B;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,GAAE,QAA0B;;;;;;EAI5E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAA"}

package/esm/standardLog.js

@@ -0,0 +1,36 @@
+import { required } from 'type-plus';
+import { createLogger } from './logger.js';
+import { logLevels } from './logLevels.js';
+import { createLogStore } from './logStore.js';
+import { createMemoryLogReporter } from './memory.js';
+export function createStandardLog(options, _meta) {
+    const store = createLogStore(required({ logLevel: logLevels.info }, options));
+    return Object.freeze({
+        get logLevel() { return store.logLevel; },
+        toLogLevelName(level) {
+            return store.logLevelStore.getName(level);
+        },
+        toLogLevel(name) {
+            return store.logLevelStore.getLevel(name);
+        },
+        getLogger([id, options], meta) {
+            if (store.loggers[id])
+                return store.loggers[id];
+            const opt = required({ level: store.logLevel }, options);
+            return store.loggers[id] = createLogger([store, id, opt], { ssf: this.getLogger, ...meta });
+        }
+    });
+}
+export function createStandardLogForTest(logLevel = logLevels.debug) {
+    const reporter = createMemoryLogReporter();
+    const standardLog = createStandardLog({ reporters: [reporter], logLevel });
+    return { ...standardLog, reporter };
+}
+export function suppressLogs(block, ...logs) {
+    const origLevels = logs.map(l => l.level);
+    logs.forEach(l => l.level = logLevels.none);
+    const result = block();
+    logs.forEach((l, i) => l.level = origLevels[i]);
+    return result;
+}
+//# sourceMappingURL=standardLog.js.map

package/esm/standardLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardLog.js","sourceRoot":"","sources":["../ts/standardLog.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAUrD,MAAM,UAAU,iBAAiB,CAC/B,OAAwC,EAAE,KAAsB;IAEhE,MAAM,KAAK,GAAG,cAAc,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC,CAAA;IAE7E,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,IAAI,QAAQ,KAAK,OAAO,KAAK,CAAC,QAAQ,CAAA,CAAC,CAAC;QAExC,cAAc,CAAC,KAAa;YAC1B,OAAO,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3C,CAAC;QACD,UAAU,CAAC,IAAY;YACrB,OAAO,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QAC3C,CAAC;QACD,SAAS,CAAC,CAAC,EAAE,EAAE,OAAO,CAAwC,EAAE,IAAqB;YACnF,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;gBAAE,OAAO,KAAK,CAAC,OAAO,CAAC,EAAE,CAAQ,CAAA;YACtD,MAAM,GAAG,GAAG,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAA;YACxD,OAAO,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,KAAK,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,GAAG,IAAI,EAAE,CAAQ,CAAA;QACpG,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,WAAqB,SAAS,CAAC,KAAK;IAC3E,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAA;IAC1C,MAAM,WAAW,GAAG,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAA;IAC1E,OAAO,EAAE,GAAG,WAAW,EAAE,QAAQ,EAAE,CAAA;AACrC,CAAC;AAMD,MAAM,UAAU,YAAY,CAAI,KAAc,EAAE,GAAG,IAAc;IAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;IACzC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;IAC3C,MAAM,MAAM,GAAG,KAAK,EAAE,CAAA;IACtB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/C,OAAO,MAAM,CAAA;AACf,CAAC","sourcesContent":["import { StackTraceMeta } from '@just-func/types'\nimport { required } from 'type-plus'\nimport { createLogger } from './logger.js'\nimport { logLevels } from './logLevels.js'\nimport { createLogStore } from './logStore.js'\nimport { createMemoryLogReporter } from './memory.js'\nimport type { Logger, LoggerOptions, LogLevel, LogMethodNames, StandardLogOptions } from './types.js'\n\nexport interface StandardLog<N extends string = LogMethodNames> {\n  readonly logLevel: number,\n  toLogLevelName(level: number): string,\n  toLogLevel(name: N): number,\n  getLogger(params: [id: string, options?: LoggerOptions], meta?: StackTraceMeta): Logger<N>\n}\n\nexport function createStandardLog<N extends string = LogMethodNames>(\n  options?: Partial<StandardLogOptions<N>>, _meta?: StackTraceMeta\n): Readonly<StandardLog<N>> {\n  const store = createLogStore(required({ logLevel: logLevels.info }, options))\n\n  return Object.freeze({\n    get logLevel() { return store.logLevel },\n\n    toLogLevelName(level: number) {\n      return store.logLevelStore.getName(level)\n    },\n    toLogLevel(name: string) {\n      return store.logLevelStore.getLevel(name)\n    },\n    getLogger([id, options]: [id: string, options?: LoggerOptions], meta?: StackTraceMeta): Logger<N> {\n      if (store.loggers[id]) return store.loggers[id] as any\n      const opt = required({ level: store.logLevel }, options)\n      return store.loggers[id] = createLogger([store, id, opt], { ssf: this.getLogger, ...meta }) as any\n    }\n  })\n}\n\nexport function createStandardLogForTest(logLevel: LogLevel = logLevels.debug) {\n  const reporter = createMemoryLogReporter()\n  const standardLog = createStandardLog({ reporters: [reporter], logLevel })\n  return { ...standardLog, reporter }\n}\n\n/**\n * Suppress logging within the code block.\n */\nexport function suppressLogs<R>(block: () => R, log: Logger, ...logs: Logger[]): R\nexport function suppressLogs<R>(block: () => R, ...logs: Logger[]): R {\n  const origLevels = logs.map(l => l.level)\n  logs.forEach(l => l.level = logLevels.none)\n  const result = block()\n  logs.forEach((l, i) => l.level = origLevels[i])\n  return result\n}\n"]}

package/esm/standardLog.spec.d.ts

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

package/esm/standardLog.spec.d.ts.map

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

package/esm/standardLog.spec.js

@@ -0,0 +1,434 @@
+import { assertron as a } from 'assertron';
+import { InvalidId } from './errors.js';
+import { logLevels, toLogLevelName } from './logLevels.js';
+import { createMemoryLogReporter } from './memory.js';
+import { createStandardLog, createStandardLogForTest, suppressLogs } from './standardLog.js';
+import { assertSSF, wrapTest } from './testUtil.js';
+describe('createStandardLog()', () => {
+    describe('logLevel', () => {
+        it('is default to info', () => {
+            const actual = createStandardLog();
+            expect(actual.logLevel).toBe(logLevels.info);
+        });
+        it('is readonly', () => {
+            const actual = createStandardLog();
+            a.throws(() => actual.logLevel = logLevels.planck, err => /only a getter/.test(err));
+        });
+        it('set logLevel from options', () => {
+            const actual = createStandardLog({ logLevel: logLevels.planck });
+            expect(actual.logLevel).toBe(logLevels.planck);
+        });
+    });
+    describe('custom levels', () => {
+        it('can define custom levels', () => {
+            const actual = createStandardLog({ customLevels: { urgent: 80 } });
+            expect(actual.toLogLevelName(80)).toBe('urgent');
+        });
+    });
+    describe('reporters', () => {
+        it('can specify reporter', () => {
+            const mem = createMemoryLogReporter();
+            const sl = createStandardLog({ reporters: [mem] });
+            const log = sl.getLogger(['x']);
+            log.info('abc');
+            expect(mem.logs.length).toBe(1);
+        });
+    });
+});
+describe('createStandardLogForTest()', () => {
+    it('returns with memory reporter', () => {
+        const { reporter } = createStandardLogForTest();
+        expect(reporter.getLogMessageWithLevel()).toBe('');
+    });
+    it('defaults to debug', () => {
+        const store = createStandardLogForTest();
+        expect(store.logLevel).toBe(logLevels.debug);
+    });
+});
+describe('getLogger()', () => {
+    it('supports id with alphanumeric and :_-.', () => {
+        const sl = createStandardLog();
+        sl.getLogger(['abcdefghijklmnopqrstuvwxyz:-_.1234567890']);
+    });
+    it('supports id with unicode', () => {
+        const sl = createStandardLog();
+        sl.getLogger(['ミク香港']);
+    });
+    it('supports id with @, \\ and /', () => {
+        const sl = createStandardLog();
+        sl.getLogger(['@unional/fixture']);
+        sl.getLogger([`a\\b\\c`]);
+    });
+    it.each('`~!#$%^&*()=+|[]{}<>,?'.split(''))('throws if id has unsupported character %s', (char) => {
+        const sl = createStandardLog();
+        a.throws(() => sl.getLogger([char]), InvalidId);
+    });
+    it('throw InvalidId with ssf to the call site', () => {
+        const sl = createStandardLog();
+        const err = a.throws(() => sl.getLogger(['!']), InvalidId);
+        assertSSF(err, __filename);
+    });
+    test('id is readonly', () => {
+        const sl = createStandardLog();
+        const log = sl.getLogger(['id is readonly']);
+        a.throws(() => log.id = 'b');
+    });
+    test('get logger with same name gets the same instance', () => {
+        const sl = createStandardLog();
+        const expected = sl.getLogger(['same-inst']);
+        const actual = sl.getLogger(['same-inst']);
+        expect(actual).toBe(expected);
+    });
+    it('can specify local log level', () => {
+        const sl = createStandardLog();
+        const log = sl.getLogger(['local', { level: logLevels.trace }]);
+        expect(log.level).toBe(logLevels.trace);
+    });
+    test('new logger will get custom level', () => {
+        const sl = createStandardLog({ customLevels: { 'to_logger': 1234 } });
+        const actual = sl.getLogger(['to_logger_logger']);
+        expect(typeof actual.to_logger).toBe('function');
+    });
+    describe('log levels', () => {
+        async function assertLoggedAtLevel(sl, method, level) {
+            const log = sl.getLogger([method]);
+            const msg = `should log on level: ${level}`;
+            log[method](msg);
+            a.satisfies(sl.reporter.logs, [{ id: method, level: sl.toLogLevel(method), args: [msg] }]);
+        }
+        async function assertNotLoggedAtLevel(sl, method, level) {
+            const log = sl.getLogger([method]);
+            log[method](`should not log on level: ${level}`);
+            expect(sl.reporter.logs.length).toBe(0);
+        }
+        async function assertLoggedAtLocalLevel(sl, method, localLevel) {
+            const log = sl.getLogger([method, { level: localLevel }]);
+            const msg = `should log on level: ${localLevel}`;
+            log[method](msg);
+            a.satisfies(sl.reporter.logs, [{ id: log.id, level: sl.toLogLevel(method), args: [msg] }]);
+        }
+        async function assertNotLoggedAtLocalLevel(sl, method, localLevel) {
+            const log = sl.getLogger([method, { level: localLevel }]);
+            log[method](`should not log on level: ${localLevel}`);
+            expect(sl.reporter.logs.length).toBe(0);
+        }
+        async function assertLoggedAtCallLevel(sl, method, callLevel) {
+            const log = sl.getLogger([method]);
+            let actual = false;
+            log.on(callLevel, () => actual = true);
+            expect(actual).toBe(true);
+        }
+        async function assertNotLoggedAtCallLevel(sl, method, callLevel, actualLevel) {
+            const log = sl.getLogger([method]);
+            log.on(callLevel, () => { throw new Error(`should not log at level ${actualLevel}`); });
+        }
+        async function assertLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel) {
+            const log = sl.getLogger([method, { level: localLevel }]);
+            let actual = false;
+            log.on(callLevel, () => actual = true);
+            expect(actual).toBe(true);
+        }
+        async function assertNotLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel) {
+            const log = sl.getLogger([method, { level: localLevel }]);
+            log.on(callLevel, () => { throw new Error(`should not log at level ${localLevel}`); });
+        }
+        const shouldLog = wrapTest((test) => (method, level) => {
+            const sl = createStandardLogForTest(level);
+            const name = sl.toLogLevelName(level);
+            test(`${method}() should log on level: ${name} (${level})`, () => {
+                return assertLoggedAtLevel(sl, method, level);
+            });
+        });
+        const shouldNotLog = wrapTest((test) => (method, level) => {
+            const sl = createStandardLogForTest(level);
+            const name = sl.toLogLevelName(level);
+            test(`${method}() should not log on level: ${name} (${level})`, () => {
+                return assertNotLoggedAtLevel(sl, method, level);
+            });
+        });
+        const shouldLogWithLocalLevelOverride = wrapTest((test) => (method, localLevel) => {
+            const localName = toLogLevelName(localLevel);
+            [logLevels.none, logLevels.error, logLevels.warn, logLevels.info, logLevels.debug].forEach(globalLevel => {
+                const globalName = toLogLevelName(globalLevel) || 'none';
+                test(`${method}() should log on local level: ${localName} (${localLevel}) while global level: ${globalName} (${globalLevel})`, () => {
+                    const sl = createStandardLogForTest(globalLevel);
+                    return assertLoggedAtLocalLevel(sl, method, localLevel);
+                });
+            });
+        });
+        const shouldNotLogWithLocalLevelOverride = wrapTest((test) => (method, localLevel) => {
+            const localName = toLogLevelName(localLevel);
+            [logLevels.none, logLevels.error, logLevels.warn, logLevels.info, logLevels.debug].forEach(globalLevel => {
+                const globalName = toLogLevelName(globalLevel) || 'none';
+                test(`${method}() should not log on local level: ${localName} (${localLevel}) while global level: ${globalName} (${globalLevel})`, () => {
+                    const sl = createStandardLogForTest(globalLevel);
+                    return assertNotLoggedAtLocalLevel(sl, method, localLevel);
+                });
+            });
+        });
+        const shouldCallLogFunction = wrapTest((test) => (callLevel, actualLevel) => {
+            const method = toLogLevelName(callLevel);
+            const name = toLogLevelName(actualLevel);
+            test(`${method}() should call log function on level: ${name} (${actualLevel})`, () => {
+                const sl = createStandardLogForTest(actualLevel);
+                return assertLoggedAtCallLevel(sl, method, callLevel);
+            });
+        });
+        const shouldNotCallLogFunction = wrapTest((test) => (callLevel, actualLevel) => {
+            const method = toLogLevelName(callLevel);
+            const name = toLogLevelName(actualLevel);
+            test(`${method}() should not call log function on level: ${name} (${actualLevel})`, () => {
+                const sl = createStandardLogForTest(actualLevel);
+                return assertNotLoggedAtCallLevel(sl, method, callLevel, actualLevel);
+            });
+        });
+        const shouldCallLogFunctionWithLocalLevelOverride = wrapTest((test) => (callLevel, localLevel) => {
+            const method = toLogLevelName(callLevel);
+            const localName = toLogLevelName(localLevel);
+            [logLevels.none, logLevels.error, logLevels.warn, logLevels.info, logLevels.debug].forEach(globalLevel => {
+                const globalName = toLogLevelName(globalLevel) || 'none';
+                test(`${method}() should log on local level: ${localName} (${localLevel}) while global level: ${globalName} (${globalLevel})`, () => {
+                    const sl = createStandardLogForTest(globalLevel);
+                    return assertLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel);
+                });
+            });
+        });
+        const shouldNotCallLogFunctionWithLocalLevelOverride = wrapTest((test) => (callLevel, localLevel) => {
+            const method = toLogLevelName(callLevel);
+            const localName = toLogLevelName(localLevel);
+            [logLevels.none, logLevels.error, logLevels.warn, logLevels.info, logLevels.debug].forEach(globalLevel => {
+                const globalName = toLogLevelName(globalLevel) || 'none';
+                test(`${method}() should not log on local level: ${localName} (${localLevel}) while global level: ${globalName} (${globalLevel})`, () => {
+                    const sl = createStandardLogForTest(globalLevel);
+                    return assertNotLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel);
+                });
+            });
+        });
+        shouldNotLog('error', logLevels.none);
+        shouldLog('error', logLevels.error);
+        shouldLog('error', logLevels.warn);
+        shouldLog('error', logLevels.info);
+        shouldLog('error', logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('error', logLevels.none);
+        shouldLogWithLocalLevelOverride('error', logLevels.error);
+        shouldLogWithLocalLevelOverride('error', logLevels.warn);
+        shouldLogWithLocalLevelOverride('error', logLevels.info);
+        shouldLogWithLocalLevelOverride('error', logLevels.debug);
+        shouldNotLog('warn', logLevels.none);
+        shouldNotLog('warn', logLevels.error);
+        shouldLog('warn', logLevels.warn);
+        shouldLog('warn', logLevels.info);
+        shouldLog('warn', logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('warn', logLevels.none);
+        shouldNotLogWithLocalLevelOverride('warn', logLevels.error);
+        shouldLogWithLocalLevelOverride('warn', logLevels.warn);
+        shouldLogWithLocalLevelOverride('warn', logLevels.info);
+        shouldLogWithLocalLevelOverride('warn', logLevels.debug);
+        shouldNotLog('info', logLevels.none);
+        shouldNotLog('info', logLevels.error);
+        shouldNotLog('info', logLevels.warn);
+        shouldLog('info', logLevels.info);
+        shouldLog('info', logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('info', logLevels.none);
+        shouldNotLogWithLocalLevelOverride('info', logLevels.error);
+        shouldNotLogWithLocalLevelOverride('info', logLevels.warn);
+        shouldLogWithLocalLevelOverride('info', logLevels.info);
+        shouldLogWithLocalLevelOverride('info', logLevels.debug);
+        shouldNotLog('debug', logLevels.none);
+        shouldNotLog('debug', logLevels.error);
+        shouldNotLog('debug', logLevels.warn);
+        shouldNotLog('debug', logLevels.info);
+        shouldLog('debug', logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels.none);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels.error);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels.warn);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels.info);
+        shouldLogWithLocalLevelOverride('debug', logLevels.debug);
+        shouldNotCallLogFunction(logLevels.error, logLevels.none);
+        shouldCallLogFunction(logLevels.error, logLevels.error);
+        shouldCallLogFunction(logLevels.error, logLevels.warn);
+        shouldCallLogFunction(logLevels.error, logLevels.info);
+        shouldCallLogFunction(logLevels.error, logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.error, logLevels.none);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.error, logLevels.error);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.error, logLevels.warn);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.error, logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.error, logLevels.debug);
+        shouldNotCallLogFunction(logLevels.warn, logLevels.none);
+        shouldNotCallLogFunction(logLevels.warn, logLevels.error);
+        shouldCallLogFunction(logLevels.warn, logLevels.warn);
+        shouldCallLogFunction(logLevels.warn, logLevels.info);
+        shouldCallLogFunction(logLevels.warn, logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.warn, logLevels.none);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.warn, logLevels.error);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.warn, logLevels.warn);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.warn, logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.warn, logLevels.debug);
+        shouldNotCallLogFunction(logLevels.info, logLevels.none);
+        shouldNotCallLogFunction(logLevels.info, logLevels.error);
+        shouldNotCallLogFunction(logLevels.info, logLevels.warn);
+        shouldCallLogFunction(logLevels.info, logLevels.info);
+        shouldCallLogFunction(logLevels.info, logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.info, logLevels.none);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.info, logLevels.error);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.info, logLevels.warn);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.info, logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.info, logLevels.debug);
+        shouldNotCallLogFunction(logLevels.debug, logLevels.none);
+        shouldNotCallLogFunction(logLevels.debug, logLevels.error);
+        shouldNotCallLogFunction(logLevels.debug, logLevels.warn);
+        shouldNotCallLogFunction(logLevels.debug, logLevels.info);
+        shouldCallLogFunction(logLevels.debug, logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.debug, logLevels.none);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.debug, logLevels.error);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.debug, logLevels.warn);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels.debug, logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels.debug, logLevels.debug);
+    });
+    it('writes entry directly', () => {
+        const sl = createStandardLogForTest();
+        const log = sl.getLogger(['write-entry']);
+        const entry = { id: 'write-entry', level: logLevels.info, args: ['abc'], timestamp: new Date() };
+        log.write(entry);
+        a.satisfies(sl.reporter.logs, [entry]);
+    });
+    test.each(['on', 'count', 'error', 'warn', 'info', 'debug'])('method %s is readonly', name => {
+        const sl = createStandardLog();
+        const log = sl.getLogger([`${name} is readonly`]);
+        a.throws(() => log[name] = true);
+    });
+    describe('on()', () => {
+        it('log using log argument', () => {
+            const sl = createStandardLogForTest();
+            const logger = sl.getLogger(['log on fn']);
+            logger.on('error', log => { log('value'); });
+            a.satisfies(sl.reporter.logs, [
+                { id: 'log on fn', level: logLevels.error, args: ['value'] }
+            ]);
+        });
+        it('can take log level name in first argument', () => {
+            const sl = createStandardLogForTest();
+            const log = sl.getLogger(['string-on']);
+            log.on('debug', () => { return; });
+        });
+    });
+    describe('count()', () => {
+        test('will increment the counter', async () => {
+            const sl = createStandardLogForTest();
+            const logger = sl.getLogger(['inc counter']);
+            logger.count();
+            logger.count();
+            a.satisfies(sl.reporter.logs, [
+                { id: 'inc counter', level: logLevels.debug, args: [1] },
+                { id: 'inc counter', level: logLevels.debug, args: [2] }
+            ]);
+        });
+        test('append args after the counter', async () => {
+            const sl = createStandardLogForTest(logLevels.debug);
+            const id = 'inc with args';
+            const logger = sl.getLogger([id]);
+            logger.count('msg1', 'msg2');
+            a.satisfies(sl.reporter.logs, [
+                { id, level: logLevels.debug, args: [1, 'msg1', 'msg2'] }
+            ]);
+        });
+        test('not log if log level is less than debug', async () => {
+            const sl = createStandardLogForTest(logLevels.debug - 1);
+            const id = 'inc with args';
+            const logger = sl.getLogger([id]);
+            logger.count('msg1', 'msg2');
+            expect(sl.reporter.logs.length).toBe(0);
+        });
+    });
+    test('logger with custom level', async () => {
+        const mem = createMemoryLogReporter();
+        const sl = createStandardLog({ customLevels: { 'cust_lvl': 100 }, reporters: [mem] });
+        const logger = sl.getLogger(['cust']);
+        logger.cust_lvl('a', 'b');
+        a.satisfies(mem.logs, [{ id: 'cust', level: 100, args: ['a', 'b'] }]);
+    });
+    describe('getLogger([,{ writeTo }])', () => {
+        function testWriteTo(loggerParams, handler) {
+            const memReporter = createMemoryLogReporter();
+            const specialReporter = createMemoryLogReporter({ id: 'special' });
+            const sl = createStandardLog({ reporters: [memReporter, specialReporter] });
+            const log = sl.getLogger(loggerParams);
+            handler(log, memReporter.logs, specialReporter.logs, sl);
+        }
+        it('can specify which reporter to use by name', () => {
+            testWriteTo(['writeTo-string', { writeTo: 'special' }], (log, memLogs, specialLogs) => {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify which reporter to use by regex', () => {
+            testWriteTo(['writeTo-regex', { writeTo: /^spec/ }], (log, memLogs, specialLogs) => {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify which reporter to use by RegExp', () => {
+            testWriteTo(['writeTo-RegExp', { writeTo: new RegExp('^spec') }], (log, memLogs, specialLogs) => {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify which reporter to use by function', () => {
+            testWriteTo(['writeTo-fn', { writeTo: id => id === 'special' }], (log, memLogs, specialLogs) => {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify custom reporter', () => {
+            const reporter = createMemoryLogReporter({ id: 'custom mem' });
+            testWriteTo(['writeTo-reporter', { writeTo: reporter }], (log, memLogs, specialLogs) => {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(0);
+                expect(reporter.logs.length).toEqual(1);
+            });
+        });
+        test('the custom console reporter cannot pick up logs from other loggers', () => {
+            // if not, it would be a security issue as the new reporter
+            // can capture the logs from other logger and send it elsewhere
+            const reporter = createMemoryLogReporter({ id: 'custom mem' });
+            testWriteTo(['writeTo-reporter-no-override', { writeTo: reporter }], (_, memLogs, specialLogs, sl) => {
+                const log = sl.getLogger(['writeTo-reporter-no-override-2']);
+                log.error('error message');
+                expect(reporter.logs.length).toEqual(0);
+            });
+        });
+    });
+});
+describe('suppressLogs()', () => {
+    test('suppress log', () => {
+        const sl = createStandardLogForTest();
+        const log = sl.getLogger(['l']);
+        suppressLogs(() => {
+            log.alert('should not see me');
+        }, log);
+        expect(sl.reporter.getLogMessageWithLevel()).toBe('');
+    });
+    test('suppress multiple logs', () => {
+        const sl = createStandardLogForTest();
+        const log1 = sl.getLogger(['l1']);
+        const log2 = sl.getLogger(['l2']);
+        suppressLogs(() => {
+            log1.alert('should not see me');
+            log2.alert('should not see me too');
+        }, log1, log2);
+        expect(sl.reporter.getLogMessageWithLevel()).toBe('');
+    });
+    test('return block result', () => {
+        const sl = createStandardLogForTest();
+        const log1 = sl.getLogger(['l']);
+        const log2 = sl.getLogger(['l2']);
+        const a = suppressLogs(() => 1, log1, log2);
+        expect(a).toBe(1);
+    });
+});
+//# sourceMappingURL=standardLog.spec.js.map