@conduit-client/utils 2.0.0

package/dist/types/utility-types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Returns the concrete constructor type for an abstract constructor. The
+ * concrete constructor is assumed to have the same constructor parameters
+ * as the abstract constructor.
+ */
+export type ConcreteConstructor<AbstractConstructor extends abstract new (...params: Array<any>) => unknown> = new (...params: ConstructorParameters<AbstractConstructor>) => InstanceType<AbstractConstructor>;
+/**
+ * As TypeScript's Partial<T> utility type, but recursive to also allow subsets of
+ * nested types.
+ */
+export type DeepPartial<T> = (T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T extends Array<infer U> ? Array<DeepPartial<U>> : T) | undefined;
+/**
+ * As TypeScript's Readonly<T> utility type, but recursive to also allow subsets of
+ * nested types.
+ */
+export type DeepReadonly<T> = T extends object ? {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+} : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends string | number | boolean | null | undefined ? T : never;
+/**
+ * Returns just the public properties of a class.
+ */
+export type PublicInterface<Class> = {
+    [K in keyof Class]: Class[K];
+};
+/**
+ * Type used to express the intention that something can complete either
+ * synchronously or asynchronously.
+ */
+export type SyncOrAsync<D> = PromiseLike<D>;
+/**
+ * A utility type for inferring the first part of a period delimited string
+ */
+type CurrentPath<T extends string> = T extends `${infer K}.${string}` ? K : T;
+/**
+ * A utility type for inferring the part of a period delimited string after the first period
+ */
+type RestOfPath<T extends string> = T extends `${string}.${infer Rest}` ? Rest : never;
+/**
+ * A utility type for extracting the values of a map type
+ */
+export type ValueOf<T> = T[keyof T];
+/**
+ * A utility type for replacing a union of paths on a given JSON-like object
+ * with a new type
+ */
+type UpdatePath<T, Paths extends string, R> = T extends Array<any> ? T extends Array<infer Items> ? CurrentPath<Paths> extends '*' ? Array<R> : Array<UpdatePath<Items, Paths, R>> : never : T extends Record<string, any> ? {
+    [P in keyof T]: P extends CurrentPath<Paths> ? ValueOf<{
+        [Path in Paths as P extends CurrentPath<Path> ? Path : never]: RestOfPath<Path> extends never ? R : UpdatePath<T[P], RestOfPath<Path>, R>;
+    }> : T[P];
+} : T;
+/**
+ * A utility type for defining a path replacement, including what paths to replace,
+ * and what type to replace them with. Used with the `ApplyPathUpdates` type.
+ */
+type PathUpdateRule<Replacement, Paths extends string> = {
+    replacement: Replacement;
+    paths: Paths;
+};
+/**
+ * A utility type that takes a tuple of `PathReplacement` types, and iteratively
+ * applies those replacements to an input type. Allows for updating many paths within a given object
+ * with new types.
+ */
+export type ApplyPathUpdates<T, PathUpdateRules extends PathUpdateRule<any, string>[]> = PathUpdateRules extends [infer First, ...infer Rest] ? First extends PathUpdateRule<any, string> ? Rest extends PathUpdateRule<any, string>[] ? ApplyPathUpdates<UpdatePath<T, First['paths'], First['replacement']>, Rest> : never : never : T;
+export type InvalidateConfig = {
+    key: Record<string, string>;
+    ref: string;
+};
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,42 @@
+import { Result } from './result';
+/**
+ * Recursively compares two values and indicates if they are equal.
+ *
+ * @param x first value
+ * @param y second value
+ * @returns true if x and y are recursively equal to each other; false if not
+ */
+export declare function deepEquals<T>(x: T, y: T): boolean;
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+/**
+ * Converts an arbitrary value to an Error.
+ *
+ * @param x anything
+ * @returns Error corresponding to x
+ */
+export declare function toError(x: any): Error;
+/**
+ * Deep copies a JSON object. Only works for non-complex values.
+ * No Date or Functions etc.
+ */
+export declare function deepCopy<T>(x: T): T | undefined;
+/**
+ * Transforms a ReadableStream in to an AsyncIterable
+ *
+ * Allows consumption of a ReadableStream using for-await-of syntax.
+ * Ensures proper cleanup and error handling for all stream control paths.
+ *
+ * @param stream the ReadableStream to be transformed
+ * @returns Result<AsyncIterable<T>, Error> built from the provided ReadableStream
+ */
+export declare function readableStreamToAsyncIterable<T>(stream: ReadableStream<T>): Result<AsyncIterable<T>, Error>;

package/dist/types/version.d.ts

@@ -0,0 +1,17 @@
+export type Version = `${number}.${number}` | `${number}.${number}.${number}`;
+/**
+ * Indicates if a given instance of a service satisfies a request. Note that this function
+ * assumes the version numbers are valid strings.
+ *
+ * @param provided ServiceVersion of the service instance to be provided
+ * @param requested ServiceVersion requested
+ * @returns true if the service instance to be provided satisfies the request
+ */
+export declare function satisfies(provided: Version, requested: Version): boolean;
+/**
+ * Indicates if a string is valid as a version.
+ *
+ * @param s arbitrary string
+ * @returns true if s is a valid version string
+ */
+export declare function stringIsVersion(s: string): s is Version;

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "@conduit-client/utils",
+    "version": "2.0.0",
+    "description": "Luvio utils",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/luvio-next.git",
+        "directory": "packages/@conduit-client/utils"
+    },
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/types/index.d.ts",
+    "files": [
+        "dist/"
+    ],
+    "scripts": {
+        "build": "vite build && tsc --build --emitDeclarationOnly",
+        "clean": "rm -rf dist",
+        "test": "vitest run",
+        "test:size": "size-limit",
+        "watch": "npm run build --watch"
+    },
+    "volta": {
+        "extends": "../../../package.json"
+    },
+    "size-limit": [
+        {
+            "path": "./dist/index.js",
+            "limit": "5.2 kB"
+        }
+    ]
+}