@webpieces/core-util 0.3.263 → 0.3.264

package/src/http/recorder/TestCaseRecorder.d.ts

@@ -0,0 +1,36 @@
+import { ContextKey } from '../../ContextKey';
+import { RecordedEndpoint } from './RecordedEndpoint';
+/**
+ * TestCaseRecorder - Records every api call made while serving one inbound
+ * request (port of Java TestCaseRecorder).
+ *
+ * The recorder travels in the request's magic context under
+ * RecorderKeys.RECORDER (Java: Context RECORDER_KEY). Downstream hooks -
+ * the HTTP client proxy and recordable() in-process wrappers - check the
+ * context and record into it when present.
+ *
+ * The contract lives in http-api (browser-safe, no Node imports) so the
+ * http-client can reference it; the implementation (TestCaseRecorderImpl)
+ * lives in http-server.
+ */
+export interface TestCaseRecorder {
+    /**
+     * Record one downstream api call (outbound HTTP or in-process recordable).
+     */
+    addEndpointInfo(info: RecordedEndpoint): void;
+    /**
+     * The most recently recorded downstream call (for hooks that fill in the
+     * response after the call completes).
+     */
+    getLastEndpointInfo(): RecordedEndpoint | undefined;
+}
+/**
+ * Context keys for the recording subsystem.
+ */
+export declare class RecorderKeys {
+    /**
+     * Key under which the active TestCaseRecorder travels in the request
+     * context. Absent = not recording.
+     */
+    static readonly RECORDER: ContextKey;
+}

package/src/http/recorder/TestCaseRecorder.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecorderKeys = void 0;
+const ContextKey_1 = require("../../ContextKey");
+/**
+ * Context keys for the recording subsystem.
+ */
+class RecorderKeys {
+    /**
+     * Key under which the active TestCaseRecorder travels in the request
+     * context. Absent = not recording.
+     */
+    static RECORDER = new ContextKey_1.ContextKey('webpieces-recorder');
+}
+exports.RecorderKeys = RecorderKeys;
+//# sourceMappingURL=TestCaseRecorder.js.map

package/src/http/recorder/TestCaseRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestCaseRecorder.js","sourceRoot":"","sources":["../../../../../../../packages/core/core-util/src/http/recorder/TestCaseRecorder.ts"],"names":[],"mappings":";;;AAAA,iDAA8C;AA6B9C;;GAEG;AACH,MAAa,YAAY;IACrB;;;OAGG;IACH,MAAM,CAAU,QAAQ,GAAG,IAAI,uBAAU,CAAC,oBAAoB,CAAC,CAAC;;AALpE,oCAMC","sourcesContent":["import { ContextKey } from '../../ContextKey';\nimport { RecordedEndpoint } from './RecordedEndpoint';\n\n/**\n * TestCaseRecorder - Records every api call made while serving one inbound\n * request (port of Java TestCaseRecorder).\n *\n * The recorder travels in the request's magic context under\n * RecorderKeys.RECORDER (Java: Context RECORDER_KEY). Downstream hooks -\n * the HTTP client proxy and recordable() in-process wrappers - check the\n * context and record into it when present.\n *\n * The contract lives in http-api (browser-safe, no Node imports) so the\n * http-client can reference it; the implementation (TestCaseRecorderImpl)\n * lives in http-server.\n */\nexport interface TestCaseRecorder {\n    /**\n     * Record one downstream api call (outbound HTTP or in-process recordable).\n     */\n    addEndpointInfo(info: RecordedEndpoint): void;\n\n    /**\n     * The most recently recorded downstream call (for hooks that fill in the\n     * response after the call completes).\n     */\n    getLastEndpointInfo(): RecordedEndpoint | undefined;\n}\n\n/**\n * Context keys for the recording subsystem.\n */\nexport class RecorderKeys {\n    /**\n     * Key under which the active TestCaseRecorder travels in the request\n     * context. Absent = not recording.\n     */\n    static readonly RECORDER = new ContextKey('webpieces-recorder');\n}\n"]}

package/src/http/validators.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Type-level validator to ensure a class implements all methods from an interface.
+ *
+ * This validator provides compile-time verification that an implementation
+ * (e.g., controller, client, mock) fully implements an API interface.
+ *
+ * Usage in server-side controllers:
+ * ```typescript
+ * export class SaveController extends SaveApi implements SaveApi {
+ *   // Compile-time check: ensures all SaveApi methods are implemented
+ *   private readonly __validator!: ValidateImplementation<SaveController, SaveApi>;
+ *
+ *   save(request: SaveRequest): Promise<SaveResponse> {
+ *     // implementation
+ *   }
+ * }
+ * ```
+ *
+ * Usage in client-side implementations:
+ * ```typescript
+ * export class MockSaveClient implements SaveApi {
+ *   private readonly __validator!: ValidateImplementation<MockSaveClient, SaveApi>;
+ *
+ *   save(request: SaveRequest): Promise<SaveResponse> {
+ *     // mock implementation
+ *   }
+ * }
+ * ```
+ *
+ * Benefits:
+ * - Compile error if any interface method is missing
+ * - Compile error if method signatures don't match
+ * - Works with controllers, clients, mocks, stubs, etc.
+ * - Type-safe contract enforcement
+ *
+ * Note: The `!` assertion is safe because this field is never accessed at runtime.
+ * It only exists for compile-time type checking.
+ */
+export type ValidateImplementation<TImpl, TInterface> = {
+    [K in keyof TInterface]: K extends keyof TImpl ? TImpl[K] extends TInterface[K] ? TInterface[K] : never : never;
+};

package/src/http/validators.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=validators.js.map

