@croct/sdk 0.17.12 → 0.18.1

package/index.cjs

@@ -17,16 +17,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
-  Configuration: () => import_sdk.Configuration,
   Sdk: () => import_sdk.Sdk,
   VERSION: () => import_constants.VERSION
 });
 module.exports = __toCommonJS(index_exports);
-var import_constants = require("./constants");
-var import_sdk = require("./sdk");
+var import_constants = require('./constants.cjs');
+var import_sdk = require('./sdk.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Configuration,
   Sdk,
   VERSION
 });

package/index.d.cts

@@ -0,0 +1,25 @@
+export { VERSION } from './constants.cjs';
+export { Configuration, Sdk } from './sdk.cjs';
+import './container.cjs';
+import './logging/logger.cjs';
+import './context.cjs';
+import './token/token.cjs';
+import '@croct/json';
+import './apiKey.cjs';
+import './cache/cache.cjs';
+import './tab.cjs';
+import './eventManager.cjs';
+import './sdkEvents.cjs';
+import './queue/monitoredQueue.cjs';
+import './queue/queue.cjs';
+import './tracker.cjs';
+import './channel/channel.cjs';
+import './retry/policy.cjs';
+import './trackingEvents.cjs';
+import './patch.cjs';
+import './utilityTypes.cjs';
+import './evaluator.cjs';
+import './sourceLocation.cjs';
+import './cid/assigner.cjs';
+import './contentFetcher.cjs';
+import './cache/cookieCache.cjs';

package/index.js

@@ -1,7 +1,6 @@
-import { VERSION } from "./constants";
-import { Sdk, Configuration } from "./sdk";
+import { VERSION } from "./constants.js";
+import { Sdk } from "./sdk.js";
 export {
-  Configuration,
   Sdk,
   VERSION
 };

package/logging/consoleLogger.d.cts

@@ -0,0 +1,13 @@
+import { Logger } from './logger.cjs';
+
+declare class ConsoleLogger implements Logger {
+    private readonly namespace?;
+    constructor(namespace?: string);
+    get debug(): (message: string) => void;
+    get info(): (message: string) => void;
+    get warn(): (message: string) => void;
+    get error(): (message: string) => void;
+    private bind;
+}
+
+export { ConsoleLogger };

package/logging/filteredLogger.d.cts

@@ -0,0 +1,22 @@
+import { Logger } from './logger.cjs';
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+type LogFilter = (level: LogLevel, message: string) => boolean;
+type FilteredLoggerConfiguration = {
+    logger: Logger;
+    allowFilter: LogFilter;
+};
+declare class FilteredLogger implements Logger {
+    private readonly logger;
+    private readonly allowFilter;
+    constructor(configuration: FilteredLoggerConfiguration);
+    static include(logger: Logger, levels: LogLevel[]): Logger;
+    static exclude(logger: Logger, levels: LogLevel[]): FilteredLogger;
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    private log;
+}
+
+export { FilteredLogger, type FilteredLoggerConfiguration, type LogFilter, type LogLevel };

package/logging/index.cjs

@@ -24,16 +24,16 @@ __export(logging_exports, {
   NullLogger: () => import_nullLogger.NullLogger
 });
 module.exports = __toCommonJS(logging_exports);
-__reExport(logging_exports, require("./logger"), module.exports);
-var import_consoleLogger = require("./consoleLogger");
-var import_namespacedLogger = require("./namespacedLogger");
-var import_nullLogger = require("./nullLogger");
-var import_filteredLogger = require("./filteredLogger");
+__reExport(logging_exports, require('./logger.cjs'), module.exports);
+var import_consoleLogger = require('./consoleLogger.cjs');
+var import_namespacedLogger = require('./namespacedLogger.cjs');
+var import_nullLogger = require('./nullLogger.cjs');
+var import_filteredLogger = require('./filteredLogger.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConsoleLogger,
   FilteredLogger,
   NamespacedLogger,
   NullLogger,
-  ...require("./logger")
+  ...require('./logger.cjs')
 });

package/logging/index.d.cts

@@ -0,0 +1,5 @@
+export { Logger, LoggerFactory } from './logger.cjs';
+export { ConsoleLogger } from './consoleLogger.cjs';
+export { NamespacedLogger } from './namespacedLogger.cjs';
+export { NullLogger } from './nullLogger.cjs';
+export { FilteredLogger } from './filteredLogger.cjs';

package/logging/index.js

