@twin.org/core 0.0.1-next.1

package/dist/types/encoding/base32.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Class to help with base63 Encoding/Decoding.
+ */
+export declare class Base32 {
+    /**
+     * Convert the base 32 string to a byte array.
+     * @param base32 The base32 string to convert.
+     * @returns The byte array.
+     * @throws If the input string contains a character not in the Base32 alphabet.
+     */
+    static decode(base32: string): Uint8Array;
+    /**
+     * Convert a byte array to base 32.
+     * @param bytes The byte array to convert.
+     * @returns The data as base32 string.
+     */
+    static encode(bytes: Uint8Array): string;
+}

package/dist/types/encoding/base64.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Class to help with base64 Encoding/Decoding.
+ * Sourced from https://github.com/beatgammit/base64-js.
+ */
+export declare class Base64 {
+    /**
+     * Get the byte length of the data.
+     * @param base64 The base64 string.
+     * @returns The byte length of the data.
+     */
+    static byteLength(base64: string): number;
+    /**
+     * Convert the base 64 string to a byte array.
+     * @param base64 The base64 string to convert.
+     * @returns The byte array.
+     */
+    static decode(base64: string): Uint8Array;
+    /**
+     * Convert a byte array to base 64.
+     * @param bytes The byte array to convert.
+     * @returns The data as base64 string.
+     */
+    static encode(bytes: Uint8Array): string;
+}

package/dist/types/encoding/base64Url.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Class to help with base64 URL Encoding/Decoding.
+ * https://www.rfc-editor.org/rfc/rfc4648#section-5.
+ */
+export declare class Base64Url {
+    /**
+     * Convert the base 64 string to a byte array.
+     * @param base64Url The base64 url string to convert.
+     * @returns The byte array.
+     */
+    static decode(base64Url: string): Uint8Array;
+    /**
+     * Convert a byte array to base 64 url.
+     * @param bytes The byte array to convert.
+     * @returns The data as base64 url string.
+     */
+    static encode(bytes: Uint8Array): string;
+}

package/dist/types/errors/alreadyExistsError.d.ts

@@ -0,0 +1,18 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors which are triggered by data already existing.
+ */
+export declare class AlreadyExistsError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of AlreadyExistsError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param existingId The id for the item.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(source: string, message: string, existingId?: string, inner?: unknown);
+}

package/dist/types/errors/baseError.d.ts

@@ -0,0 +1,103 @@
+import type { IError } from "../models/IError";
+/**
+ * Class to handle errors.
+ */
+export declare class BaseError extends Error implements IError {
+    /**
+     * The source of the error.
+     */
+    source?: string;
+    /**
+     * Any additional information for the error.
+     */
+    properties?: {
+        [id: string]: unknown;
+    };
+    /**
+     * The inner error if there was one.
+     */
+    inner?: IError;
+    /**
+     * Create a new instance of BaseError.
+     * @param name The name of the error.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param properties Any additional information for the error.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(name: string, source: string, message: string, properties?: {
+        [id: string]: unknown;
+    }, inner?: unknown);
+    /**
+     * Construct an error from an existing one.
+     * @param err The existing error.
+     * @returns The new instance.
+     */
+    static fromError(err: unknown): BaseError;
+    /**
+     * Flatten an error tree.
+     * @param err The starting error.
+     * @returns The list of all internal errors.
+     */
+    static flatten(err: unknown): IError[];
+    /**
+     * Expand an error tree.
+     * @param errors The list of errors to expand.
+     * @returns The first level error.
+     */
+    static expand(errors: IError[] | undefined): IError | undefined;
+    /**
+     * Test to see if the error has the specified error name.
+     * @param error The error to test.
+     * @param name The name to check for.
+     * @returns True if the error has the name.
+     */
+    static isErrorName(error: unknown, name: string | RegExp): error is BaseError;
+    /**
+     * Test to see if the error has the specified error message.
+     * @param error The error to test.
+     * @param message The message to check for.
+     * @returns True if the error has the name.
+     */
+    static isErrorMessage(error: unknown, message: string | RegExp): error is BaseError;
+    /**
+     * Test to see if the error has the specified error code.
+     * @param error The error to test.
+     * @param code The code to check for.
+     * @returns True if the error has the code.
+     */
+    static isErrorCode(error: unknown, code: string | RegExp): boolean;
+    /**
+     * Test to see if any of the errors or children have the given error name.
+     * @param error The error to test.
+     * @param name The name to check for.
+     * @returns True if the error has the name.
+     */
+    static someErrorName(error: unknown, name: string | RegExp): error is BaseError;
+    /**
+     * Test to see if any of the errors or children have the given error message.
+     * @param error The error to test.
+     * @param message The message to check for.
+     * @returns True if the error has the name.
+     */
+    static someErrorMessage(error: unknown, message: string | RegExp): error is BaseError;
+    /**
+     * Test to see if any of the errors or children are from a specific class.
+     * @param error The error to test.
+     * @param cls The class to check for.
+     * @returns True if the error has the specific class.
+     */
+    static someErrorClass(error: unknown, cls: string): error is BaseError;
+    /**
+     * Test to see if any of the errors or children have the given error code.
+     * @param error The error to test.
+     * @param code The code to check for.
+     * @returns True if the error has the name.
+     */
+    static someErrorCode(error: unknown, code: string | RegExp): error is BaseError;
+    /**
+     * Serialize the error to the error model.
+     * @returns The error model.
+     */
+    toJsonObject(): IError;
+}