package/src/http/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../../../../../packages/core/core-util/src/http/validators.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Type-level validator to ensure a class implements all methods from an interface.\n *\n * This validator provides compile-time verification that an implementation\n * (e.g., controller, client, mock) fully implements an API interface.\n *\n * Usage in server-side controllers:\n * ```typescript\n * export class SaveController extends SaveApi implements SaveApi {\n *   // Compile-time check: ensures all SaveApi methods are implemented\n *   private readonly __validator!: ValidateImplementation<SaveController, SaveApi>;\n *\n *   save(request: SaveRequest): Promise<SaveResponse> {\n *     // implementation\n *   }\n * }\n * ```\n *\n * Usage in client-side implementations:\n * ```typescript\n * export class MockSaveClient implements SaveApi {\n *   private readonly __validator!: ValidateImplementation<MockSaveClient, SaveApi>;\n *\n *   save(request: SaveRequest): Promise<SaveResponse> {\n *     // mock implementation\n *   }\n * }\n * ```\n *\n * Benefits:\n * - Compile error if any interface method is missing\n * - Compile error if method signatures don't match\n * - Works with controllers, clients, mocks, stubs, etc.\n * - Type-safe contract enforcement\n *\n * Note: The `!` assertion is safe because this field is never accessed at runtime.\n * It only exists for compile-time type checking.\n */\nexport type ValidateImplementation<TImpl, TInterface> = {\n    [K in keyof TInterface]: K extends keyof TImpl\n        ? TImpl[K] extends TInterface[K]\n            ? TInterface[K]\n            : never\n        : never;\n};\n"]}

package/src/index.d.ts

@@ -9,3 +9,25 @@
 export { toError } from './lib/errorUtils';
 export { Header } from './Header';
 export { ContextKey } from './ContextKey';
+export type { Logger, LogLevel } from './logging/Logger';
+export type { LoggerFactory } from './logging/LoggerFactory';
+export { ConsoleLogger } from './logging/ConsoleLogger';
+export { ConsoleLoggerFactory } from './logging/ConsoleLoggerFactory';
+export { LogManager } from './logging/LogManager';
+export { ApiPath, Endpoint, Authentication, AuthenticationConfig, Public, AuthJwt, AuthOidc, AuthSharedSecret, Rpc, PubSub, Queue, getApiPath, getEndpoints, isApiPath, getAuthMeta, getAuthMode, assertEveryEndpointHasAuthMode, getApiKind, assertApiKind, assertPubSubConventions, getQueueName, validateNoConflictingDecorators, AuthMeta, RouteMetadata, METADATA_KEYS, } from './http/decorators';
+export type { AuthMode, ApiKind } from './http/decorators';
+export { ValidateImplementation } from './http/validators';
+export { ProtocolError, HttpError, HttpNotFoundError, EndpointNotFoundError, HttpBadRequestError, HttpUnauthorizedError, HttpForbiddenError, HttpTimeoutError, HttpBadGatewayError, HttpGatewayTimeoutError, HttpInternalServerError, HttpVendorError, HttpUserError, ENTITY_NOT_FOUND, WRONG_LOGIN_TYPE, WRONG_LOGIN, NOT_APPROVED, EMAIL_NOT_CONFIRMED, WRONG_DOMAIN, WRONG_COMPANY, NO_REG_CODE, } from './http/errors';
+export { InstantDto, DateDto, TimeDto, DateTimeDto, InstantUtil, DateUtil, TimeUtil, DateTimeUtil, } from './http/datetime';
+export { PlatformHeader } from './http/PlatformHeader';
+export { PlatformHeadersExtension } from './http/PlatformHeadersExtension';
+export { HeaderRegistry } from './http/HeaderRegistry';
+export { WebpiecesCoreHeaders } from './http/WebpiecesCoreHeaders';
+export { HeaderMethods } from './http/HeaderMethods';
+export { ContextReader } from './http/ContextReader';
+export { HEADER_TYPES } from './http/HeaderTypes';
+export { LogApiCall } from './http/LogApiCall';
+export { TestCaseRecorder, RecorderKeys } from './http/recorder/TestCaseRecorder';
+export { RecordedEndpoint, RecordedError, RecordedTestCase } from './http/recorder/RecordedEndpoint';
+export { DoNotRecord, getDoNotRecordFields } from './http/recorder/DoNotRecord';
+export { RecordSerializer, SerializedMap, SerializedError } from './http/recorder/RecordSerializer';

package/src/index.js

@@ -8,9 +8,110 @@
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextKey = exports.toError = void 0;
+exports.WRONG_COMPANY = exports.WRONG_DOMAIN = exports.EMAIL_NOT_CONFIRMED = exports.NOT_APPROVED = exports.WRONG_LOGIN = exports.WRONG_LOGIN_TYPE = exports.ENTITY_NOT_FOUND = exports.HttpUserError = exports.HttpVendorError = exports.HttpInternalServerError = exports.HttpGatewayTimeoutError = exports.HttpBadGatewayError = exports.HttpTimeoutError = exports.HttpForbiddenError = exports.HttpUnauthorizedError = exports.HttpBadRequestError = exports.EndpointNotFoundError = exports.HttpNotFoundError = exports.HttpError = exports.ProtocolError = exports.METADATA_KEYS = exports.RouteMetadata = exports.AuthMeta = exports.validateNoConflictingDecorators = exports.getQueueName = exports.assertPubSubConventions = exports.assertApiKind = exports.getApiKind = exports.assertEveryEndpointHasAuthMode = exports.getAuthMode = exports.getAuthMeta = exports.isApiPath = exports.getEndpoints = exports.getApiPath = exports.Queue = exports.PubSub = exports.Rpc = exports.AuthSharedSecret = exports.AuthOidc = exports.AuthJwt = exports.Public = exports.AuthenticationConfig = exports.Authentication = exports.Endpoint = exports.ApiPath = exports.LogManager = exports.ConsoleLoggerFactory = exports.ConsoleLogger = exports.ContextKey = exports.toError = void 0;
+exports.SerializedError = exports.SerializedMap = exports.RecordSerializer = exports.getDoNotRecordFields = exports.DoNotRecord = exports.RecordedTestCase = exports.RecordedError = exports.RecordedEndpoint = exports.RecorderKeys = exports.LogApiCall = exports.HEADER_TYPES = exports.HeaderMethods = exports.WebpiecesCoreHeaders = exports.HeaderRegistry = exports.PlatformHeadersExtension = exports.PlatformHeader = exports.DateTimeUtil = exports.TimeUtil = exports.DateUtil = exports.InstantUtil = exports.NO_REG_CODE = void 0;
 var errorUtils_1 = require("./lib/errorUtils");
 Object.defineProperty(exports, "toError", { enumerable: true, get: function () { return errorUtils_1.toError; } });
 var ContextKey_1 = require("./ContextKey");
 Object.defineProperty(exports, "ContextKey", { enumerable: true, get: function () { return ContextKey_1.ContextKey; } });