@@ -1,8 +1,8 @@
-export * from "./logger";
-import { ConsoleLogger } from "./consoleLogger";
-import { NamespacedLogger } from "./namespacedLogger";
-import { NullLogger } from "./nullLogger";
-import { FilteredLogger } from "./filteredLogger";
+export * from "./logger.js";
+import { ConsoleLogger } from "./consoleLogger.js";
+import { NamespacedLogger } from "./namespacedLogger.js";
+import { NullLogger } from "./nullLogger.js";
+import { FilteredLogger } from "./filteredLogger.js";
 export {
   ConsoleLogger,
   FilteredLogger,

package/logging/logger.d.cts

@@ -0,0 +1,11 @@
+interface Logger {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+interface LoggerFactory {
+    (namespace?: string): Logger;
+}
+
+export type { Logger, LoggerFactory };

package/logging/namespacedLogger.d.cts

@@ -0,0 +1,14 @@
+import { Logger } from './logger.cjs';
+
+declare class NamespacedLogger implements Logger {
+    private readonly logger;
+    private readonly namespace;
+    constructor(logger: Logger, namespace: string);
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    private format;
+}
+
+export { NamespacedLogger };

package/logging/nullLogger.d.cts

@@ -0,0 +1,10 @@
+import { Logger } from './logger.cjs';
+
+declare class NullLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+
+export { NullLogger };

package/namespacedStorage.d.cts

@@ -0,0 +1,16 @@
+declare class NamespacedStorage implements Storage {
+    private readonly storage;
+    private readonly namespace;
+    constructor(storage: Storage, namespace: string);
+    get length(): number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+    private getKeys;
+    private getPrefixedKey;
+    private getPrefix;
+}
+
+export { NamespacedStorage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/sdk",
-  "version": "0.17.12",
+  "version": "0.18.1",
   "description": "Croct SDK for JavaScript.",
   "license": "MIT",
   "author": {
@@ -84,6 +84,7 @@
     "tslib": "^2.5.0"
   },
   "devDependencies": {
+    "esbuild-fix-imports-plugin": "^1.0.19",
     "@croct/eslint-plugin": "^0.7.0",
     "@types/jest": "^29.2.3",
     "eslint": "^8.57.0",
@@ -101,6 +102,8 @@
     "**/*.cjs",
     "**/*.mjs",
     "**/*.ts",
+    "**/*.mts",
+    "**/*.cts",
     "**/*.map"
   ],
   "browserslist": [

package/patch.d.cts

@@ -0,0 +1,46 @@
+import { JsonValue, JsonStructure } from '@croct/json';
+
+interface AbstractOperation {
+    type: string;
+    path: string;
+}
+interface UnsetOperation extends AbstractOperation {
+    type: 'unset';
+}
+interface ClearOperation extends AbstractOperation {
+    type: 'clear';
+}
+interface SetOperation extends AbstractOperation {
+    type: 'set';
+    value: JsonValue;
+}
+interface AddOperation extends AbstractOperation {
+    type: 'add';
+    value: JsonValue;
+}
+interface CombineOperation extends AbstractOperation {
+    type: 'combine';
+    value: JsonValue;
+}
+interface MergeOperation extends AbstractOperation {
+    type: 'merge';
+    value: JsonStructure;
+}
+interface IncrementOperation extends AbstractOperation {
+    type: 'increment';
+    value: JsonValue;
+}
+interface DecrementOperation extends AbstractOperation {
+    type: 'decrement';
+    value: JsonValue;
+}
+interface removeOperation extends AbstractOperation {
+    type: 'remove';
+    value: JsonValue;
+}
+type Operation = UnsetOperation | ClearOperation | AddOperation | SetOperation | CombineOperation | MergeOperation | IncrementOperation | DecrementOperation | removeOperation;
+interface Patch {
+    operations: Operation[];
+}
+
+export type { Operation, Patch };

package/queue/capacityRestrictedQueue.d.cts

@@ -0,0 +1,16 @@
+import { Queue } from './queue.cjs';
+
+declare class CapacityRestrictedQueue<T> implements Queue<T> {
+    private readonly queue;
+    private readonly capacity;
+    constructor(queue: Queue<T>, capacity: number);
+    all(): T[];
+    getCapacity(): number;
+    isEmpty(): boolean;
+    length(): number;
+    peek(): T | null;
+    push(value: T): void;
+    shift(): T;
+}
+
+export { CapacityRestrictedQueue };

package/queue/inMemoryQueue.d.cts

@@ -0,0 +1,15 @@
+import { Queue } from './queue.cjs';
+
+declare class InMemoryQueue<T> implements Queue<T> {
+    private queue;
+    constructor(...values: T[]);
+    all(): T[];
+    getCapacity(): number;
+    isEmpty(): boolean;
+    push(value: T): void;
+    peek(): T | null;
+    shift(): T;
+    length(): number;
+}
+
+export { InMemoryQueue };

package/queue/index.cjs

@@ -24,16 +24,16 @@ __export(queue_exports, {
   PersistentQueue: () => import_persistentQueue.PersistentQueue
 });
 module.exports = __toCommonJS(queue_exports);
-__reExport(queue_exports, require("./queue"), module.exports);
-var import_capacityRestrictedQueue = require("./capacityRestrictedQueue");
-var import_inMemoryQueue = require("./inMemoryQueue");
-var import_monitoredQueue = require("./monitoredQueue");
-var import_persistentQueue = require("./persistentQueue");
+__reExport(queue_exports, require('./queue.cjs'), module.exports);
+var import_capacityRestrictedQueue = require('./capacityRestrictedQueue.cjs');
+var import_inMemoryQueue = require('./inMemoryQueue.cjs');
+var import_monitoredQueue = require('./monitoredQueue.cjs');
+var import_persistentQueue = require('./persistentQueue.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CapacityRestrictedQueue,
   InMemoryQueue,
   MonitoredQueue,
   PersistentQueue,
-  ...require("./queue")
+  ...require('./queue.cjs')
 });

package/queue/index.d.cts

@@ -0,0 +1,6 @@
+export { Queue } from './queue.cjs';
+export { CapacityRestrictedQueue } from './capacityRestrictedQueue.cjs';
+export { InMemoryQueue } from './inMemoryQueue.cjs';
+export { MonitoredQueue } from './monitoredQueue.cjs';
+export { PersistentQueue } from './persistentQueue.cjs';
+import '../logging/logger.cjs';

package/queue/index.js

@@ -1,8 +1,8 @@
-export * from "./queue";
-import { CapacityRestrictedQueue } from "./capacityRestrictedQueue";
-import { InMemoryQueue } from "./inMemoryQueue";
-import { MonitoredQueue } from "./monitoredQueue";
-import { PersistentQueue } from "./persistentQueue";
+export * from "./queue.js";
+import { CapacityRestrictedQueue } from "./capacityRestrictedQueue.js";
+import { InMemoryQueue } from "./inMemoryQueue.js";
+import { MonitoredQueue } from "./monitoredQueue.js";
+import { PersistentQueue } from "./persistentQueue.js";
 export {
   CapacityRestrictedQueue,
   InMemoryQueue,

package/queue/monitoredQueue.cjs

@@ -20,7 +20,7 @@ __export(monitoredQueue_exports, {
   MonitoredQueue: () => MonitoredQueue
 });
 module.exports = __toCommonJS(monitoredQueue_exports);
-var import_logging = require("../logging");
+var import_logging = require('../logging/index.cjs');
 class MonitoredQueue {
   constructor(queue, logger) {
     this.callbacks = {};

package/queue/monitoredQueue.d.cts

@@ -0,0 +1,28 @@
+import { Queue } from './queue.cjs';
+import { Logger } from '../logging/logger.cjs';
+
+type QueueStatus = 'halfEmpty' | 'almostEmpty' | 'empty' | 'halfFull' | 'almostFull' | 'full';
+type QueueCallback<T> = {
+    (queue: Queue<T>): void;
+};
+declare class MonitoredQueue<T> implements Queue<T> {
+    private readonly queue;
+    private readonly logger;
+    private readonly callbacks;
+    private status;
+    constructor(queue: Queue<T>, logger?: Logger);
+    all(): T[];
+    getCapacity(): number;
+    addCallback(status: QueueStatus, callback: QueueCallback<T>): void;
+    removeCallback(type: QueueStatus, callback: QueueCallback<T>): void;
+    private setStatus;
+    private report;
+    isEmpty(): boolean;
+    length(): number;
+    peek(): T | null;
+    push(value: T): void;
+    shift(): T;
+    private updateStatus;
+}
+
+export { MonitoredQueue, type QueueCallback, type QueueStatus };

package/queue/monitoredQueue.js

@@ -1,4 +1,4 @@
-import { NullLogger } from "../logging";
+import { NullLogger } from "../logging/index.js";
 class MonitoredQueue {
   constructor(queue, logger) {
     this.callbacks = {};

package/queue/persistentQueue.d.cts

@@ -0,0 +1,18 @@
+import { Queue } from './queue.cjs';
+
+declare class PersistentQueue<T> implements Queue<T> {
+    private readonly storage;
+    private readonly key;
+    constructor(storage: Storage, key?: string);
+    all(): T[];
+    getCapacity(): number;
+    isEmpty(): boolean;
+    length(): number;
+    push(value: T): void;
+    peek(): T | null;
+    shift(): T;
+    private get queue();
+    private save;
+}
+
+export { PersistentQueue };

package/queue/queue.d.cts

@@ -0,0 +1,11 @@
+interface Queue<T> {
+    getCapacity(): number;
+    all(): T[];
+    push(value: T): void;
+    shift(): T;
+    peek(): T | null;
+    isEmpty(): boolean;
+    length(): number;
+}
+
+export type { Queue };

package/retry/arbitraryPolicy.d.cts

@@ -0,0 +1,10 @@
+import { RetryPolicy } from './policy.cjs';
+
+declare class ArbitraryPolicy<T> implements RetryPolicy<T> {
+    private readonly delays;
+    constructor(delays: number[]);
+    getDelay(attempt: number): number;
+    shouldRetry(): boolean;
+}
+
+export { ArbitraryPolicy };

package/retry/backoffPolicy.d.cts

@@ -0,0 +1,26 @@
+import { RetryPolicy } from './policy.cjs';
+
+type Options = {
+    minRetryDelay: number;
+    maxRetryDelay: number;
+    backoffFactor: number;
+    backoffJitter: number;
+    maxAttempts: number;
+};
+declare class BackoffPolicy<T> implements RetryPolicy<T> {
+    private readonly minRetryDelay;
+    private readonly maxRetryDelay;
+    private readonly backoffFactor;
+    private readonly backoffJitter;
+    private readonly maxAttempts;
+    constructor(options?: Partial<Options>);
+    /**
+     * Full Jitter algorithm
+     *
+     * @see https://www.awsarchitectureblog.com/2015/03/backoff.html
+     */
+    getDelay(attempt: number): number;
+    shouldRetry(attempt: number): boolean;
+}
+
+export { BackoffPolicy };

package/retry/index.cjs

@@ -24,16 +24,16 @@ __export(retry_exports, {
   NeverPolicy: () => import_neverPolicy.NeverPolicy
 });
 module.exports = __toCommonJS(retry_exports);
-__reExport(retry_exports, require("./policy"), module.exports);
-var import_arbitraryPolicy = require("./arbitraryPolicy");
-var import_backoffPolicy = require("./backoffPolicy");
-var import_maxAttemptsPolicy = require("./maxAttemptsPolicy");
-var import_neverPolicy = require("./neverPolicy");
+__reExport(retry_exports, require('./policy.cjs'), module.exports);
+var import_arbitraryPolicy = require('./arbitraryPolicy.cjs');
+var import_backoffPolicy = require('./backoffPolicy.cjs');
+var import_maxAttemptsPolicy = require('./maxAttemptsPolicy.cjs');
+var import_neverPolicy = require('./neverPolicy.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArbitraryPolicy,
   BackoffPolicy,
   MaxAttemptsPolicy,
   NeverPolicy,
-  ...require("./policy")
+  ...require('./policy.cjs')
 });

package/retry/index.d.cts

@@ -0,0 +1,5 @@
+export { RetryPolicy } from './policy.cjs';
+export { ArbitraryPolicy } from './arbitraryPolicy.cjs';
+export { BackoffPolicy } from './backoffPolicy.cjs';
+export { MaxAttemptsPolicy } from './maxAttemptsPolicy.cjs';
+export { NeverPolicy } from './neverPolicy.cjs';

package/retry/index.js

@@ -1,8 +1,8 @@
-export * from "./policy";
-import { ArbitraryPolicy } from "./arbitraryPolicy";
-import { BackoffPolicy } from "./backoffPolicy";
-import { MaxAttemptsPolicy } from "./maxAttemptsPolicy";
-import { NeverPolicy } from "./neverPolicy";
+export * from "./policy.js";
+import { ArbitraryPolicy } from "./arbitraryPolicy.js";
+import { BackoffPolicy } from "./backoffPolicy.js";
+import { MaxAttemptsPolicy } from "./maxAttemptsPolicy.js";
+import { NeverPolicy } from "./neverPolicy.js";
 export {
   ArbitraryPolicy,
   BackoffPolicy,

package/retry/maxAttemptsPolicy.d.cts

@@ -0,0 +1,11 @@
+import { RetryPolicy } from './policy.cjs';
+
+declare class MaxAttemptsPolicy<T> implements RetryPolicy<T> {
+    private readonly maxAttempts;
+    private readonly delay;
+    constructor(delay: number, maxAttempts: number);
+    getDelay(): number;
+    shouldRetry(attempt: number): boolean;
+}
+
+export { MaxAttemptsPolicy };

package/retry/neverPolicy.d.cts

@@ -0,0 +1,8 @@
+import { RetryPolicy } from './policy.cjs';
+
+declare class NeverPolicy<T> implements RetryPolicy<T> {
+    getDelay(): number;
+    shouldRetry(): boolean;
+}
+
+export { NeverPolicy };

package/retry/policy.d.cts

@@ -0,0 +1,6 @@
+interface RetryPolicy<T> {
+    shouldRetry(attempt: number, subject?: T, failure?: any): boolean;
+    getDelay(attempt: number): number;
+}
+
+export type { RetryPolicy };

package/schema/attributeSchema.cjs

@@ -20,7 +20,7 @@ __export(attributeSchema_exports, {
   attributeNameSchema: () => attributeNameSchema
 });
 module.exports = __toCommonJS(attributeSchema_exports);
-var import_validation = require("../validation");
+var import_validation = require('../validation/index.cjs');
 const attributeNameSchema = new import_validation.StringType({
   maxLength: 50,
   format: "identifier"

package/schema/attributeSchema.d.cts

@@ -0,0 +1,6 @@
+import { StringType } from '../validation/stringType.cjs';
+import '../validation/schema.cjs';
+
+declare const attributeNameSchema: StringType;
+
+export { attributeNameSchema };

package/schema/attributeSchema.js

@@ -1,4 +1,4 @@
-import { StringType } from "../validation";
+import { StringType } from "../validation/index.js";
 const attributeNameSchema = new StringType({
   maxLength: 50,
   format: "identifier"

package/schema/contentFetcherSchemas.cjs

@@ -20,7 +20,7 @@ __export(contentFetcherSchemas_exports, {
   fetchOptionsSchema: () => fetchOptionsSchema
 });
 module.exports = __toCommonJS(contentFetcherSchemas_exports);
-var import_validation = require("../validation");
+var import_validation = require('../validation/index.cjs');
 const fetchOptionsSchema = new import_validation.ObjectType({
   properties: {
     timeout: new import_validation.NumberType({

package/schema/contentFetcherSchemas.d.cts

@@ -0,0 +1,6 @@
+import { ObjectType } from '../validation/objectType.cjs';
+import '../validation/schema.cjs';
+
+declare const fetchOptionsSchema: ObjectType;
+
+export { fetchOptionsSchema };

package/schema/contentFetcherSchemas.js

@@ -1,4 +1,4 @@
-import { ObjectType, NumberType, JsonObjectType, StringType, UnionType } from "../validation";
+import { ObjectType, NumberType, JsonObjectType, StringType, UnionType } from "../validation/index.js";
 const fetchOptionsSchema = new ObjectType({
   properties: {
     timeout: new NumberType({

package/schema/contentSchemas.cjs

@@ -20,7 +20,7 @@ __export(contentSchemas_exports, {
   postDetails: () => postDetails
 });
 module.exports = __toCommonJS(contentSchemas_exports);
-var import_validation = require("../validation");
+var import_validation = require('../validation/index.cjs');
 const postDetails = new import_validation.ObjectType({
   required: ["postId", "title", "publishTime"],
   properties: {

package/schema/contentSchemas.d.cts

@@ -0,0 +1,6 @@
+import { ObjectType } from '../validation/objectType.cjs';
+import '../validation/schema.cjs';
+
+declare const postDetails: ObjectType;
+
+export { postDetails };

package/schema/contentSchemas.js

@@ -1,4 +1,4 @@
-import { ArrayType, StringType, ObjectType, NumberType } from "../validation";
+import { ArrayType, StringType, ObjectType, NumberType } from "../validation/index.js";
 const postDetails = new ObjectType({
   required: ["postId", "title", "publishTime"],
   properties: {

package/schema/contextSchemas.cjs

@@ -20,7 +20,7 @@ __export(contextSchemas_exports, {
   tokenScopeSchema: () => tokenScopeSchema
 });
 module.exports = __toCommonJS(contextSchemas_exports);
-var import_validation = require("../validation");
+var import_validation = require('../validation/index.cjs');
 const tokenScopeSchema = new import_validation.StringType({
   enumeration: ["global", "contextual", "isolated"]
 });

package/schema/contextSchemas.d.cts

@@ -0,0 +1,6 @@
+import { StringType } from '../validation/stringType.cjs';
+import '../validation/schema.cjs';
+
+declare const tokenScopeSchema: StringType;
+
+export { tokenScopeSchema };

package/schema/contextSchemas.js

@@ -1,4 +1,4 @@
-import { StringType } from "../validation";
+import { StringType } from "../validation/index.js";
 const tokenScopeSchema = new StringType({
   enumeration: ["global", "contextual", "isolated"]
 });