package/dist/types/errors/conflictError.d.ts

@@ -0,0 +1,19 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors which are triggered by conflicting data.
+ */
+export declare class ConflictError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of ConflictError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param conflictId The id that has conflicts.
+     * @param conflicts The conflicts that occurred.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(source: string, message: string, conflictId?: string, conflicts?: string[], inner?: unknown);
+}

package/dist/types/errors/generalError.d.ts

@@ -0,0 +1,20 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors.
+ */
+export declare class GeneralError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of GeneralError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param properties Any additional information for the error.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(source: string, message: string, properties?: {
+        [id: string]: unknown;
+    }, inner?: unknown);
+}

package/dist/types/errors/guardError.d.ts

@@ -0,0 +1,19 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors which are triggered by data guards.
+ */
+export declare class GuardError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of GuardError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param propertyName The property which triggered the guard error for the item.
+     * @param propertyValue The property value which triggered the guard error for the item.
+     * @param propertyOptions The property options which might be allowed.
+     */
+    constructor(source: string, message: string, propertyName: string, propertyValue: unknown, propertyOptions?: string);
+}

package/dist/types/errors/notFoundError.d.ts

@@ -0,0 +1,18 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors which are triggered by data not being found.
+ */
+export declare class NotFoundError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of NotFoundError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param notFoundId The id for the item.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(source: string, message: string, notFoundId?: string, inner?: unknown);
+}

package/dist/types/errors/notImplementedError.d.ts

@@ -0,0 +1,16 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors.
+ */
+export declare class NotImplementedError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of NotImplementedError.
+     * @param source The source of the error.
+     * @param method The method for the error.
+     */
+    constructor(source: string, method: string);
+}

package/dist/types/errors/notSupportedError.d.ts

@@ -0,0 +1,17 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors when a feature is unsupported.
+ */
+export declare class NotSupportedError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of NotSupportedError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(source: string, message: string, inner?: unknown);
+}

package/dist/types/errors/unauthorizedError.d.ts

@@ -0,0 +1,17 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors which are triggered by access not being unauthorized.
+ */
+export declare class UnauthorizedError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of UnauthorizedError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(source: string, message: string, inner?: unknown);
+}

package/dist/types/errors/unprocessableError.d.ts

@@ -0,0 +1,20 @@
+import { BaseError } from "./baseError";
+/**
+ * Class to handle errors when some data can not be processed.
+ */
+export declare class UnprocessableError extends BaseError {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of UnprocessableError.
+     * @param source The source of the error.
+     * @param message The message as a code.
+     * @param properties Any additional information for the error.
+     * @param inner The inner error if we have wrapped another error.
+     */
+    constructor(source: string, message: string, properties?: {
+        [id: string]: unknown;
+    }, inner?: unknown);
+}

package/dist/types/errors/validationError.d.ts

@@ -0,0 +1,18 @@
+import { BaseError } from "./baseError";
+import type { IValidationFailure } from "../models/IValidationFailure";
+/**
+ * Class to handle errors which are triggered by entity validation.
+ */
+export declare class ValidationError extends BaseError {
+    /**
+     * Runtime name for the class.s
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of ValidationError.
+     * @param source The source of the error.
+     * @param validationObject The object that failed validation.
+     * @param validationFailures The validation failures.
+     */
+    constructor(source: string, validationObject: string, validationFailures: IValidationFailure[]);
+}

package/dist/types/factories/componentFactory.d.ts