+var ConsoleLogger_1 = require("./logging/ConsoleLogger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return ConsoleLogger_1.ConsoleLogger; } });
+var ConsoleLoggerFactory_1 = require("./logging/ConsoleLoggerFactory");
+Object.defineProperty(exports, "ConsoleLoggerFactory", { enumerable: true, get: function () { return ConsoleLoggerFactory_1.ConsoleLoggerFactory; } });
+var LogManager_1 = require("./logging/LogManager");
+Object.defineProperty(exports, "LogManager", { enumerable: true, get: function () { return LogManager_1.LogManager; } });
+// HTTP API contract (merged from former @webpieces/http-api).
+// Shared HTTP API definition consumed by both client and server: REST
+// decorators, the HttpError hierarchy, datetime DTOs, platform-header
+// registry/readers, ValidateImplementation, and the test-case recorder
+// contract. Pure definitions — express-free, browser + Node safe.
+// API definition decorators
+var decorators_1 = require("./http/decorators");
+Object.defineProperty(exports, "ApiPath", { enumerable: true, get: function () { return decorators_1.ApiPath; } });
+Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return decorators_1.Endpoint; } });
+Object.defineProperty(exports, "Authentication", { enumerable: true, get: function () { return decorators_1.Authentication; } });
+Object.defineProperty(exports, "AuthenticationConfig", { enumerable: true, get: function () { return decorators_1.AuthenticationConfig; } });
+// Auth mode decorators (clean service-to-service + user JWT model)
+Object.defineProperty(exports, "Public", { enumerable: true, get: function () { return decorators_1.Public; } });
+Object.defineProperty(exports, "AuthJwt", { enumerable: true, get: function () { return decorators_1.AuthJwt; } });
+Object.defineProperty(exports, "AuthOidc", { enumerable: true, get: function () { return decorators_1.AuthOidc; } });
+Object.defineProperty(exports, "AuthSharedSecret", { enumerable: true, get: function () { return decorators_1.AuthSharedSecret; } });
+// API kind (RPC vs PubSub/Cloud Tasks) + queue naming
+Object.defineProperty(exports, "Rpc", { enumerable: true, get: function () { return decorators_1.Rpc; } });
+Object.defineProperty(exports, "PubSub", { enumerable: true, get: function () { return decorators_1.PubSub; } });
+Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return decorators_1.Queue; } });
+Object.defineProperty(exports, "getApiPath", { enumerable: true, get: function () { return decorators_1.getApiPath; } });
+Object.defineProperty(exports, "getEndpoints", { enumerable: true, get: function () { return decorators_1.getEndpoints; } });
+Object.defineProperty(exports, "isApiPath", { enumerable: true, get: function () { return decorators_1.isApiPath; } });
+Object.defineProperty(exports, "getAuthMeta", { enumerable: true, get: function () { return decorators_1.getAuthMeta; } });
+Object.defineProperty(exports, "getAuthMode", { enumerable: true, get: function () { return decorators_1.getAuthMode; } });
+Object.defineProperty(exports, "assertEveryEndpointHasAuthMode", { enumerable: true, get: function () { return decorators_1.assertEveryEndpointHasAuthMode; } });
+Object.defineProperty(exports, "getApiKind", { enumerable: true, get: function () { return decorators_1.getApiKind; } });
+Object.defineProperty(exports, "assertApiKind", { enumerable: true, get: function () { return decorators_1.assertApiKind; } });
+Object.defineProperty(exports, "assertPubSubConventions", { enumerable: true, get: function () { return decorators_1.assertPubSubConventions; } });
+Object.defineProperty(exports, "getQueueName", { enumerable: true, get: function () { return decorators_1.getQueueName; } });
+Object.defineProperty(exports, "validateNoConflictingDecorators", { enumerable: true, get: function () { return decorators_1.validateNoConflictingDecorators; } });
+Object.defineProperty(exports, "AuthMeta", { enumerable: true, get: function () { return decorators_1.AuthMeta; } });
+Object.defineProperty(exports, "RouteMetadata", { enumerable: true, get: function () { return decorators_1.RouteMetadata; } });
+Object.defineProperty(exports, "METADATA_KEYS", { enumerable: true, get: function () { return decorators_1.METADATA_KEYS; } });
+// HTTP errors
+var errors_1 = require("./http/errors");
+Object.defineProperty(exports, "ProtocolError", { enumerable: true, get: function () { return errors_1.ProtocolError; } });
+Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return errors_1.HttpError; } });
+Object.defineProperty(exports, "HttpNotFoundError", { enumerable: true, get: function () { return errors_1.HttpNotFoundError; } });
+Object.defineProperty(exports, "EndpointNotFoundError", { enumerable: true, get: function () { return errors_1.EndpointNotFoundError; } });
+Object.defineProperty(exports, "HttpBadRequestError", { enumerable: true, get: function () { return errors_1.HttpBadRequestError; } });
+Object.defineProperty(exports, "HttpUnauthorizedError", { enumerable: true, get: function () { return errors_1.HttpUnauthorizedError; } });
+Object.defineProperty(exports, "HttpForbiddenError", { enumerable: true, get: function () { return errors_1.HttpForbiddenError; } });
+Object.defineProperty(exports, "HttpTimeoutError", { enumerable: true, get: function () { return errors_1.HttpTimeoutError; } });
+Object.defineProperty(exports, "HttpBadGatewayError", { enumerable: true, get: function () { return errors_1.HttpBadGatewayError; } });
+Object.defineProperty(exports, "HttpGatewayTimeoutError", { enumerable: true, get: function () { return errors_1.HttpGatewayTimeoutError; } });
+Object.defineProperty(exports, "HttpInternalServerError", { enumerable: true, get: function () { return errors_1.HttpInternalServerError; } });
+Object.defineProperty(exports, "HttpVendorError", { enumerable: true, get: function () { return errors_1.HttpVendorError; } });
+Object.defineProperty(exports, "HttpUserError", { enumerable: true, get: function () { return errors_1.HttpUserError; } });
+// Error subtype constants
+Object.defineProperty(exports, "ENTITY_NOT_FOUND", { enumerable: true, get: function () { return errors_1.ENTITY_NOT_FOUND; } });
+Object.defineProperty(exports, "WRONG_LOGIN_TYPE", { enumerable: true, get: function () { return errors_1.WRONG_LOGIN_TYPE; } });
+Object.defineProperty(exports, "WRONG_LOGIN", { enumerable: true, get: function () { return errors_1.WRONG_LOGIN; } });
+Object.defineProperty(exports, "NOT_APPROVED", { enumerable: true, get: function () { return errors_1.NOT_APPROVED; } });
+Object.defineProperty(exports, "EMAIL_NOT_CONFIRMED", { enumerable: true, get: function () { return errors_1.EMAIL_NOT_CONFIRMED; } });
+Object.defineProperty(exports, "WRONG_DOMAIN", { enumerable: true, get: function () { return errors_1.WRONG_DOMAIN; } });
+Object.defineProperty(exports, "WRONG_COMPANY", { enumerable: true, get: function () { return errors_1.WRONG_COMPANY; } });
+Object.defineProperty(exports, "NO_REG_CODE", { enumerable: true, get: function () { return errors_1.NO_REG_CODE; } });
+// Date/Time DTOs and Utilities (inspired by Java Time / JSR-310)
+var datetime_1 = require("./http/datetime");
+Object.defineProperty(exports, "InstantUtil", { enumerable: true, get: function () { return datetime_1.InstantUtil; } });
+Object.defineProperty(exports, "DateUtil", { enumerable: true, get: function () { return datetime_1.DateUtil; } });
+Object.defineProperty(exports, "TimeUtil", { enumerable: true, get: function () { return datetime_1.TimeUtil; } });
+Object.defineProperty(exports, "DateTimeUtil", { enumerable: true, get: function () { return datetime_1.DateTimeUtil; } });
+// Platform Headers
+var PlatformHeader_1 = require("./http/PlatformHeader");
+Object.defineProperty(exports, "PlatformHeader", { enumerable: true, get: function () { return PlatformHeader_1.PlatformHeader; } });
+var PlatformHeadersExtension_1 = require("./http/PlatformHeadersExtension");
+Object.defineProperty(exports, "PlatformHeadersExtension", { enumerable: true, get: function () { return PlatformHeadersExtension_1.PlatformHeadersExtension; } });
+var HeaderRegistry_1 = require("./http/HeaderRegistry");
+Object.defineProperty(exports, "HeaderRegistry", { enumerable: true, get: function () { return HeaderRegistry_1.HeaderRegistry; } });
+var WebpiecesCoreHeaders_1 = require("./http/WebpiecesCoreHeaders");
+Object.defineProperty(exports, "WebpiecesCoreHeaders", { enumerable: true, get: function () { return WebpiecesCoreHeaders_1.WebpiecesCoreHeaders; } });
+var HeaderMethods_1 = require("./http/HeaderMethods");
+Object.defineProperty(exports, "HeaderMethods", { enumerable: true, get: function () { return HeaderMethods_1.HeaderMethods; } });
+var HeaderTypes_1 = require("./http/HeaderTypes");
+Object.defineProperty(exports, "HEADER_TYPES", { enumerable: true, get: function () { return HeaderTypes_1.HEADER_TYPES; } });
+// API-call logging helper (uses LogManager above)
+var LogApiCall_1 = require("./http/LogApiCall");
+Object.defineProperty(exports, "LogApiCall", { enumerable: true, get: function () { return LogApiCall_1.LogApiCall; } });
+// Test-case recording contract (impl lives in http-server; hooks in http-client)
+var TestCaseRecorder_1 = require("./http/recorder/TestCaseRecorder");
+Object.defineProperty(exports, "RecorderKeys", { enumerable: true, get: function () { return TestCaseRecorder_1.RecorderKeys; } });
+var RecordedEndpoint_1 = require("./http/recorder/RecordedEndpoint");
+Object.defineProperty(exports, "RecordedEndpoint", { enumerable: true, get: function () { return RecordedEndpoint_1.RecordedEndpoint; } });
+Object.defineProperty(exports, "RecordedError", { enumerable: true, get: function () { return RecordedEndpoint_1.RecordedError; } });
+Object.defineProperty(exports, "RecordedTestCase", { enumerable: true, get: function () { return RecordedEndpoint_1.RecordedTestCase; } });
+var DoNotRecord_1 = require("./http/recorder/DoNotRecord");
+Object.defineProperty(exports, "DoNotRecord", { enumerable: true, get: function () { return DoNotRecord_1.DoNotRecord; } });
+Object.defineProperty(exports, "getDoNotRecordFields", { enumerable: true, get: function () { return DoNotRecord_1.getDoNotRecordFields; } });
+var RecordSerializer_1 = require("./http/recorder/RecordSerializer");
+Object.defineProperty(exports, "RecordSerializer", { enumerable: true, get: function () { return RecordSerializer_1.RecordSerializer; } });
+Object.defineProperty(exports, "SerializedMap", { enumerable: true, get: function () { return RecordSerializer_1.SerializedMap; } });
+Object.defineProperty(exports, "SerializedError", { enumerable: true, get: function () { return RecordSerializer_1.SerializedError; } });
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/core/core-util/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,+CAA2C;AAAlC,qGAAA,OAAO,OAAA;AAEhB,2CAA0C;AAAjC,wGAAA,UAAU,OAAA","sourcesContent":["/**\n * @webpieces/core-util\n *\n * Utility functions for WebPieces applications.\n * This package works in both browser and Node.js environments.\n *\n * @packageDocumentation\n */\n\nexport { toError } from './lib/errorUtils';\nexport { Header } from './Header';\nexport { ContextKey } from './ContextKey';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/core/core-util/src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @webpieces/core-util\n *\n * Utility functions for WebPieces applications.\n * This package works in both browser and Node.js environments.\n *\n * @packageDocumentation\n */\n\nexport { toError } from './lib/errorUtils';\nexport { Header } from './Header';\nexport { ContextKey } from './ContextKey';\n\n// Logging (merged from former @webpieces/wp-logging).\n// Pluggable logging interface + a browser-safe console default; apps plug in\n// bunyan/winston/pino/etc. via LogManager.setFactory(...). Browser + Node.\nexport type { Logger, LogLevel } from './logging/Logger';\nexport type { LoggerFactory } from './logging/LoggerFactory';\nexport { ConsoleLogger } from './logging/ConsoleLogger';\nexport { ConsoleLoggerFactory } from './logging/ConsoleLoggerFactory';\nexport { LogManager } from './logging/LogManager';\n\n// HTTP API contract (merged from former @webpieces/http-api).\n// Shared HTTP API definition consumed by both client and server: REST\n// decorators, the HttpError hierarchy, datetime DTOs, platform-header\n// registry/readers, ValidateImplementation, and the test-case recorder\n// contract. Pure definitions — express-free, browser + Node safe.\n\n// API definition decorators\nexport {\n    ApiPath,\n    Endpoint,\n    Authentication,\n    AuthenticationConfig,\n    // Auth mode decorators (clean service-to-service + user JWT model)\n    Public,\n    AuthJwt,\n    AuthOidc,\n    AuthSharedSecret,\n    // API kind (RPC vs PubSub/Cloud Tasks) + queue naming\n    Rpc,\n    PubSub,\n    Queue,\n    getApiPath,\n    getEndpoints,\n    isApiPath,\n    getAuthMeta,\n    getAuthMode,\n    assertEveryEndpointHasAuthMode,\n    getApiKind,\n    assertApiKind,\n    assertPubSubConventions,\n    getQueueName,\n    validateNoConflictingDecorators,\n    AuthMeta,\n    RouteMetadata,\n    METADATA_KEYS,\n} from './http/decorators';\nexport type { AuthMode, ApiKind } from './http/decorators';\n\n// Type validators\nexport { ValidateImplementation } from './http/validators';\n\n// HTTP errors\nexport {\n    ProtocolError,\n    HttpError,\n    HttpNotFoundError,\n    EndpointNotFoundError,\n    HttpBadRequestError,\n    HttpUnauthorizedError,\n    HttpForbiddenError,\n    HttpTimeoutError,\n    HttpBadGatewayError,\n    HttpGatewayTimeoutError,\n    HttpInternalServerError,\n    HttpVendorError,\n    HttpUserError,\n    // Error subtype constants\n    ENTITY_NOT_FOUND,\n    WRONG_LOGIN_TYPE,\n    WRONG_LOGIN,\n    NOT_APPROVED,\n    EMAIL_NOT_CONFIRMED,\n    WRONG_DOMAIN,\n    WRONG_COMPANY,\n    NO_REG_CODE,\n} from './http/errors';\n\n// Date/Time DTOs and Utilities (inspired by Java Time / JSR-310)\nexport {\n    InstantDto,\n    DateDto,\n    TimeDto,\n    DateTimeDto,\n    InstantUtil,\n    DateUtil,\n    TimeUtil,\n    DateTimeUtil,\n} from './http/datetime';\n\n// Platform Headers\nexport { PlatformHeader } from './http/PlatformHeader';\nexport { PlatformHeadersExtension } from './http/PlatformHeadersExtension';\nexport { HeaderRegistry } from './http/HeaderRegistry';\nexport { WebpiecesCoreHeaders } from './http/WebpiecesCoreHeaders';\nexport { HeaderMethods } from './http/HeaderMethods';\nexport { ContextReader } from './http/ContextReader';\nexport { HEADER_TYPES } from './http/HeaderTypes';\n\n// API-call logging helper (uses LogManager above)\nexport { LogApiCall } from './http/LogApiCall';\n\n// Test-case recording contract (impl lives in http-server; hooks in http-client)\nexport { TestCaseRecorder, RecorderKeys } from './http/recorder/TestCaseRecorder';\nexport { RecordedEndpoint, RecordedError, RecordedTestCase } from './http/recorder/RecordedEndpoint';\nexport { DoNotRecord, getDoNotRecordFields } from './http/recorder/DoNotRecord';\nexport { RecordSerializer, SerializedMap, SerializedError } from './http/recorder/RecordSerializer';\n"]}

