@croct/sdk 0.17.10 → 0.17.11

package/constants.cjs

@@ -25,7 +25,7 @@ __export(constants_exports, {
 module.exports = __toCommonJS(constants_exports);
 const BASE_ENDPOINT_URL = "https://api.croct.io";
 const MAX_QUERY_LENGTH = parseInt("<@maxQueryLength@>", 10);
-const VERSION = "0.17.10";
+const VERSION = "0.17.11";
 const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.10';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}
+{"version":3,"sources":["../src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.11';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}

package/constants.d.ts

@@ -1,6 +1,6 @@
 declare const BASE_ENDPOINT_URL = "https://api.croct.io";
 declare const MAX_QUERY_LENGTH: number;
-declare const VERSION = "0.17.10";
-declare const CLIENT_LIBRARY = "Croct SDK JS v0.17.10";
+declare const VERSION = "0.17.11";
+declare const CLIENT_LIBRARY = "Croct SDK JS v0.17.11";
 
 export { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH, VERSION };

package/constants.js

@@ -1,6 +1,6 @@
 const BASE_ENDPOINT_URL = "https://api.croct.io";
 const MAX_QUERY_LENGTH = parseInt("<@maxQueryLength@>", 10);
-const VERSION = "0.17.10";
+const VERSION = "0.17.11";
 const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;
 export {
   BASE_ENDPOINT_URL,

package/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.10';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":"AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}
+{"version":3,"sources":["src/constants.ts"],"sourcesContent":["export const BASE_ENDPOINT_URL = 'https://api.croct.io';\nexport const MAX_QUERY_LENGTH = 500;\nexport const VERSION = '0.17.11';\nexport const CLIENT_LIBRARY = `Croct SDK JS v${VERSION}`;\n"],"mappings":"AAAO,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB,SAAS,sBAAsB,EAAE;AAC1D,MAAM,UAAU;AAChB,MAAM,iBAAiB,iBAAiB,OAAO;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/sdk",
-  "version": "0.17.10",
+  "version": "0.17.11",
   "description": "Croct SDK for JavaScript.",
   "license": "MIT",
   "author": {

package/src/activeRecord.ts

@@ -1,150 +0,0 @@
-import {JsonStructure, JsonValue} from '@croct/json';
-import {Operation, Patch} from './patch';
-import {TrackingEvent} from './trackingEvents';
-import {
-    addOperation,
-    clearOperation,
-    combineOperation,
-    decrementOperation,
-    incrementOperation,
-    mergeOperation,
-    setOperation,
-    unsetOperation,
-    removeOperation,
-} from './schema';
-
-const operationSchema = {
-    add: addOperation,
-    set: setOperation,
-    merge: mergeOperation,
-    combine: combineOperation,
-    increment: incrementOperation,
-    decrement: decrementOperation,
-    clear: clearOperation,
-    unset: unsetOperation,
-    remove: removeOperation,
-};
-
-export abstract class ActiveRecord<T extends TrackingEvent> {
-    private readonly operations: Operation[] = [];
-
-    public set(value: JsonValue): this;
-
-    public set(property: string, value: JsonValue): this;
-
-    public set(propertyOrValue: string | JsonValue, value?: JsonValue): this {
-        if (typeof propertyOrValue === 'string') {
-            return this.pushOperation({
-                type: 'set',
-                path: propertyOrValue,
-                value: value as JsonValue,
-            });
-        }
-
-        return this.pushOperation({
-            type: 'set',
-            path: '.',
-            value: propertyOrValue,
-        });
-    }
-
-    public add(property: string, value: JsonValue): this {
-        return this.pushOperation({
-            type: 'add',
-            path: property,
-            value: value,
-        });
-    }
-
-    public combine(property: string, value: JsonValue): this {
-        return this.pushOperation({
-            type: 'combine',
-            path: property,
-            value: value,
-        });
-    }
-
-    public merge(value: JsonStructure): this;
-
-    public merge(property: string, value: JsonStructure): this;
-
-    public merge(propertyOrValue: string | JsonStructure, value?: JsonStructure): this {
-        if (typeof propertyOrValue === 'string') {
-            return this.pushOperation({
-                type: 'merge',
-                path: propertyOrValue,
-                value: value as JsonStructure,
-            });
-        }
-
-        return this.pushOperation({
-            type: 'merge',
-            path: '.',
-            value: propertyOrValue,
-        });
-    }
-
-    public increment(property: string, amount = 1): this {
-        return this.pushOperation({
-            type: 'increment',
-            path: property,
-            value: amount,
-        });
-    }
-
-    public decrement(property: string, amount = 1): this {
-        return this.pushOperation({
-            type: 'decrement',
-            path: property,
-            value: amount,
-        });
-    }
-
-    public clear(property: string): this {
-        return this.pushOperation({
-            type: 'clear',
-            path: property,
-        });
-    }
-
-    public unset(property: string): this {
-        return this.pushOperation({
-            type: 'unset',
-            path: property,
-        });
-    }
-
-    public remove(property: string, value: JsonValue): this {
-        return this.pushOperation({
-            type: 'remove',
-            path: property,
-            value: value,
-        });
-    }
-
-    private pushOperation(operation: Operation): this {
-        const {type, ...data} = operation;
-
-        operationSchema[type].validate(data);
-
-        this.operations.push(operation);
-
-        return this;
-    }
-
-    protected reset(): this {
-        this.operations.splice(0);
-
-        return this;
-    }
-
-    public abstract save(): Promise<T>;
-
-    protected isDirty(): boolean {
-        return this.operations.length > 0;
-    }
-
-    protected buildPatch(): Patch {
-        return {operations: this.operations.slice()};
-    }
-}

package/src/apiKey.ts

@@ -1,208 +0,0 @@
-export type ParsedPrivateKey = {
-    algorithm: string,
-    encodedKey: string,
-};
-
-type Algorithm = {
-    keyAlgorithm: EcKeyImportParams,
-    signatureAlgorithm: EcdsaParams,
-};
-
-export class ApiKey {
-    private static readonly IDENTIFIER_PATTERN = /^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$/i;
-
-    private static readonly PRIVATE_KEY_PATTERN = /^[a-z0-9]+;[^;]+$/i;
-
-    private static readonly ALGORITHMS: Record<string, Algorithm> = {
-        ES256: {
-            keyAlgorithm: {
-                name: 'ECDSA',
-                namedCurve: 'P-256',
-            },
-            signatureAlgorithm: {
-                name: 'ECDSA',
-                hash: 'SHA-256',
-            },
-        },
-    };
-
-    private readonly identifier: string;
-
-    private readonly privateKey?: ParsedPrivateKey;
-
-    private importedKey: Promise<CryptoKey>;
-
-    private constructor(identifier: string, privateKey?: ParsedPrivateKey) {
-        this.identifier = identifier;
-        this.privateKey = privateKey;
-    }
-
-    public static from(apiKey: string | ApiKey): ApiKey {
-        if (apiKey instanceof ApiKey) {
-            return apiKey;
-        }
-
-        return ApiKey.parse(apiKey);
-    }
-
-    public static parse(apiKey: string): ApiKey {
-        const parts = apiKey.split(':');
-
-        if (parts.length > 2) {
-            throw new Error('Invalid API key format.');
-        }
-
-        return ApiKey.of(parts[0], parts[1]);
-    }
-
-    public static of(identifier: string, privateKey?: string): ApiKey {
-        if (!ApiKey.IDENTIFIER_PATTERN.test(identifier)) {
-            throw new Error('The identifier must be a UUID.');
-        }
-
-        if (privateKey === undefined || privateKey === '') {
-            return new ApiKey(identifier);
-        }
-
-        if (!ApiKey.PRIVATE_KEY_PATTERN.test(privateKey)) {
-            throw new Error('The private key is malformed.');
-        }
-
-        const [algorithmName, encodedKey] = privateKey.split(';');
-
-        if (!(algorithmName in ApiKey.ALGORITHMS)) {
-            throw new Error(`Unsupported signing algorithm "${algorithmName}".`);
-        }
-
-        return new ApiKey(identifier, {
-            algorithm: algorithmName,
-            encodedKey: encodedKey,
-        });
-    }
-
-    public getIdentifier(): string {
-        return this.identifier;
-    }
-
-    public async getIdentifierHash(): Promise<string> {
-        const identifierBytes = ApiKey.createByteArrayFromHexString(this.identifier.replace(/-/g, ''));
-        const rawHash = await crypto.subtle.digest('SHA-256', identifierBytes);
-
-        return ApiKey.convertBufferToHexString(rawHash);
-    }
-
-    public hasPrivateKey(): boolean {
-        return this.privateKey !== undefined;
-    }
-
-    public getPrivateKey(): string {
-        if (this.privateKey === undefined) {
-            throw new Error('The API key does not have a private key.');
-        }
-
-        return `${this.privateKey.algorithm};${this.privateKey.encodedKey}`;
-    }
-
-    public async sign(data: string): Promise<string> {
-        const key = await this.importKey();
-        const algorithm = this.getSigningAlgorithm();
-
-        return ApiKey.convertBufferToString(
-            await crypto.subtle.sign(
-                ApiKey.ALGORITHMS[algorithm].signatureAlgorithm,
-                key,
-                ApiKey.createByteArrayFromString(data),
-            ),
-        );
-    }
-
-    public getSigningAlgorithm(): string {
-        const {algorithm} = this.getParsedPrivateKey();
-
-        return algorithm;
-    }
-
-    private importKey(): Promise<CryptoKey> {
-        const {algorithm, encodedKey} = this.getParsedPrivateKey();
-
-        if (this.importedKey === undefined) {
-            this.importedKey = crypto.subtle
-                .importKey(
-                    'pkcs8',
-                    ApiKey.createByteArrayFromString(atob(encodedKey)),
-                    ApiKey.ALGORITHMS[algorithm].keyAlgorithm,
-                    false,
-                    ['sign'],
-                );
-        }
-
-        return this.importedKey;
-    }
-
-    private getParsedPrivateKey(): ParsedPrivateKey {
-        if (this.privateKey === undefined) {
-            throw new Error('The API key does not have a private key.');
-        }
-
-        return this.privateKey;
-    }
-
-    public export(): string {
-        return this.identifier + (this.hasPrivateKey() ? `:${this.getPrivateKey()}` : '');
-    }
-
-    public toString(): string {
-        return '[redacted]';
-    }
-
-    /**
-     * Create an array buffer from a string.
-     *
-     * @see https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
-     *
-     * @param data The string to convert.
-     * @returns The array buffer.
-     */
-    private static createByteArrayFromString(data: string): Uint8Array {
-        const byteArray = new Uint8Array(data.length);
-
-        for (let i = 0; i < byteArray.length; i++) {
-            byteArray[i] = data.charCodeAt(i);
-        }
-
-        return byteArray;
-    }
-
-    private static createByteArrayFromHexString(data: string): Uint8Array {
-        const byteArray = new Uint8Array(data.length / 2);
-
-        for (let i = 0; i < byteArray.length; i++) {
-            byteArray[i] = parseInt(data.substring(i * 2, i * 2 + 2), 16);
-        }
-
-        return byteArray;
-    }
-
-    /**
-     * Convert an array buffer to a string.
-     *
-     * @see https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
-     *
-     * @param buffer The buffer to convert.
-     * @returns The string.
-     */
-    private static convertBufferToString(buffer: ArrayLike<number> | ArrayBufferLike): string {
-        return String.fromCharCode(...new Uint8Array(buffer));
-    }
-
-    private static convertBufferToHexString(buffer: ArrayLike<number> | ArrayBufferLike): string {
-        const bytes = new Uint8Array(buffer);
-        let hexString = '';
-
-        for (let i = 0; i < bytes.length; i++) {
-            hexString += bytes[i].toString(16).padStart(2, '0');
-        }
-
-        return hexString;
-    }
-}

package/src/base64Url.ts

@@ -1,22 +0,0 @@
-function base64Unescape(value: string): string {
-    return (value + '==='.slice((value.length + 3) % 4)).replace(/-/g, '+').replace(/_/g, '/');
-}
-
-function base64Escape(value: string): string {
-    return value
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_')
-        .replace(/=/g, '');
-}
-
-export function base64UrlEncode(value: string, utf8 = false): string {
-    return utf8
-        ? base64Escape(btoa(String.fromCodePoint(...new TextEncoder().encode(value))))
-        : base64Escape(btoa(value));
-}
-
-export function base64UrlDecode(value: string, utf8 = false): string {
-    return utf8
-        ? new TextDecoder().decode(Uint8Array.from(atob(base64Unescape(value)), m => m.codePointAt(0)!))
-        : atob(base64Unescape(value));
-}

package/src/cache/cache.ts

@@ -1,22 +0,0 @@
-export interface Cache {
-    get(): string|null;
-    put(value: string): void;
-    clear(): void;
-}
-
-export interface CacheListener {
-    (value: string|null): void;
-}
-
-export interface ObservableCache extends Cache {
-    addListener(listener: CacheListener): void;
-
-    removeListener(listener: CacheListener): void;
-}
-
-export namespace ObservableCache {
-    export function isObservable(cache: Cache): cache is ObservableCache {
-        return typeof (cache as ObservableCache).addListener === 'function'
-            && typeof (cache as ObservableCache).removeListener === 'function';
-    }
-}

package/src/cache/cookieCache.ts

@@ -1,88 +0,0 @@
-import {Cache} from './cache';
-
-export type CookieCacheConfiguration = {
-    name: string,
-    secure?: boolean,
-    maxAge?: number,
-    domain?: string,
-    path?: string,
-    sameSite?: 'strict' | 'lax' | 'none',
-};
-
-export class CookieCache implements Cache {
-    private readonly config: CookieCacheConfiguration;
-
-    public constructor(config: CookieCacheConfiguration, defaultSecure = window.location.protocol === 'https:') {
-        this.config = {
-            ...config,
-            path: config.path ?? '/',
-        };
-
-        if (defaultSecure && this.config.secure === undefined) {
-            this.config.secure = true;
-        }
-
-        if (this.config.secure === true && this.config.sameSite === undefined) {
-            this.config.sameSite = 'none';
-        }
-    }
-
-    public get(): string | null {
-        const entries = document.cookie.split(';');
-
-        for (const entry of entries) {
-            const [name, value] = entry.split('=');
-
-            if (CookieCache.decode(name).trim() === this.config.name) {
-                return CookieCache.decode(value.trim());
-            }
-        }
-
-        return null;
-    }
-
-    public put(value: string): void {
-        document.cookie = CookieCache.serializeCookie(value, this.config);
-    }
-
-    public clear(): void {
-        document.cookie = CookieCache.serializeCookie('', {
-            ...this.config,
-            maxAge: 0,
-        });
-    }
-
-    private static serializeCookie(value: string, config: CookieCacheConfiguration): string {
-        const cookie = [`${CookieCache.encode(config.name)}=${CookieCache.encode(value)}`];
-
-        if (config.maxAge !== undefined) {
-            cookie.push(`Max-Age=${config.maxAge}`);
-        }
-
-        if (config.domain !== undefined) {
-            cookie.push(`Domain=${CookieCache.encode(config.domain)}`);
-        }
-
-        if (config.path !== undefined) {
-            cookie.push(`Path=${CookieCache.encode(config.path)}`);
-        }
-
-        if (config.secure === true) {
-            cookie.push('Secure');
-        }
-
-        if (config.sameSite !== undefined) {
-            cookie.push(`SameSite=${({strict: 'Strict', lax: 'Lax', none: 'None'})[config.sameSite]}`);
-        }
-
-        return cookie.join('; ');
-    }
-
-    private static encode(value: string): string {
-        return value.replace(/[,; ]+/g, encodeURIComponent);
-    }
-
-    private static decode(value: string): string {
-        return decodeURIComponent(value);
-    }
-}

package/src/cache/fallbackCache.ts

@@ -1,29 +0,0 @@
-import {Cache} from './cache';
-
-export class FallbackCache implements Cache {
-    private readonly caches: Cache[];
-
-    public constructor(...caches: Cache[]) {
-        this.caches = caches;
-    }
-
-    public get(): string|null {
-        for (const cache of this.caches) {
-            const value = cache.get();
-
-            if (value !== null) {
-                return value;
-            }
-        }
-
-        return null;
-    }
-
-    public put(value: string): void {
-        this.caches.forEach(cache => cache.put(value));
-    }
-
-    public clear(): void {
-        this.caches.forEach(cache => cache.clear());
-    }
-}

package/src/cache/inMemoryCache.ts

@@ -1,21 +0,0 @@
-import {Cache} from './cache';
-
-export class InMemoryCache implements Cache {
-    private cache?: string;
-
-    public constructor(cache?: string) {
-        this.cache = cache;
-    }
-
-    public get(): string | null {
-        return this.cache ?? null;
-    }
-
-    public put(value: string): void {
-        this.cache = value;
-    }
-
-    public clear(): void {
-        delete this.cache;
-    }
-}

package/src/cache/index.ts

@@ -1,4 +0,0 @@
-export * from './cache';
-export {FallbackCache} from './fallbackCache';
-export {InMemoryCache} from './inMemoryCache';
-export {LocalStorageCache} from './localStorageCache';

package/src/cache/localStorageCache.ts

@@ -1,85 +0,0 @@
-import {CacheListener, ObservableCache} from './cache';
-
-export class LocalStorageCache implements ObservableCache {
-    private readonly storage: Storage;
-
-    private readonly key: string;
-
-    private value: string|null;
-
-    private readonly listeners: CacheListener[] = [];
-
-    public constructor(storage: Storage, key: string) {
-        this.storage = storage;
-        this.key = key;
-        this.value = storage.getItem(key);
-    }
-
-    public static autoSync(cache: LocalStorageCache): (() => void) {
-        const listener = cache.sync.bind(cache);
-
-        window.addEventListener('storage', listener);
-
-        return (): void => window.removeEventListener('storage', listener);
-    }
-
-    public get(): string|null {
-        return this.value;
-    }
-
-    public put(value: string): void {
-        this.storage.setItem(this.key, value);
-
-        if (this.value !== value) {
-            this.value = value;
-            this.notifyChange(value);
-        }
-    }
-
-    public clear(): void {
-        this.storage.removeItem(this.key);
-
-        if (this.value !== null) {
-            this.value = null;
-            this.notifyChange(null);
-        }
-    }
-
-    public addListener(listener: CacheListener): void {
-        if (!this.listeners.includes(listener)) {
-            this.listeners.push(listener);
-        }
-    }
-
-    public removeListener(listener: CacheListener): void {
-        const index = this.listeners.indexOf(listener);
-
-        if (index > -1) {
-            this.listeners.splice(index, 1);
-        }
-    }
-
-    private notifyChange(value: string|null): void {
-        this.listeners.forEach(listener => listener(value));
-    }
-
-    private sync(event: StorageEvent): void {
-        if (event.storageArea !== this.storage || (event.key !== null && event.key !== this.key)) {
-            // Ignore unrelated changes
-            return;
-        }
-
-        /*
-         * Retrieving the value from the store rather than the event ensures
-         * the cache will be in sync with the latest value set.
-         * In case of cascading changes, it prevents notifying listeners
-         * about intermediate states already outdated at this point.
-         */
-        const value = this.storage.getItem(this.key);
-
-        if (this.value !== value) {
-            this.value = value;
-            this.notifyChange(value);
-        }
-    }
-}