@@ -0,0 +1,6 @@
+import { Factory } from "./factory";
+import type { IComponent } from "../models/IComponent";
+/**
+ * Factory for creating implementation of component types.
+ */
+export declare const ComponentFactory: Factory<IComponent>;

package/dist/types/factories/factory.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Factory for creating implementation of generic types.
+ */
+export declare class Factory<T> {
+    /**
+     * Create a new factory, which is shared throughout all library instances.
+     * @param typeName The type name for the instances.
+     * @param autoInstance Automatically create an instance when registered.
+     * @param matcher Match the name of the instance.
+     * @returns The factory instance.
+     */
+    static createFactory<U>(typeName: string, autoInstance?: boolean, matcher?: (names: string[], name: string) => string | undefined): Factory<U>;
+    /**
+     * Register a new generator.
+     * @param name The name of the generator.
+     * @param generator The function to create an instance.
+     */
+    register<U extends T>(name: string, generator: () => U): void;
+    /**
+     * Unregister a generator.
+     * @param name The name of the generator to unregister.
+     * @throws GuardError if the parameters are invalid.
+     * @throws GeneralError if no generator exists.
+     */
+    unregister(name: string): void;
+    /**
+     * Get a generator instance.
+     * @param name The name of the instance to generate.
+     * @returns An instance of the item.
+     * @throws GuardError if the parameters are invalid.
+     * @throws GeneralError if no item exists to get.
+     */
+    get<U extends T>(name: string): U;
+    /**
+     * Get a generator instance with no exceptions.
+     * @param name The name of the instance to generate.
+     * @returns An instance of the item or undefined if it does not exist.
+     */
+    getIfExists<U extends T>(name: string): U | undefined;
+    /**
+     * Reset all the instances.
+     */
+    reset(): void;
+    /**
+     * Get all the instances as a map.
+     * @returns The instances as a map.
+     */
+    instancesMap(): {
+        [name: string]: T;
+    };
+    /**
+     * Get all the instances as a list in the order they were registered.
+     * @returns The instances as a list in the order they were registered.
+     */
+    instancesList(): T[];
+    /**
+     * Get all the generator names in the order they were registered.
+     * @returns The ordered generator names.
+     */
+    names(): string[];
+    /**
+     * Does the factory contain the name.
+     * @param name The name of the instance to find.
+     * @returns True if the factory has a matching name.
+     */
+    hasName(name: string): boolean;
+}

package/dist/types/helpers/arrayHelper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Class to help with arrays.
+ */
+export declare class ArrayHelper {
+    /**
+     * Do the two arrays match.
+     * @param arr1 The first array.
+     * @param arr2 The second array.
+     * @returns True if both arrays are empty of have the same values.
+     */
+    static matches(arr1: unknown, arr2: unknown): boolean;
+}

package/dist/types/helpers/errorHelper.d.ts

@@ -0,0 +1,24 @@
+import type { IError } from "../models/IError";
+/**
+ * Error helper functions.
+ */
+export declare class ErrorHelper {
+    /**
+     * Format Errors and returns just their messages.
+     * @param error The error to format.
+     * @returns The error formatted including any inner errors.
+     */
+    static formatErrors(error: unknown): string[];
+    /**
+     * Localize the content of an error and any inner errors.
+     * @param error The error to format.
+     * @returns The localized version of the errors flattened.
+     */
+    static localizeErrors(error: unknown): IError[];
+    /**
+     * Localize the content of an error and any inner errors.
+     * @param error The error to format.
+     * @returns The localized version of the errors flattened.
+     */
+    static formatValidationErrors(error: IError): string | undefined;
+}

package/dist/types/helpers/filenameHelper.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Class to help with filenames.
+ */
+export declare class FilenameHelper {
+    /**
+     * Replaces any unsafe characters in the filename.
+     * @param filename The filename to make safe.
+     * @returns The safe filename.
+     */
+    static safeFilename(filename: unknown): string;
+}

package/dist/types/helpers/hexHelper.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Helper methods for hex conversions.
+ */
+export declare class HexHelper {
+    /**
+     * Strip the 0x prefix if it exists.
+     * @param hex The hex value to strip.
+     * @returns The stripped hex without the prefix.
+     */
+    static stripPrefix(hex: string): string;
+    /**
+     * Add the 0x prefix if it does not exist.
+     * @param hex The hex value to add the prefix to.
+     * @returns The hex with the prefix.
+     */
+    static addPrefix(hex: string): string;
+    /**
+     * Does the hex string have the prefix.
+     * @param hex The hex value to check for the prefix.
+     * @returns True if the hex string has the prefix.
+     */
+    static hasPrefix(hex: string): boolean;
+    /**
+     * Is the data hex format.
+     * @param value The value to test.
+     * @param allowPrefix Allow the hex to have the 0x prefix.
+     * @returns True if the string is hex.
+     */
+    static isHex(value: string, allowPrefix?: boolean): boolean;
+}