package/src/logging/ConsoleLogger.d.ts

@@ -0,0 +1,25 @@
+import { Logger, LogArg } from './Logger';
+/**
+ * ConsoleLogger - the default, browser-safe {@link Logger} implementation.
+ *
+ * Backed purely by `console.*` (no Node imports), so it works unchanged in the
+ * browser (Angular/React) and in Node. Each line is prefixed with the logger
+ * name so multi-source logs stay greppable; callers that pass their own tag
+ * (e.g. `[API-SVR-req] ...`) keep it inside the message.
+ *
+ * Level → console method mapping:
+ * - trace/debug → console.debug
+ * - info        → console.log   (stdout, matching conventional server logging)
+ * - warn        → console.warn
+ * - error       → console.error
+ */
+export declare class ConsoleLogger implements Logger {
+    private readonly name;
+    constructor(name: string);
+    private prefix;
+    trace(message: string, ...args: LogArg[]): void;
+    debug(message: string, ...args: LogArg[]): void;
+    info(message: string, ...args: LogArg[]): void;
+    warn(message: string, ...args: LogArg[]): void;
+    error(message: string, ...args: LogArg[]): void;
+}

package/src/logging/ConsoleLogger.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+/**
+ * ConsoleLogger - the default, browser-safe {@link Logger} implementation.
+ *
+ * Backed purely by `console.*` (no Node imports), so it works unchanged in the
+ * browser (Angular/React) and in Node. Each line is prefixed with the logger
+ * name so multi-source logs stay greppable; callers that pass their own tag
+ * (e.g. `[API-SVR-req] ...`) keep it inside the message.
+ *
+ * Level → console method mapping:
+ * - trace/debug → console.debug
+ * - info        → console.log   (stdout, matching conventional server logging)
+ * - warn        → console.warn
+ * - error       → console.error
+ */
+class ConsoleLogger {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    prefix() {
+        return `[${this.name}]`;
+    }
+    trace(message, ...args) {
+        console.debug(`${this.prefix()} ${message}`, ...args);
+    }
+    debug(message, ...args) {
+        console.debug(`${this.prefix()} ${message}`, ...args);
+    }
+    info(message, ...args) {
+        console.log(`${this.prefix()} ${message}`, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(`${this.prefix()} ${message}`, ...args);
+    }
+    error(message, ...args) {
+        console.error(`${this.prefix()} ${message}`, ...args);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+//# sourceMappingURL=ConsoleLogger.js.map

package/src/logging/ConsoleLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleLogger.js","sourceRoot":"","sources":["../../../../../../packages/core/core-util/src/logging/ConsoleLogger.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;GAaG;AACH,MAAa,aAAa;IACL,IAAI,CAAS;IAE9B,YAAY,IAAY;QACpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAEO,MAAM;QACV,OAAO,IAAI,IAAI,CAAC,IAAI,GAAG,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,GAAG,IAAc;QACpC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,GAAG,IAAc;QACpC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,GAAG,IAAc;QACnC,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;IACxD,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,GAAG,IAAc;QACnC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,GAAG,IAAc;QACpC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;IAC1D,CAAC;CACJ;AA9BD,sCA8BC","sourcesContent":["import { Logger, LogArg } from './Logger';\n\n/**\n * ConsoleLogger - the default, browser-safe {@link Logger} implementation.\n *\n * Backed purely by `console.*` (no Node imports), so it works unchanged in the\n * browser (Angular/React) and in Node. Each line is prefixed with the logger\n * name so multi-source logs stay greppable; callers that pass their own tag\n * (e.g. `[API-SVR-req] ...`) keep it inside the message.\n *\n * Level → console method mapping:\n * - trace/debug → console.debug\n * - info        → console.log   (stdout, matching conventional server logging)\n * - warn        → console.warn\n * - error       → console.error\n */\nexport class ConsoleLogger implements Logger {\n    private readonly name: string;\n\n    constructor(name: string) {\n        this.name = name;\n    }\n\n    private prefix(): string {\n        return `[${this.name}]`;\n    }\n\n    trace(message: string, ...args: LogArg[]): void {\n        console.debug(`${this.prefix()} ${message}`, ...args);\n    }\n\n    debug(message: string, ...args: LogArg[]): void {\n        console.debug(`${this.prefix()} ${message}`, ...args);\n    }\n\n    info(message: string, ...args: LogArg[]): void {\n        console.log(`${this.prefix()} ${message}`, ...args);\n    }\n\n    warn(message: string, ...args: LogArg[]): void {\n        console.warn(`${this.prefix()} ${message}`, ...args);\n    }\n\n    error(message: string, ...args: LogArg[]): void {\n        console.error(`${this.prefix()} ${message}`, ...args);\n    }\n}\n"]}

package/src/logging/ConsoleLoggerFactory.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from './Logger';
+import { LoggerFactory } from './LoggerFactory';
+/**
+ * ConsoleLoggerFactory - the default {@link LoggerFactory}, browser-safe.
+ *
+ * Produces (and caches per name) {@link ConsoleLogger}s. This is what
+ * {@link LogManager} uses until an app installs a different backend
+ * (bunyan/winston/pino/...) via {@link LogManager.setFactory}.
+ */
+export declare class ConsoleLoggerFactory implements LoggerFactory {
+    private readonly loggers;
+    getLogger(name: string): Logger;
+}

package/src/logging/ConsoleLoggerFactory.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLoggerFactory = void 0;
+const ConsoleLogger_1 = require("./ConsoleLogger");
+/**
+ * ConsoleLoggerFactory - the default {@link LoggerFactory}, browser-safe.
+ *
+ * Produces (and caches per name) {@link ConsoleLogger}s. This is what
+ * {@link LogManager} uses until an app installs a different backend
+ * (bunyan/winston/pino/...) via {@link LogManager.setFactory}.
+ */
+class ConsoleLoggerFactory {
+    loggers = new Map();
+    getLogger(name) {
+        let logger = this.loggers.get(name);
+        if (!logger) {
+            logger = new ConsoleLogger_1.ConsoleLogger(name);
+            this.loggers.set(name, logger);
+        }
+        return logger;
+    }
+}
+exports.ConsoleLoggerFactory = ConsoleLoggerFactory;
+//# sourceMappingURL=ConsoleLoggerFactory.js.map

package/src/logging/ConsoleLoggerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleLoggerFactory.js","sourceRoot":"","sources":["../../../../../../packages/core/core-util/src/logging/ConsoleLoggerFactory.ts"],"names":[],"mappings":";;;AAEA,mDAAgD;AAEhD;;;;;;GAMG;AACH,MAAa,oBAAoB;IACZ,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAErD,SAAS,CAAC,IAAY;QAClB,IAAI,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,GAAG,IAAI,6BAAa,CAAC,IAAI,CAAC,CAAC;YACjC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AAXD,oDAWC","sourcesContent":["import { Logger } from './Logger';\nimport { LoggerFactory } from './LoggerFactory';\nimport { ConsoleLogger } from './ConsoleLogger';\n\n/**\n * ConsoleLoggerFactory - the default {@link LoggerFactory}, browser-safe.\n *\n * Produces (and caches per name) {@link ConsoleLogger}s. This is what\n * {@link LogManager} uses until an app installs a different backend\n * (bunyan/winston/pino/...) via {@link LogManager.setFactory}.\n */\nexport class ConsoleLoggerFactory implements LoggerFactory {\n    private readonly loggers = new Map<string, Logger>();\n\n    getLogger(name: string): Logger {\n        let logger = this.loggers.get(name);\n        if (!logger) {\n            logger = new ConsoleLogger(name);\n            this.loggers.set(name, logger);\n        }\n        return logger;\n    }\n}\n"]}

package/src/logging/LogManager.d.ts

@@ -0,0 +1,36 @@
+import { Logger } from './Logger';
+import { LoggerFactory } from './LoggerFactory';
+/**
+ * LogManager - the global, slf4j-style entry point for logging.
+ *
+ * Every call site in the codebase does:
+ *
+ * ```ts
+ * const log = LogManager.getLogger('MyClass');
+ * log.info('hello', { some: 'context' });
+ * ```
+ *
+ * and never knows which backend is behind it. Apps choose their backend ONCE at
+ * startup by installing a {@link LoggerFactory}:
+ *
+ * ```ts
+ * LogManager.setFactory(new BunyanLoggerFactory(...)); // node-only app
+ * ```
+ *
+ * Until a factory is installed, logging goes to the browser-safe
+ * {@link ConsoleLoggerFactory}, so libraries can log at import time without any
+ * app wiring. This is a data-less coordination holder (all static), which is why
+ * it is a class with static members rather than an instance.
+ */
+export declare class LogManager {
+    private static factory;
+    /**
+     * Install the process-wide logging backend. Call once at app startup, before
+     * other modules fetch their loggers, so early loggers use the chosen backend.
+     */
+    static setFactory(factory: LoggerFactory): void;
+    /** Get a named logger from the currently installed factory. */
+    static getLogger(name: string): Logger;
+    /** The currently installed factory (mainly for tests / diagnostics). */
+    static getFactory(): LoggerFactory;
+}

package/src/logging/LogManager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogManager = void 0;
+const ConsoleLoggerFactory_1 = require("./ConsoleLoggerFactory");
+/**
+ * LogManager - the global, slf4j-style entry point for logging.
+ *
+ * Every call site in the codebase does:
+ *
+ * ```ts
+ * const log = LogManager.getLogger('MyClass');
+ * log.info('hello', { some: 'context' });
+ * ```
+ *
+ * and never knows which backend is behind it. Apps choose their backend ONCE at
+ * startup by installing a {@link LoggerFactory}:
+ *
+ * ```ts
+ * LogManager.setFactory(new BunyanLoggerFactory(...)); // node-only app
+ * ```
+ *
+ * Until a factory is installed, logging goes to the browser-safe
+ * {@link ConsoleLoggerFactory}, so libraries can log at import time without any
+ * app wiring. This is a data-less coordination holder (all static), which is why
+ * it is a class with static members rather than an instance.
+ */
+class LogManager {
+    static factory = new ConsoleLoggerFactory_1.ConsoleLoggerFactory();
+    /**
+     * Install the process-wide logging backend. Call once at app startup, before
+     * other modules fetch their loggers, so early loggers use the chosen backend.
+     */
+    static setFactory(factory) {
+        LogManager.factory = factory;
+    }
+    /** Get a named logger from the currently installed factory. */
+    static getLogger(name) {
+        return LogManager.factory.getLogger(name);
+    }
+    /** The currently installed factory (mainly for tests / diagnostics). */
+    static getFactory() {
+        return LogManager.factory;
+    }
+}
+exports.LogManager = LogManager;
+//# sourceMappingURL=LogManager.js.map

package/src/logging/LogManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogManager.js","sourceRoot":"","sources":["../../../../../../packages/core/core-util/src/logging/LogManager.ts"],"names":[],"mappings":";;;AAEA,iEAA8D;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,UAAU;IACX,MAAM,CAAC,OAAO,GAAkB,IAAI,2CAAoB,EAAE,CAAC;IAEnE;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,OAAsB;QACpC,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC;IACjC,CAAC;IAED,+DAA+D;IAC/D,MAAM,CAAC,SAAS,CAAC,IAAY;QACzB,OAAO,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAED,wEAAwE;IACxE,MAAM,CAAC,UAAU;QACb,OAAO,UAAU,CAAC,OAAO,CAAC;IAC9B,CAAC;;AAnBL,gCAoBC","sourcesContent":["import { Logger } from './Logger';\nimport { LoggerFactory } from './LoggerFactory';\nimport { ConsoleLoggerFactory } from './ConsoleLoggerFactory';\n\n/**\n * LogManager - the global, slf4j-style entry point for logging.\n *\n * Every call site in the codebase does:\n *\n * ```ts\n * const log = LogManager.getLogger('MyClass');\n * log.info('hello', { some: 'context' });\n * ```\n *\n * and never knows which backend is behind it. Apps choose their backend ONCE at\n * startup by installing a {@link LoggerFactory}:\n *\n * ```ts\n * LogManager.setFactory(new BunyanLoggerFactory(...)); // node-only app\n * ```\n *\n * Until a factory is installed, logging goes to the browser-safe\n * {@link ConsoleLoggerFactory}, so libraries can log at import time without any\n * app wiring. This is a data-less coordination holder (all static), which is why\n * it is a class with static members rather than an instance.\n */\nexport class LogManager {\n    private static factory: LoggerFactory = new ConsoleLoggerFactory();\n\n    /**\n     * Install the process-wide logging backend. Call once at app startup, before\n     * other modules fetch their loggers, so early loggers use the chosen backend.\n     */\n    static setFactory(factory: LoggerFactory): void {\n        LogManager.factory = factory;\n    }\n\n    /** Get a named logger from the currently installed factory. */\n    static getLogger(name: string): Logger {\n        return LogManager.factory.getLogger(name);\n    }\n\n    /** The currently installed factory (mainly for tests / diagnostics). */\n    static getFactory(): LoggerFactory {\n        return LogManager.factory;\n    }\n}\n"]}

package/src/logging/Logger.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Log severity levels, ordered lowest → highest.
+ *
+ * Mirrors the common slf4j/bunyan/winston vocabulary so any of those backends
+ * can be plugged in behind the {@link Logger} interface.
+ */
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+/**
+ * A single structured log argument. A logger legitimately accepts arbitrary
+ * values (objects, errors, primitives) and lets the backend decide how to
+ * render them — mirroring `console.*`/bunyan/winston signatures.
+ */
+export type LogArg = unknown;
+/**
+ * Logger - the pluggable logging contract for WebPieces.
+ *
+ * This is a BUSINESS-LOGIC interface (methods with behavior), so per the
+ * webpieces guidelines it is an `interface`, not a class. Different projects
+ * plug in different backends (bunyan, winston, pino, browser console, a
+ * file writer, ...) by supplying an implementation via a {@link LoggerFactory}.
+ *
+ * Implementations MUST stay browser-safe if they are to be used from Angular /
+ * React. Node-only backends (bunyan, file writers, ...) are wired in by
+ * `framework:express` apps at startup, never in browser-safe libraries.
+ *
+ * Each method takes a message plus optional structured args (objects, errors,
+ * numbers) that the backend decides how to render — matching `console.*` and
+ * bunyan/winston signatures.
+ */
+export interface Logger {
+    trace(message: string, ...args: LogArg[]): void;
+    debug(message: string, ...args: LogArg[]): void;
+    info(message: string, ...args: LogArg[]): void;
+    warn(message: string, ...args: LogArg[]): void;
+    error(message: string, ...args: LogArg[]): void;
+}

package/src/logging/Logger.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Logger.js.map

package/src/logging/Logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.js","sourceRoot":"","sources":["../../../../../../packages/core/core-util/src/logging/Logger.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Log severity levels, ordered lowest → highest.\n *\n * Mirrors the common slf4j/bunyan/winston vocabulary so any of those backends\n * can be plugged in behind the {@link Logger} interface.\n */\nexport type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';\n\n/**\n * A single structured log argument. A logger legitimately accepts arbitrary\n * values (objects, errors, primitives) and lets the backend decide how to\n * render them — mirroring `console.*`/bunyan/winston signatures.\n */\n// webpieces-disable no-any-unknown -- a logger must accept arbitrary values to render; this is the one intentional widening\nexport type LogArg = unknown;\n\n/**\n * Logger - the pluggable logging contract for WebPieces.\n *\n * This is a BUSINESS-LOGIC interface (methods with behavior), so per the\n * webpieces guidelines it is an `interface`, not a class. Different projects\n * plug in different backends (bunyan, winston, pino, browser console, a\n * file writer, ...) by supplying an implementation via a {@link LoggerFactory}.\n *\n * Implementations MUST stay browser-safe if they are to be used from Angular /\n * React. Node-only backends (bunyan, file writers, ...) are wired in by\n * `framework:express` apps at startup, never in browser-safe libraries.\n *\n * Each method takes a message plus optional structured args (objects, errors,\n * numbers) that the backend decides how to render — matching `console.*` and\n * bunyan/winston signatures.\n */\nexport interface Logger {\n    trace(message: string, ...args: LogArg[]): void;\n    debug(message: string, ...args: LogArg[]): void;\n    info(message: string, ...args: LogArg[]): void;\n    warn(message: string, ...args: LogArg[]): void;\n    error(message: string, ...args: LogArg[]): void;\n}\n"]}

package/src/logging/LoggerFactory.d.ts

@@ -0,0 +1,16 @@
+import { Logger } from './Logger';
+/**
+ * LoggerFactory - the pluggable seam that produces named {@link Logger}s.
+ *
+ * BUSINESS-LOGIC interface (a method with behavior). An app selects its logging
+ * backend by installing one implementation of this factory globally via
+ * {@link LogManager.setFactory}. Everything else in the codebase asks
+ * {@link LogManager.getLogger} for a named logger and never knows which backend
+ * is behind it.
+ *
+ * `name` is conventionally the class or module name (slf4j style), e.g.
+ * `LogManager.getLogger('LogApiCall')`.
+ */
+export interface LoggerFactory {
+    getLogger(name: string): Logger;
+}

package/src/logging/LoggerFactory.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=LoggerFactory.js.map

package/src/logging/LoggerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerFactory.js","sourceRoot":"","sources":["../../../../../../packages/core/core-util/src/logging/LoggerFactory.ts"],"names":[],"mappings":"","sourcesContent":["import { Logger } from './Logger';\n\n/**\n * LoggerFactory - the pluggable seam that produces named {@link Logger}s.\n *\n * BUSINESS-LOGIC interface (a method with behavior). An app selects its logging\n * backend by installing one implementation of this factory globally via\n * {@link LogManager.setFactory}. Everything else in the codebase asks\n * {@link LogManager.getLogger} for a named logger and never knows which backend\n * is behind it.\n *\n * `name` is conventionally the class or module name (slf4j style), e.g.\n * `LogManager.getLogger('LogApiCall')`.\n */\nexport interface LoggerFactory {\n    getLogger(name: string): Logger;\n}\n"]}