@streamscloud/kit 0.0.1-1770364570820

package/dist/core/utils/url-helper.js

@@ -0,0 +1,13 @@
+export class UrlHelper {
+    static getRootDomain(url) {
+        let tokens = url.hostname.split('.');
+        if (tokens.length <= 2) {
+            return url.hostname;
+        }
+        tokens = tokens.slice(-3);
+        if (['co', 'com', 'org', 'net', 'gov', 'edu', 'ac'].includes(tokens[1])) {
+            return tokens.join('.');
+        }
+        return tokens.slice(-2).join('.');
+    }
+}

package/dist/core/utils/utils.d.ts

@@ -0,0 +1,29 @@
+export declare class Utils {
+    static areEqual(value: unknown, other: unknown): boolean;
+    static assertUnreachable(_x: never): never;
+    static clone<T>(value: T): T;
+    /**
+     * Find the greatest common divisor of 2 numbers
+     */
+    static gcd(a: number, b: number): number;
+    /**
+     * Find the least dividend and divisor by given quotient
+     */
+    static ldd(quotient: number, divisorLimit?: number): {
+        dividend: number;
+        divisor: number;
+    } | null;
+    /**
+     * Returns a function, that, as long as it continues to be invoked, will not
+     * be triggered. The function will be called after it stops being called for
+     * N milliseconds.
+     */
+    static debounce(func: (...args: any[]) => void, wait: number): (...args: unknown[]) => void;
+    static throttle<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => ReturnType<T>;
+    static sleep: (ms: number) => Promise<unknown>;
+    static poll: <T>(fn: () => Promise<T>, continueWhileTrueFn: (input: T) => boolean, ms?: number) => Promise<T>;
+    static nameof: <T>(name: keyof T) => keyof T;
+    static unsubscribe(sub: UnsubscribeMethod | UnsubscribeMethod[] | null | undefined): void;
+}
+export type Without<T, K> = Pick<T, Exclude<keyof T, K>>;
+export type UnsubscribeMethod = () => void;

package/dist/core/utils/utils.js