package/dist/types/helpers/jsonHelper.d.ts

@@ -0,0 +1,29 @@
+import type { IPatchOperation } from "../models/IPatchOperation";
+/**
+ * Helpers methods for JSON objects.
+ */
+export declare class JsonHelper {
+    /**
+     * Serializes in canonical format.
+     * Based on https://www.rfc-editor.org/rfc/rfc8785.
+     * @param object The object to be serialized.
+     * @returns The serialized object.
+     */
+    static canonicalize(object: unknown): string;
+    /**
+     * Creates a RFC 6902 diff set.
+     * Based on https://www.rfc-editor.org/rfc/rfc6902.
+     * @param object1 The first object.
+     * @param object2 The second object.
+     * @returns The list of patches.
+     */
+    static diff<T = unknown>(object1: T, object2: T): IPatchOperation[];
+    /**
+     * Applies a RFC 6902 diff set to an object.
+     * Based on https://www.rfc-editor.org/rfc/rfc6902.
+     * @param object The object to patch.
+     * @param patches The second object.
+     * @returns The updated object.
+     */
+    static patch<T = unknown>(object: T, patches: IPatchOperation[]): T;
+}

package/dist/types/helpers/objectHelper.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Class to help with objects.
+ */
+export declare class ObjectHelper {
+    /**
+     * Convert an object to bytes.
+     * @param obj The object to convert.
+     * @param format Format the JSON content.
+     * @returns The object as bytes.
+     */
+    static toBytes<T>(obj: T | undefined, format?: boolean): Uint8Array;
+    /**
+     * Convert a bytes to an object.
+     * @param bytes The bytes to convert to an object.
+     * @returns The object.
+     * @throws GeneralError if there was an error parsing the JSON.
+     */
+    static fromBytes<T>(bytes: Uint8Array | undefined | null): T;
+    /**
+     * Make a deep clone of an object.
+     * @param obj The object to clone.
+     * @returns The objects clone.
+     */
+    static clone<T>(obj: T): T;
+    /**
+     * Deep merge objects.
+     * @param obj1 The first object to merge.
+     * @param obj2 The second object to merge.
+     * @returns The combined deep merge of the objects.
+     */
+    static merge<T = unknown, U = unknown>(obj1: T, obj2: U): T & U;
+    /**
+     * Does one object equal another.
+     * @param obj1 The first object to compare.
+     * @param obj2 The second object to compare.
+     * @param strictPropertyOrder Should the properties be in the same order, defaults to true.
+     * @returns True is the objects are equal.
+     */
+    static equal<T>(obj1: T, obj2: T, strictPropertyOrder?: boolean): boolean;
+    /**
+     * Get the property of an unknown object.
+     * @param obj The object to get the property from.
+     * @param property The property to get, can be separated by dots for nested path.
+     * @returns The property.
+     */
+    static propertyGet<T = unknown>(obj: unknown, property: string): T | undefined;
+    /**
+     * Set the property of an unknown object.
+     * @param obj The object to set the property from.
+     * @param property The property to set.
+     * @param value The value to set.
+     */
+    static propertySet(obj: unknown, property: string, value: unknown): void;
+    /**
+     * Delete the property of an unknown object.
+     * @param obj The object to set the property from.
+     * @param property The property to set
+     */
+    static propertyDelete(obj: unknown, property: string): void;
+    /**
+     * Pick a subset of properties from an object.
+     * @param obj The object to pick the properties from.
+     * @param keys The property keys to pick.
+     * @returns The partial object.
+     */
+    static pick<T>(obj: T | undefined, keys?: (keyof T)[]): Partial<T>;
+    /**
+     * Omit a subset of properties from an object.
+     * @param obj The object to omit the properties from.
+     * @param keys The property keys to omit.
+     * @returns The partial object.
+     */
+    static omit<T>(obj: T | undefined, keys?: (keyof T)[]): Partial<T>;
+}

package/dist/types/helpers/randomHelper.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Class to help with random generation.
+ */
+export declare class RandomHelper {
+    /**
+     * Generate a new random array.
+     * @param length The length of buffer to create.
+     * @returns The random array.
+     */
+    static generate(length: number): Uint8Array;
+}