@streamscloud/kit 0.42.1 → 0.44.0

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

@@ -142,6 +142,9 @@ export class FormValidationHandler {
         if (event && event.preventDefault) {
             event.preventDefault();
         }
+        if (this._isSubmitting) {
+            return;
+        }
         try {
             this._isSubmitting = true;
             const values = this.form;

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

@@ -1,3 +1,5 @@
 import type { ArrayValidation } from './types';
 import * as yup from 'yup';
+/** Value-level rules of `arrayValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export declare const isValidArray: <TItem = unknown>(items: TItem[], rules: ArrayValidation) => boolean;
 export declare const arrayValidationSchema: <TItem = unknown>(rules: ArrayValidation) => yup.ArraySchema<TItem[] | undefined, yup.AnyObject, undefined, "">;

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

@@ -1,9 +1,18 @@
 import { ValidationLocalization } from './validation-localization';
 import * as yup from 'yup';
-export const arrayValidationSchema = (rules) => {
-    const msg = new ValidationLocalization();
+const resolveItemBounds = (rules) => {
     const minItems = rules.minItems > 0 ? rules.minItems : 0;
     const maxItems = rules.maxItems !== null && rules.maxItems >= 0 && rules.maxItems >= minItems ? rules.maxItems : undefined;
+    return { minItems, maxItems };
+};
+/** Value-level rules of `arrayValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export const isValidArray = (items, rules) => {
+    const { minItems, maxItems } = resolveItemBounds(rules);
+    return items.length >= minItems && (maxItems === undefined || items.length <= maxItems);
+};
+export const arrayValidationSchema = (rules) => {
+    const msg = new ValidationLocalization();
+    const { minItems, maxItems } = resolveItemBounds(rules);
     let schema = yup.array();
     if (maxItems !== undefined) {
         schema = schema.max(maxItems, msg.maxItems(maxItems));

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

@@ -1,3 +1,5 @@
 import * as yup from 'yup';
+/** The email format both email schemas check. Presence — empty, `null`, `undefined` — is decided by the schema the caller picks. */
+export declare const isValidEmail: (value: string) => boolean;
 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

@@ -1,6 +1,10 @@
 import { ValidationLocalization } from './validation-localization';
 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,}$/;
+const EMAIL_REGEX = /^[a-zA-Z0-9_]([.+-]?[a-zA-Z0-9_])*@[a-zA-Z0-9]([.-]?[a-zA-Z0-9])*\.[a-zA-Z]{2,}$/;
+/** The email format both email schemas check. Presence — empty, `null`, `undefined` — is decided by the schema the caller picks. */
+export const isValidEmail = (value) => {
+    return EMAIL_REGEX.test(value);
+};
 export const emailValidationSchema = () => {
     const msg = new ValidationLocalization();
     return yup.string().required(msg.required).matches(EMAIL_REGEX, {

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

@@ -1,3 +1,5 @@
 import type { TextValidation } from './types';
 import * as yup from 'yup';
+/** Value-level rules of `handleValidationSchema` — within length bounds and matching the handle format. */
+export declare const isValidHandle: (value: string, lengthValidation?: TextValidation) => boolean;
 export declare const handleValidationSchema: (lengthValidation?: TextValidation) => yup.StringSchema<string, yup.AnyObject, undefined, "">;

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

@@ -3,10 +3,18 @@ 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_]$/;
+const resolveHandleLength = (lengthValidation) => ({
+    minLength: lengthValidation?.minLength ?? DEFAULT_MIN_LENGTH,
+    maxLength: lengthValidation?.maxLength ?? DEFAULT_MAX_LENGTH
+});
+/** Value-level rules of `handleValidationSchema` — within length bounds and matching the handle format. */
+export const isValidHandle = (value, lengthValidation) => {
+    const { minLength, maxLength } = resolveHandleLength(lengthValidation);
+    return value.length >= minLength && value.length <= maxLength && HANDLE_REGEX.test(value);
+};
 export const handleValidationSchema = (lengthValidation) => {
     const msg = new ValidationLocalization();
-    const minLength = lengthValidation?.minLength ?? DEFAULT_MIN_LENGTH;
-    const maxLength = lengthValidation?.maxLength ?? DEFAULT_MAX_LENGTH;
+    const { minLength, maxLength } = resolveHandleLength(lengthValidation);
     return yup
         .string()
         .required(msg.required)

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

@@ -1,7 +1,7 @@
 export type { TextValidation, TextWithFormatValidation, NumberValidation, MinNumberValidation, ArrayValidation, UrlValidation } from './types';
-export { emailValidationSchema, nullableEmailValidationSchema } from './email-validation';
-export { textValidationSchema, formattedTextValidationSchema } from './text-validations';
-export { handleValidationSchema } from './handle-validations';
-export { numberValidationSchema, minNumberValidationSchema } from './number-validations';
-export { arrayValidationSchema } from './array-validations';
-export { urlValidationSchema } from './url-validation';
+export { emailValidationSchema, nullableEmailValidationSchema, isValidEmail } from './email-validation';
+export { textValidationSchema, formattedTextValidationSchema, isValidText, isValidFormattedText } from './text-validations';
+export { handleValidationSchema, isValidHandle } from './handle-validations';
+export { numberValidationSchema, minNumberValidationSchema, isValidNumber, isValidMinNumber } from './number-validations';
+export { arrayValidationSchema, isValidArray } from './array-validations';
+export { urlValidationSchema, isValidUrl } from './url-validation';

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

@@ -1,6 +1,6 @@
-export { emailValidationSchema, nullableEmailValidationSchema } from './email-validation';
-export { textValidationSchema, formattedTextValidationSchema } from './text-validations';
-export { handleValidationSchema } from './handle-validations';
-export { numberValidationSchema, minNumberValidationSchema } from './number-validations';
-export { arrayValidationSchema } from './array-validations';
-export { urlValidationSchema } from './url-validation';
+export { emailValidationSchema, nullableEmailValidationSchema, isValidEmail } from './email-validation';
+export { textValidationSchema, formattedTextValidationSchema, isValidText, isValidFormattedText } from './text-validations';
+export { handleValidationSchema, isValidHandle } from './handle-validations';
+export { numberValidationSchema, minNumberValidationSchema, isValidNumber, isValidMinNumber } from './number-validations';
+export { arrayValidationSchema, isValidArray } from './array-validations';
+export { urlValidationSchema, isValidUrl } from './url-validation';

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

@@ -1,4 +1,8 @@
 import type { MinNumberValidation, NumberValidation } from './types';
 import * as yup from 'yup';
+/** Value-level rules of `numberValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export declare const isValidNumber: (value: number, rules: NumberValidation) => boolean;
+/** Value-level rules of `minNumberValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export declare const isValidMinNumber: (value: number, rules: MinNumberValidation) => boolean;
 export declare const numberValidationSchema: (rules: NumberValidation) => yup.NumberSchema<number | null | undefined, yup.AnyObject, undefined, "">;
 export declare const minNumberValidationSchema: (rules: MinNumberValidation) => yup.NumberSchema<number | null | undefined, yup.AnyObject, undefined, "">;

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

@@ -1,24 +1,41 @@
 import { ValidationLocalization } from './validation-localization';
 import * as yup from 'yup';
+const resolveMinBound = (rules) => {
+    return rules.minValue === null ? null : rules.minExclusive ? rules.minValue + 1 : rules.minValue;
+};
+const resolveMaxBound = (rules) => {
+    return rules.maxValue === null ? null : rules.maxExclusive ? rules.maxValue - 1 : rules.maxValue;
+};
+/** Value-level rules of `numberValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export const isValidNumber = (value, rules) => {
+    const min = resolveMinBound(rules);
+    const max = resolveMaxBound(rules);
+    return (min === null || value >= min) && (max === null || value <= max);
+};
+/** Value-level rules of `minNumberValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export const isValidMinNumber = (value, rules) => {
+    const min = resolveMinBound(rules);
+    return min === null || value >= min;
+};
 export const numberValidationSchema = (rules) => {
     const msg = new ValidationLocalization();
+    const min = resolveMinBound(rules);
+    const max = resolveMaxBound(rules);
     let schema = yup.number().typeError(msg.badFormat).nullable();
-    if (rules.minValue !== null) {
-        const minValue = rules.minExclusive ? rules.minValue + 1 : rules.minValue;
-        schema = schema.min(minValue, msg.min(minValue));
+    if (min !== null) {
+        schema = schema.min(min, msg.min(min));
     }
-    if (rules.maxValue !== null) {
-        const maxValue = rules.maxExclusive ? rules.maxValue - 1 : rules.maxValue;
-        schema = schema.max(maxValue, msg.max(maxValue));
+    if (max !== null) {
+        schema = schema.max(max, msg.max(max));
     }
     return schema;
 };
 export const minNumberValidationSchema = (rules) => {
     const msg = new ValidationLocalization();
+    const min = resolveMinBound(rules);
     let schema = yup.number().typeError(msg.badFormat).nullable();
-    if (rules.minValue !== null) {
-        const minValue = rules.minExclusive ? rules.minValue + 1 : rules.minValue;
-        schema = schema.min(minValue, msg.min(minValue));
+    if (min !== null) {
+        schema = schema.min(min, msg.min(min));
     }
     return schema;
 };

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

@@ -1,4 +1,8 @@
 import type { TextValidation, TextWithFormatValidation } from './types';
 import * as yup from 'yup';
+/** Value-level rules of `textValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export declare const isValidText: (value: string, rules: TextValidation) => boolean;
+/** Value-level rules of `formattedTextValidationSchema` — `isValidText` plus the format, which an empty value skips. */
+export declare const isValidFormattedText: (value: string, rules: TextWithFormatValidation) => boolean;
 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, "">;

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

@@ -1,8 +1,17 @@
 import { ValidationLocalization } from './validation-localization';
 import * as yup from 'yup';
+const isEmptyOrHasContent = (value) => !value || value.trim().length > 0;
+/** Value-level rules of `textValidationSchema`. Judges a real value — `null` / `undefined` are decided by the schema modifiers the caller adds. */
+export const isValidText = (value, rules) => {
+    return isEmptyOrHasContent(value) && value.length >= rules.minLength && value.length <= rules.maxLength;
+};
+/** Value-level rules of `formattedTextValidationSchema` — `isValidText` plus the format, which an empty value skips. */
+export const isValidFormattedText = (value, rules) => {
+    return isValidText(value, rules) && (!value || new RegExp(rules.format).test(value));
+};
 export const textValidationSchema = (rules) => {
     const msg = new ValidationLocalization();
-    const schema = yup.string().max(rules.maxLength, msg.maxLength(rules.maxLength));
+    const schema = yup.string().test('whitespace-only', msg.whitespaceOnly, isEmptyOrHasContent).max(rules.maxLength, msg.maxLength(rules.maxLength));
     if (rules.minLength === 0) {
         return schema;
     }

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

@@ -1,3 +1,5 @@
 import type { UrlValidation } from './types';
 import * as yup from 'yup';
+/** Value-level rules of `urlValidationSchema` — scheme / host check via `validateHref`, plus the optional length and required rules. */
+export declare const isValidUrl: (value: string, rules?: UrlValidation) => boolean;
 export declare const urlValidationSchema: (rules?: UrlValidation) => yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;

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

@@ -2,12 +2,25 @@ import { validateHref } from '../../utils';
 import { ValidationLocalization } from './validation-localization';
 import * as yup from 'yup';
 const DEFAULT_SCHEMES = new Set(['http:', 'https:']);
+const resolveHrefOptions = (rules) => ({
+    allowedSchemes: rules.schemes ?? DEFAULT_SCHEMES,
+    requireNamedHost: rules.requireNamedHost ?? true,
+    allowLocalHosts: rules.allowLocalHosts ?? true
+});
+/** Value-level rules of `urlValidationSchema` — scheme / host check via `validateHref`, plus the optional length and required rules. */
+export const isValidUrl = (value, rules = {}) => {
+    if (!value) {
+        return rules.required !== true;
+    }
+    if (!validateHref(value, resolveHrefOptions(rules)).valid) {
+        return false;
+    }
+    return rules.maxLength === undefined || value.length <= rules.maxLength;
+};
 export const urlValidationSchema = (rules = {}) => {
     const msg = new ValidationLocalization();
-    const allowedSchemes = rules.schemes ?? DEFAULT_SCHEMES;
-    const requireNamedHost = rules.requireNamedHost ?? true;
-    const allowLocalHosts = rules.allowLocalHosts ?? true;
-    const schema = yup.string().test('url', msg.url, (value) => !value || validateHref(value, { allowedSchemes, requireNamedHost, allowLocalHosts }).valid);
+    const hrefOptions = resolveHrefOptions(rules);
+    const schema = yup.string().test('url', msg.url, (value) => !value || validateHref(value, hrefOptions).valid);
     const withMaxLength = rules.maxLength === undefined ? schema : schema.max(rules.maxLength, msg.maxLength(rules.maxLength));
     return rules.required ? withMaxLength.required(msg.required) : withMaxLength;
 };

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

@@ -7,6 +7,7 @@ export declare class ValidationLocalization {
     get max(): (val: number) => string;
     get minItems(): (count: number) => string;
     get maxItems(): (count: number) => string;
+    get whitespaceOnly(): string;
     get badFormat(): string;
     get url(): string;
 }

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

@@ -24,6 +24,9 @@ export class ValidationLocalization {
     get maxItems() {
         return loc.maxItems[AppLocale.current];
     }
+    get whitespaceOnly() {
+        return loc.whitespaceOnly[AppLocale.current];
+    }
     get badFormat() {
         return loc.badFormat[AppLocale.current];
     }
@@ -64,6 +67,10 @@ const loc = {
         en: (count) => `Must contain at most ${count} item${count === 1 ? '' : 's'}`,
         no: (count) => `Kan ikke inneholde mer enn ${count} element${count === 1 ? '' : 'er'}`
     },
+    whitespaceOnly: {
+        en: 'This field cannot contain only spaces',
+        no: 'Dette feltet kan ikke bestå av bare mellomrom'
+    },
     badFormat: {
         en: 'Invalid format',
         no: 'Ugyldig format'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/kit",
-  "version": "0.42.1",
+  "version": "0.44.0",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",