@@ -0,0 +1,108 @@
+import { dequal as isEqual } from 'dequal/lite';
+import rfdc from 'rfdc';
+export class Utils {
+    static areEqual(value, other) {
+        return isEqual(value, other);
+    }
+    static assertUnreachable(_x) {
+        return undefined;
+    }
+    static clone(value) {
+        return rfdc()(value);
+    }
+    /**
+     * Find the greatest common divisor of 2 numbers
+     */
+    static gcd(a, b) {
+        a = Math.abs(a);
+        b = Math.abs(b);
+        if (b > a) {
+            const temp = a;
+            a = b;
+            b = temp;
+        }
+        while (true) {
+            if (b === 0) {
+                return a;
+            }
+            a %= b;
+            if (a === 0) {
+                return b;
+            }
+            b %= a;
+        }
+    }
+    /**
+     * Find the least dividend and divisor by given quotient
+     */
+    static ldd(quotient, divisorLimit = 1000000) {
+        let divisor = 1;
+        while (divisor <= divisorLimit) {
+            const dividend = quotient * divisor;
+            if (dividend % 1 === 0) {
+                return { dividend, divisor };
+            }
+            divisor++;
+        }
+        return null;
+    }
+    /**
+     * Returns a function, that, as long as it continues to be invoked, will not
+     * be triggered. The function will be called after it stops being called for
+     * N milliseconds.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static debounce(func, wait) {
+        let timeout;
+        return (...args) => {
+            const later = () => {
+                func.apply(this, args);
+            };
+            clearTimeout(timeout);
+            timeout = window.setTimeout(later, wait);
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static throttle(func, wait) {
+        // Capture the current time
+        let time = Date.now() - wait;
+        return (...args) => {
+            if (time + wait - Date.now() <= 0) {
+                time = Date.now();
+                // Run the function we've passed to our throttler,
+                // and reset the `time` variable (so we can check again).
+                return func.apply(this, args);
+            }
+            return null;
+        };
+    }
+    static sleep = async (ms) => {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    };
+    static poll = async (fn, continueWhileTrueFn, ms = 1000) => {
+        let result = await fn();
+        while (continueWhileTrueFn(result)) {
+            await Utils.sleep(ms);
+            result = await fn();
+        }
+        return result;
+    };
+    static nameof = (name) => name;
+    static unsubscribe(sub) {
+        if (!sub) {
+            return;
+        }
+        const unsubscribeSingle = (sub) => {
+            if (!sub) {
+                return;
+            }
+            sub();
+        };
+        if (sub instanceof Array) {
+            sub.forEach(unsubscribeSingle);
+        }
+        else {
+            unsubscribeSingle(sub);
+        }
+    }
+}

package/dist/core/validation/form-validation-handler/form-validation-handler.svelte.d.ts

@@ -0,0 +1,47 @@
+import type { IValidator } from '../i-validator';
+import type { IFormHandlerValidator } from './types';
+type TypeToValidate<T> = {
+    [K in keyof T]: T[K];
+};
+export declare class FormValidationHandler<T extends TypeToValidate<T> = TypeToValidate<unknown>, TSubmitResult = void> implements IValidator {
+    readonly formStringified: Record<string, string>;
+    readonly modified: Record<keyof T, boolean>;
+    readonly isValid: boolean;
+    readonly isModified: boolean;
+    private _form;
+    private _errors;
+    private _touched;
+    private _isValidating;
+    private _isSubmitting;
+    private _validator;
+    private _initialValues;
+    private readonly _onSubmit;
+    private readonly _onReset;
+    private _initials;
+    constructor(context: {
+        initialValues: T;
+        validator: IFormHandlerValidator<T>;
+        onSubmit?: (values: T) => TSubmitResult;
+        onReset?: () => void;
+    });
+    get form(): T;
+    get errors(): { [P in keyof Partial<T>]: string; };
+    get touched(): Record<keyof T, boolean>;
+    get isValidating(): boolean;
+    get isSubmitting(): boolean;
+    updateField: <K extends keyof T>(field: K, value: T[K]) => void;
+    updateValidateField: <K extends keyof T>(field: K, value: T[K]) => Promise<void>;
+    updateTouched: (field: keyof T, value: boolean) => void;
+    updateTouchedForAllFields: (value: boolean) => void;
+    validateField: (field: keyof T) => Promise<void>;
+    updateInitialValues: (newValues: T) => void;
+    updateValidator: (validator: IFormHandlerValidator<T>) => void;
+    handleReset: () => void;
+    handleInputValueChanged: (event: Event) => Promise<void>;
+    validate: (values?: T) => Promise<boolean>;
+    handleSubmit: (event: Event | null) => Promise<void>;
+    dispose(): void;
+    private validateFieldValue;
+    private stringify;
+}
+export {};

package/dist/core/validation/form-validation-handler/form-validation-handler.svelte.js

@@ -0,0 +1,182 @@
+import { Utils } from '../../utils';
+import { dequal as isEqual } from 'dequal/lite';
+const NO_ERROR = '';
+export class FormValidationHandler {
+    formStringified = $derived.by(() => {
+        if (!this.form) {
+            return {};
+        }
+        return Object.entries(this.form).reduce((acc, [key, value]) => ({ ...acc, [key]: this.stringify(value) }), {});
+    });
+    modified = $derived.by(() => {
+        if (!this.form) {
+            return null;
+        }
+        const object = ValidationUtils.assignDeep(this.form, false);
+        for (const key in this.form) {
+            object[key] = !isEqual(this.form[key], this._initialValues[key]);
+        }
+        return object;
+    });
+    isValid = $derived(ValidationUtils.getValues(this.errors).every((field) => field === NO_ERROR));
+    isModified = $derived.by(() => {
+        return ValidationUtils.getValues(this.modified).includes(true);
+    });
+    _form = $state(null);
+    _errors = $state(null);
+    _touched = $state(null);
+    _isValidating = $state(false);
+    _isSubmitting = $state(false);
+    _validator;
+    _initialValues = $state(null);
+    _onSubmit;
+    _onReset;
+    _initials = {
+        values: () => Utils.clone(this._initialValues),
+        errors: () => ValidationUtils.assignDeep(this._initialValues, NO_ERROR),
+        touched: () => ValidationUtils.assignDeep(this._initialValues, false)
+    };
+    constructor(context) {
+        this._initialValues = context.initialValues || {};
+        this._onSubmit = context.onSubmit ? context.onSubmit : () => ({});
+        this._onReset = context.onReset ? context.onReset : () => ({});
+        this._validator = context.validator;
+        this._form = this._initials.values();
+        this._errors = this._initials.errors();
+        this._touched = this._initials.touched();
+    }
+    get form() {
+        return this._form;
+    }
+    get errors() {
+        return this._errors;
+    }
+    get touched() {
+        return this._touched;
+    }
+    get isValidating() {
+        return this._isValidating;
+    }
+    get isSubmitting() {
+        return this._isSubmitting;
+    }
+    updateField = (field, value) => {
+        ValidationUtils.update(this._form, field, value);
+    };
+    updateValidateField = async (field, value) => {
+        this.updateField(field, value);
+        await this.validateFieldValue(field);
+    };
+    updateTouched = (field, value) => {
+        ValidationUtils.update(this._touched, field, value);
+    };
+    updateTouchedForAllFields = (value) => {
+        Object.keys(this._initialValues).forEach((key) => {
+            ValidationUtils.update(this._touched, key, value);
+        });
+    };
+    validateField = async (field) => {
+        return await this.validateFieldValue(field);
+    };
+    updateInitialValues = (newValues) => {
+        this._initialValues = newValues;
+        this.handleReset();
+    };
+    updateValidator = (validator) => {
+        this._validator = validator;
+        this.handleReset();
+    };
+    handleReset = () => {
+        this._form = this._initials.values();
+        this._errors = this._initials.errors();
+        this._touched = this._initials.touched();
+        this._onReset();
+    };
+    handleInputValueChanged = (event) => {
+        const element = event.target;
+        const field = (element.name || element.id);
+        const resolveValue = () => {
+            if (element.getAttribute && element.getAttribute('type') === 'file') {
+                return element.files;
+            }
+            else if (element.getAttribute && element.getAttribute('type') === 'checkbox') {
+                return element.checked;
+            }
+            else {
+                return element.value;
+            }
+        };
+        const value = resolveValue();
+        return this.updateValidateField(field, value);
+    };
+    validate = async (values) => {
+        this.updateTouchedForAllFields(true);
+        values = values || this.form;
+        this._isValidating = true;
+        const result = await this._validator.validate(values);
+        this._errors = result.errors;
+        this._isValidating = false;
+        return result.isValid;
+    };
+    handleSubmit = async (event) => {
+        if (event && event.preventDefault) {
+            event.preventDefault();
+        }
+        try {
+            this._isSubmitting = true;
+            const values = this.form;
+            const isValid = await this.validate(values);
+            if (!isValid) {
+                this._isSubmitting = false;
+                return;
+            }
+            this._errors = this._initials.errors();
+            await this._onSubmit(values);
+        }
+        finally {
+            this._isSubmitting = false;
+        }
+    };
+    dispose() {
+        // do nothing
+    }
+    validateFieldValue = async (field) => {
+        this.updateTouched(field, true);
+        this._isValidating = true;
+        const error = await this._validator.validateAt(this._form, field);
+        ValidationUtils.update(this.errors, field, error || '');
+        this._isValidating = false;
+    };
+    stringify = (value) => {
+        if (typeof value !== 'number' && !value) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        return JSON.stringify(value);
+    };
+}
+class ValidationUtils {
+    static update = (object, path, value) => {
+        ValidationUtils.set(object, path, value);
+    };
+    static getValues = (object) => {
+        const results = [];
+        for (const [, value] of Object.entries(object)) {
+            results.push(value);
+        }
+        return results;
+    };
+    static assignDeep(object, value) {
+        const copy = {};
+        for (const key in object) {
+            copy[key] = value;
+        }
+        return copy;
+    }
+    static set(object, path, value) {
+        object[path] = value;
+        return object;
+    }
+}

package/dist/core/validation/form-validation-handler/index.d.ts

@@ -0,0 +1,4 @@
+export { FormValidationHandler } from './form-validation-handler.svelte';
+export type { FormValidateResult, IFormHandlerValidator } from './types';
+export { StubFormValidator } from './stub-form-validator';
+export { YupFormValidator } from './yup-form-validator';

package/dist/core/validation/form-validation-handler/index.js

@@ -0,0 +1,3 @@
+export { FormValidationHandler } from './form-validation-handler.svelte';
+export { StubFormValidator } from './stub-form-validator';
+export { YupFormValidator } from './yup-form-validator';

package/dist/core/validation/form-validation-handler/stub-form-validator.d.ts

@@ -0,0 +1,5 @@
+import type { FormValidateResult, IFormHandlerValidator } from './types';
+export declare class StubFormValidator<T> implements IFormHandlerValidator<T> {
+    validate: () => Promise<FormValidateResult<T>>;
+    validateAt: () => Promise<string | null>;
+}

package/dist/core/validation/form-validation-handler/stub-form-validator.js

@@ -0,0 +1,12 @@
+export class StubFormValidator {
+    validate = async () => {
+        const errors = {};
+        return {
+            isValid: true,
+            errors
+        };
+    };
+    validateAt = async () => {
+        return null;
+    };
+}

package/dist/core/validation/form-validation-handler/types.d.ts

@@ -0,0 +1,10 @@
+export type IFormHandlerValidator<T> = {
+    validate: (obj: T) => Promise<FormValidateResult<Partial<T>>>;
+    validateAt: (obj: T, field: keyof T) => Promise<string | null>;
+};
+export type FormValidateResult<T> = {
+    isValid: boolean;
+    errors: {
+        [P in keyof T]: string;
+    };
+};

package/dist/core/validation/form-validation-handler/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/validation/form-validation-handler/yup-form-validator.d.ts

@@ -0,0 +1,11 @@
+import type { FormValidateResult, IFormHandlerValidator } from './types';
+import type { ObjectSchema } from 'yup';
+export declare class YupFormValidator<T> implements IFormHandlerValidator<T> {
+    private validationSchema;
+    private validationOptions;
+    constructor(validationSchema: ObjectSchema<Partial<T>>, validationOptions?: {
+        trimErrorPath: boolean;
+    });
+    validate: (obj: T) => Promise<FormValidateResult<Partial<T>>>;
+    validateAt: (obj: T, field: keyof T) => Promise<string | null>;
+}

package/dist/core/validation/form-validation-handler/yup-form-validator.js

@@ -0,0 +1,49 @@
+export class YupFormValidator {
+    validationSchema;
+    validationOptions;
+    constructor(validationSchema, validationOptions = { trimErrorPath: true }) {
+        this.validationSchema = validationSchema;
+        this.validationOptions = validationOptions;
+    }
+    validate = async (obj) => {
+        const errors = {};
+        try {
+            await this.validationSchema.validate(obj, { abortEarly: false });
+            return {
+                isValid: true,
+                errors
+            };
+        }
+        catch (error) {
+            const yupErrors = error;
+            if (yupErrors && yupErrors.inner) {
+                const updatedPathMap = {};
+                yupErrors.inner.forEach((e) => {
+                    if (!e.path) {
+                        return;
+                    }
+                    if (updatedPathMap[e.path]) {
+                        return;
+                    }
+                    const errorPath = this.validationOptions.trimErrorPath ? e.path.split('.')[0] : e.path;
+                    errors[errorPath] = e.message;
+                    updatedPathMap[e.path] = true;
+                });
+            }
+            return {
+                isValid: false,
+                errors
+            };
+        }
+    };
+    validateAt = async (obj, field) => {
+        try {
+            await this.validationSchema.validateAt(field, obj);
+            return null;
+        }
+        catch (e) {
+            const error = e;
+            return error.message;
+        }
+    };
+}

package/dist/core/validation/form-validator.svelte.d.ts

@@ -0,0 +1,12 @@
+import { FormValidationHandler } from './form-validation-handler';
+import type { IValidator } from './i-validator';
+export declare class FormValidator<T> implements IValidator {
+    private _formHandler;
+    private _isValid;
+    private _isModified;
+    constructor(formHandler: FormValidationHandler<T>);
+    get isValid(): boolean;
+    get isModified(): boolean;
+    dispose(): void;
+    validate(): Promise<boolean>;
+}

package/dist/core/validation/form-validator.svelte.js

@@ -0,0 +1,21 @@
+import { FormValidationHandler } from './form-validation-handler';
+export class FormValidator {
+    _formHandler = $state.raw(null);
+    _isValid = $derived(!!this._formHandler && this._formHandler.isValid);
+    _isModified = $derived(!!this._formHandler && this._formHandler.isModified);
+    constructor(formHandler) {
+        this._formHandler = formHandler;
+    }
+    get isValid() {
+        return this._isValid;
+    }
+    get isModified() {
+        return this._isModified;
+    }
+    dispose() {
+        // do nothing
+    }
+    async validate() {
+        return await this._formHandler.validate();
+    }
+}

package/dist/core/validation/i-validator.d.ts

@@ -0,0 +1,6 @@
+export interface IValidator {
+    isValid: boolean;
+    isModified: boolean;
+    validate: () => Promise<boolean>;
+    dispose: () => void;
+}

package/dist/core/validation/i-validator.js

@@ -0,0 +1 @@
+export {};

package/dist/core/validation/index.d.ts

@@ -0,0 +1,5 @@
+export type { IValidator } from './i-validator';
+export * from './form-validation-handler';
+export { ValidatorsHub } from './validators-hub.svelte';
+export { FormValidator } from './form-validator.svelte';
+export * from './validation-schemas';

package/dist/core/validation/index.js

@@ -0,0 +1,4 @@
+export * from './form-validation-handler';
+export { ValidatorsHub } from './validators-hub.svelte';
+export { FormValidator } from './form-validator.svelte';
+export * from './validation-schemas';

package/dist/core/validation/validation-schemas/email-validation.d.ts

@@ -0,0 +1,3 @@
+import * as yup from 'yup';
+export declare const emailValidationSchema: () => yup.StringSchema<string, yup.AnyObject, undefined, "">;
+export declare const nullableEmailValidationSchema: () => yup.StringSchema<string | null | undefined, yup.AnyObject, undefined, "">;

package/dist/core/validation/validation-schemas/email-validation.js

@@ -0,0 +1,17 @@
+import { getValidationMessages } from './validation-messages';
+import * as yup from 'yup';
+const EMAIL_REGEX = /^[a-zA-Z0-9_]([.+-]?[a-zA-Z0-9_])+@[a-zA-Z0-9]([.-]?[a-zA-Z0-9])+\.[a-zA-Z]{2,}$/;
+export const emailValidationSchema = () => {
+    const msg = getValidationMessages();
+    return yup.string().required(msg.required).matches(EMAIL_REGEX, {
+        excludeEmptyString: true,
+        message: msg.email
+    });
+};
+export const nullableEmailValidationSchema = () => {
+    const msg = getValidationMessages();
+    return yup.string().nullable().matches(EMAIL_REGEX, {
+        excludeEmptyString: true,
+        message: msg.email
+    });
+};

package/dist/core/validation/validation-schemas/handle-validations.d.ts

@@ -0,0 +1,3 @@
+import type { TextValidation } from './types';
+import * as yup from 'yup';
+export declare const handleValidationSchema: (lengthValidation?: TextValidation) => yup.StringSchema<string, yup.AnyObject, undefined, "">;

package/dist/core/validation/validation-schemas/handle-validations.js

@@ -0,0 +1,16 @@
+import { getValidationMessages } from './validation-messages';
+import * as yup from 'yup';
+const DEFAULT_MIN_LENGTH = 3;
+const DEFAULT_MAX_LENGTH = 30;
+const HANDLE_REGEX = /^[a-z_]([a-z0-9_]|[.-](?![.-]))*[a-z0-9_]$/;
+export const handleValidationSchema = (lengthValidation) => {
+    const msg = getValidationMessages();
+    const minLength = lengthValidation?.minLength ?? DEFAULT_MIN_LENGTH;
+    const maxLength = lengthValidation?.maxLength ?? DEFAULT_MAX_LENGTH;
+    return yup
+        .string()
+        .required(msg.required)
+        .min(minLength, msg.minLength(minLength))
+        .max(maxLength, msg.maxLength(maxLength))
+        .test('handle-format', msg.badFormat, (val) => !!val && HANDLE_REGEX.test(val));
+};

package/dist/core/validation/validation-schemas/index.d.ts

@@ -0,0 +1,6 @@
+export type { TextValidation, TextWithFormatValidation, NumberValidation, MinNumberValidation } from './types';
+export { setValidationMessages } from './validation-messages';
+export { emailValidationSchema, nullableEmailValidationSchema } from './email-validation';
+export { textValidationSchema, formattedTextValidationSchema } from './text-validations';
+export { handleValidationSchema } from './handle-validations';
+export { numberValidationSchema, minNumberValidationSchema } from './number-validations';

package/dist/core/validation/validation-schemas/index.js

@@ -0,0 +1,5 @@
+export { setValidationMessages } from './validation-messages';
+export { emailValidationSchema, nullableEmailValidationSchema } from './email-validation';
+export { textValidationSchema, formattedTextValidationSchema } from './text-validations';
+export { handleValidationSchema } from './handle-validations';
+export { numberValidationSchema, minNumberValidationSchema } from './number-validations';

package/dist/core/validation/validation-schemas/number-validations.d.ts

@@ -0,0 +1,4 @@
+import type { MinNumberValidation, NumberValidation } from './types';
+import * as yup from 'yup';
+export declare const numberValidationSchema: (rules: NumberValidation) => yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;
+export declare const minNumberValidationSchema: (rules: MinNumberValidation) => yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;

package/dist/core/validation/validation-schemas/number-validations.js

@@ -0,0 +1,30 @@
+import { getValidationMessages } from './validation-messages';
+import * as yup from 'yup';
+export const numberValidationSchema = (rules) => {
+    const msg = getValidationMessages();
+    let schema = yup.number().typeError(msg.badFormat);
+    if (rules.isRequired) {
+        schema = schema.required(msg.required);
+    }
+    if (rules.minValue !== null) {
+        const minValue = rules.minExclusive ? rules.minValue + 1 : rules.minValue;
+        schema = schema.min(minValue, msg.min(minValue));
+    }
+    if (rules.maxValue !== null) {
+        const maxValue = rules.maxExclusive ? rules.maxValue - 1 : rules.maxValue;
+        schema = schema.max(maxValue, msg.max(maxValue));
+    }
+    return schema;
+};
+export const minNumberValidationSchema = (rules) => {
+    const msg = getValidationMessages();
+    let schema = yup.number().typeError(msg.badFormat);
+    if (rules.isRequired) {
+        schema = schema.required(msg.required);
+    }
+    if (rules.minValue !== null) {
+        const minValue = rules.minExclusive ? rules.minValue + 1 : rules.minValue;
+        schema = schema.min(minValue, msg.min(minValue));
+    }
+    return schema;
+};

package/dist/core/validation/validation-schemas/text-validations.d.ts

@@ -0,0 +1,4 @@
+import type { TextValidation, TextWithFormatValidation } from './types';
+import * as yup from 'yup';
+export declare const textValidationSchema: (rules: TextValidation) => yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
+export declare const formattedTextValidationSchema: (rules: TextWithFormatValidation, fieldName: string, formatMessage?: string) => yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;