origam 0.3.10 → 2.3.0

package/dist/src/utils/Mask/apply-mask.util.cjs

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyMask = applyMask;
+exports.parsePattern = parsePattern;
+exports.unmaskValue = unmaskValue;
+const TOKEN_CACHE = /* @__PURE__ */new Map();
+function parsePattern(pattern) {
+  if (TOKEN_CACHE.has(pattern)) {
+    return TOKEN_CACHE.get(pattern);
+  }
+  const tokens = [];
+  for (const char of pattern) {
+    if (char === "#") {
+      tokens.push({
+        kind: "digit",
+        char: "#",
+        consumer: true
+      });
+    } else if (char === "A") {
+      tokens.push({
+        kind: "letter",
+        char: "A",
+        consumer: true
+      });
+    } else if (char === "*") {
+      tokens.push({
+        kind: "any",
+        char: "*",
+        consumer: true
+      });
+    } else {
+      tokens.push({
+        kind: "literal",
+        char,
+        consumer: false
+      });
+    }
+  }
+  TOKEN_CACHE.set(pattern, tokens);
+  return tokens;
+}
+const isDigit = c => c >= "0" && c <= "9";
+const isLetter = c => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+const LITERALS_CACHE = /* @__PURE__ */new Map();
+function literalSetOf(pattern) {
+  if (LITERALS_CACHE.has(pattern)) return LITERALS_CACHE.get(pattern);
+  const set = /* @__PURE__ */new Set();
+  for (const tok of parsePattern(pattern)) {
+    if (!tok.consumer) set.add(tok.char);
+  }
+  LITERALS_CACHE.set(pattern, set);
+  return set;
+}
+function stripLiterals(raw, pattern) {
+  const literals = literalSetOf(pattern);
+  let out = "";
+  for (const c of raw) {
+    if (literals.has(c)) continue;
+    out += c;
+  }
+  return out;
+}
+function applyMask(value, pattern) {
+  if (!pattern) {
+    return {
+      masked: value ?? "",
+      unmasked: value ?? "",
+      complete: false
+    };
+  }
+  const tokens = parsePattern(pattern);
+  const stripped = stripLiterals(value ?? "", pattern);
+  let masked = "";
+  let unmasked = "";
+  let consumed = 0;
+  let filledConsumers = 0;
+  const totalConsumers = tokens.reduce((acc, t) => acc + (t.consumer ? 1 : 0), 0);
+  for (const tok of tokens) {
+    if (!tok.consumer) {
+      if (consumed < stripped.length || unmasked.length > 0) {
+        masked += tok.char;
+      }
+      continue;
+    }
+    let matched = null;
+    while (consumed < stripped.length) {
+      const c = stripped[consumed++];
+      if (tok.kind === "digit" && isDigit(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "letter" && isLetter(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "any") {
+        matched = c;
+        break;
+      }
+    }
+    if (matched === null) {
+      break;
+    }
+    masked += matched;
+    unmasked += matched;
+    filledConsumers++;
+  }
+  const complete = filledConsumers === totalConsumers && totalConsumers > 0;
+  return {
+    masked,
+    unmasked,
+    complete
+  };
+}
+function unmaskValue(value, pattern) {
+  return applyMask(value, pattern).unmasked;
+}

package/dist/src/utils/Mask/apply-mask.util.d.ts

@@ -0,0 +1,13 @@
+import type { IMaskApplyResult, IMaskToken } from '../../interfaces';
+export declare function parsePattern(pattern: string): Array<IMaskToken>;
+/**
+ * Walk the pattern and consume the (pre-stripped) input
+ * char-by-char. Mismatching characters are dropped.
+ */
+export declare function applyMask(value: string, pattern: string): IMaskApplyResult;
+/**
+ * Returns just the unmasked value — handy from outside
+ * code that already knows its mask but only wants the
+ * raw characters.
+ */
+export declare function unmaskValue(value: string, pattern: string): string;

package/dist/src/utils/Mask/apply-mask.util.js

@@ -0,0 +1,91 @@
+const TOKEN_CACHE = /* @__PURE__ */ new Map();
+export function parsePattern(pattern) {
+  if (TOKEN_CACHE.has(pattern)) {
+    return TOKEN_CACHE.get(pattern);
+  }
+  const tokens = [];
+  for (const char of pattern) {
+    if (char === "#") {
+      tokens.push({ kind: "digit", char: "#", consumer: true });
+    } else if (char === "A") {
+      tokens.push({ kind: "letter", char: "A", consumer: true });
+    } else if (char === "*") {
+      tokens.push({ kind: "any", char: "*", consumer: true });
+    } else {
+      tokens.push({ kind: "literal", char, consumer: false });
+    }
+  }
+  TOKEN_CACHE.set(pattern, tokens);
+  return tokens;
+}
+const isDigit = (c) => c >= "0" && c <= "9";
+const isLetter = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+const LITERALS_CACHE = /* @__PURE__ */ new Map();
+function literalSetOf(pattern) {
+  if (LITERALS_CACHE.has(pattern)) return LITERALS_CACHE.get(pattern);
+  const set = /* @__PURE__ */ new Set();
+  for (const tok of parsePattern(pattern)) {
+    if (!tok.consumer) set.add(tok.char);
+  }
+  LITERALS_CACHE.set(pattern, set);
+  return set;
+}
+function stripLiterals(raw, pattern) {
+  const literals = literalSetOf(pattern);
+  let out = "";
+  for (const c of raw) {
+    if (literals.has(c)) continue;
+    out += c;
+  }
+  return out;
+}
+export function applyMask(value, pattern) {
+  if (!pattern) {
+    return { masked: value ?? "", unmasked: value ?? "", complete: false };
+  }
+  const tokens = parsePattern(pattern);
+  const stripped = stripLiterals(value ?? "", pattern);
+  let masked = "";
+  let unmasked = "";
+  let consumed = 0;
+  let filledConsumers = 0;
+  const totalConsumers = tokens.reduce(
+    (acc, t) => acc + (t.consumer ? 1 : 0),
+    0
+  );
+  for (const tok of tokens) {
+    if (!tok.consumer) {
+      if (consumed < stripped.length || unmasked.length > 0) {
+        masked += tok.char;
+      }
+      continue;
+    }
+    let matched = null;
+    while (consumed < stripped.length) {
+      const c = stripped[consumed++];
+      if (tok.kind === "digit" && isDigit(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "letter" && isLetter(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "any") {
+        matched = c;
+        break;
+      }
+    }
+    if (matched === null) {
+      break;
+    }
+    masked += matched;
+    unmasked += matched;
+    filledConsumers++;
+  }
+  const complete = filledConsumers === totalConsumers && totalConsumers > 0;
+  return { masked, unmasked, complete };
+}
+export function unmaskValue(value, pattern) {
+  return applyMask(value, pattern).unmasked;
+}

package/dist/src/utils/Mask/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _applyMask = require("./apply-mask.util.cjs");
+Object.keys(_applyMask).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _applyMask[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _applyMask[key];
+    }
+  });
+});
+var _resolveMaskConfig = require("./resolve-mask-config.util.cjs");
+Object.keys(_resolveMaskConfig).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolveMaskConfig[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolveMaskConfig[key];
+    }
+  });
+});
+var _validatePattern = require("./validate-pattern.util.cjs");
+Object.keys(_validatePattern).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validatePattern[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validatePattern[key];
+    }
+  });
+});

package/dist/src/utils/Mask/index.d.ts

@@ -0,0 +1,3 @@
+export * from './apply-mask.util';
+export * from './resolve-mask-config.util';
+export * from './validate-pattern.util';

package/dist/src/utils/Mask/index.js

@@ -0,0 +1,3 @@
+export * from "./apply-mask.util.js";
+export * from "./resolve-mask-config.util.js";
+export * from "./validate-pattern.util.js";

package/dist/src/utils/Mask/resolve-mask-config.util.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveMaskConfig = resolveMaskConfig;
+var _consts = require("../../consts/index.cjs");
+function resolveMaskConfig(mask) {
+  if (mask == null || mask === "") return null;
+  if (typeof mask === "string") {
+    if (_consts.BUILT_IN_PATTERN_KEYS.has(mask)) {
+      const preset = _consts.BUILT_IN_PATTERNS[mask];
+      return {
+        pattern: preset.pattern,
+        validator: preset.validator ?? null,
+        required: preset.required ?? false
+      };
+    }
+    return {
+      pattern: mask,
+      validator: null,
+      required: false
+    };
+  }
+  const opts = mask;
+  return {
+    pattern: opts.pattern,
+    validator: opts.validator ?? null,
+    required: opts.required ?? false
+  };
+}

package/dist/src/utils/Mask/resolve-mask-config.util.d.ts

@@ -0,0 +1,15 @@
+import type { IResolvedMaskConfig } from '../../interfaces';
+import type { TMask } from '../../types';
+/**
+ * Normalise the polymorphic `mask` prop / arg into a fully
+ * resolved `{ pattern, validator, required }` object.
+ *
+ * - `null | undefined | ''` → returns `null`. Callers treat
+ *   this as "no masking".
+ * - `string`                → either a registered built-in
+ *                             key (looked up) or a raw
+ *                             pattern (used verbatim).
+ * - `IMaskOptions`          → consumed as-is, with `required`
+ *                             defaulting to `false`.
+ */
+export declare function resolveMaskConfig(mask: TMask | undefined): IResolvedMaskConfig | null;

package/dist/src/utils/Mask/resolve-mask-config.util.js

@@ -0,0 +1,21 @@
+import { BUILT_IN_PATTERN_KEYS, BUILT_IN_PATTERNS } from "../../consts/index.js";
+export function resolveMaskConfig(mask) {
+  if (mask == null || mask === "") return null;
+  if (typeof mask === "string") {
+    if (BUILT_IN_PATTERN_KEYS.has(mask)) {
+      const preset = BUILT_IN_PATTERNS[mask];
+      return {
+        pattern: preset.pattern,
+        validator: preset.validator ?? null,
+        required: preset.required ?? false
+      };
+    }
+    return { pattern: mask, validator: null, required: false };
+  }
+  const opts = mask;
+  return {
+    pattern: opts.pattern,
+    validator: opts.validator ?? null,
+    required: opts.required ?? false
+  };
+}

package/dist/src/utils/Mask/validate-pattern.util.cjs

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isFrDateValid = isFrDateValid;
+exports.isIbanValid = isIbanValid;
+exports.isIsoDateValid = isIsoDateValid;
+exports.isLuhnValid = isLuhnValid;
+exports.isUsDateValid = isUsDateValid;
+exports.validatePattern = validatePattern;
+var _enums = require("../../enums/index.cjs");
+function isLuhnValid(digits) {
+  if (!digits) return false;
+  if (!/^\d+$/.test(digits)) return false;
+  let sum = 0;
+  let alternate = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = digits.charCodeAt(i) - 48;
+    if (alternate) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+function isIbanValid(raw) {
+  if (!raw) return false;
+  const clean = raw.replace(/\s+/g, "").toUpperCase();
+  if (clean.length < 4 || clean.length > 34) return false;
+  if (!/^[A-Z0-9]+$/.test(clean)) return false;
+  const rearranged = clean.slice(4) + clean.slice(0, 4);
+  let numeric = "";
+  for (const c of rearranged) {
+    if (c >= "0" && c <= "9") {
+      numeric += c;
+    } else {
+      numeric += String(c.charCodeAt(0) - 55);
+    }
+  }
+  let remainder = 0;
+  for (const ch of numeric) {
+    remainder = (remainder * 10 + (ch.charCodeAt(0) - 48)) % 97;
+  }
+  return remainder === 1;
+}
+function isRealDate(y, m, d) {
+  if (m < 1 || m > 12) return false;
+  if (d < 1 || d > 31) return false;
+  const date = new Date(Date.UTC(y, m - 1, d));
+  return date.getUTCFullYear() === y && date.getUTCMonth() === m - 1 && date.getUTCDate() === d;
+}
+function isIsoDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const y = Number(unmasked.slice(0, 4));
+  const m = Number(unmasked.slice(4, 6));
+  const d = Number(unmasked.slice(6, 8));
+  return isRealDate(y, m, d);
+}
+function isFrDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const d = Number(unmasked.slice(0, 2));
+  const m = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+function isUsDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const m = Number(unmasked.slice(0, 2));
+  const d = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+const VALIDATORS = {
+  [_enums.PATTERN_VALIDATOR.LUHN]: isLuhnValid,
+  [_enums.PATTERN_VALIDATOR.IBAN]: isIbanValid,
+  [_enums.PATTERN_VALIDATOR.DATE_ISO]: isIsoDateValid,
+  [_enums.PATTERN_VALIDATOR.DATE_FR]: isFrDateValid,
+  [_enums.PATTERN_VALIDATOR.DATE_US]: isUsDateValid
+};
+function validatePattern(unmasked, validator) {
+  if (typeof validator === "function") {
+    return validator(unmasked);
+  }
+  const fn = VALIDATORS[validator];
+  if (!fn) {
+    throw new Error(`[origam:mask] unknown validator "${validator}"`);
+  }
+  return fn(unmasked);
+}

package/dist/src/utils/Mask/validate-pattern.util.d.ts

@@ -0,0 +1,41 @@
+import type { TPatternValidator } from '../../types';
+/**
+ * Standard Luhn checksum used to validate credit-card,
+ * IMEI, SIRET-like number sequences.
+ *
+ *   1. Walk digits from right to left.
+ *   2. Double every second digit; subtract 9 if > 9.
+ *   3. Sum the result. A valid number's sum mod 10 == 0.
+ */
+export declare function isLuhnValid(digits: string): boolean;
+/**
+ * Standard IBAN mod-97 check (ISO 13616).
+ *
+ *   1. Move the first 4 chars to the end.
+ *   2. Replace every letter with `letter - 'A' + 10` as a
+ *      decimal pair.
+ *   3. The resulting big integer mod 97 must equal 1.
+ *
+ * We compute the mod incrementally to avoid BigInt.
+ */
+export declare function isIbanValid(raw: string): boolean;
+/**
+ * `YYYYMMDD` — accepts the unmasked iso digits.
+ */
+export declare function isIsoDateValid(unmasked: string): boolean;
+/**
+ * `DDMMYYYY` — accepts the unmasked fr digits.
+ */
+export declare function isFrDateValid(unmasked: string): boolean;
+/**
+ * `MMDDYYYY` — accepts the unmasked us digits.
+ */
+export declare function isUsDateValid(unmasked: string): boolean;
+/**
+ * Resolve and execute a validator on an UNMASKED value.
+ *
+ * - `string`   → looked up in `VALIDATORS`. Unknown names
+ *                throw — typo-prevention.
+ * - `function` → called as-is.
+ */
+export declare function validatePattern(unmasked: string, validator: TPatternValidator): boolean;

package/dist/src/utils/Mask/validate-pattern.util.js

@@ -0,0 +1,81 @@
+import { PATTERN_VALIDATOR } from "../../enums/index.js";
+export function isLuhnValid(digits) {
+  if (!digits) return false;
+  if (!/^\d+$/.test(digits)) return false;
+  let sum = 0;
+  let alternate = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = digits.charCodeAt(i) - 48;
+    if (alternate) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+export function isIbanValid(raw) {
+  if (!raw) return false;
+  const clean = raw.replace(/\s+/g, "").toUpperCase();
+  if (clean.length < 4 || clean.length > 34) return false;
+  if (!/^[A-Z0-9]+$/.test(clean)) return false;
+  const rearranged = clean.slice(4) + clean.slice(0, 4);
+  let numeric = "";
+  for (const c of rearranged) {
+    if (c >= "0" && c <= "9") {
+      numeric += c;
+    } else {
+      numeric += String(c.charCodeAt(0) - 55);
+    }
+  }
+  let remainder = 0;
+  for (const ch of numeric) {
+    remainder = (remainder * 10 + (ch.charCodeAt(0) - 48)) % 97;
+  }
+  return remainder === 1;
+}
+function isRealDate(y, m, d) {
+  if (m < 1 || m > 12) return false;
+  if (d < 1 || d > 31) return false;
+  const date = new Date(Date.UTC(y, m - 1, d));
+  return date.getUTCFullYear() === y && date.getUTCMonth() === m - 1 && date.getUTCDate() === d;
+}
+export function isIsoDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const y = Number(unmasked.slice(0, 4));
+  const m = Number(unmasked.slice(4, 6));
+  const d = Number(unmasked.slice(6, 8));
+  return isRealDate(y, m, d);
+}
+export function isFrDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const d = Number(unmasked.slice(0, 2));
+  const m = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+export function isUsDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const m = Number(unmasked.slice(0, 2));
+  const d = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+const VALIDATORS = {
+  [PATTERN_VALIDATOR.LUHN]: isLuhnValid,
+  [PATTERN_VALIDATOR.IBAN]: isIbanValid,
+  [PATTERN_VALIDATOR.DATE_ISO]: isIsoDateValid,
+  [PATTERN_VALIDATOR.DATE_FR]: isFrDateValid,
+  [PATTERN_VALIDATOR.DATE_US]: isUsDateValid
+};
+export function validatePattern(unmasked, validator) {
+  if (typeof validator === "function") {
+    return validator(unmasked);
+  }
+  const fn = VALIDATORS[validator];
+  if (!fn) {
+    throw new Error(`[origam:mask] unknown validator "${validator}"`);
+  }
+  return fn(unmasked);
+}

package/dist/src/utils/Parallax/parallax-element.util.d.ts

@@ -1,8 +1,19 @@
 import type { IParallaxElementCicle, IParallaxElementMovement } from '../../interfaces';
 import type { TPoint } from '../../types';
+/**
+ * Element movement.
+ *
+ * @param action …
+ */
 export declare function elementMovement(action: IParallaxElementMovement): {
     x: number;
     y: number;
     target: import("../../interfaces").IBox | DOMRect | undefined;
 };
+/**
+ * Cyclic movement.
+ *
+ * @param cycleData …
+ * @returns …
+ */
 export declare function cyclicMovement(cycleData: IParallaxElementCicle): TPoint;

package/dist/src/utils/Slide/slide-group.util.d.ts

@@ -1,16 +1,59 @@
+/**
+ * Calculate updated target.
+ *
+ * @param options …
+ * @returns …
+ */
 export declare function calculateUpdatedTarget({ selectedElement, containerElement, isRtl, isHorizontal }: {
     selectedElement: HTMLElement;
     containerElement: HTMLElement;
     isRtl: boolean;
     isHorizontal: boolean;
 }): number;
+/**
+ * Calculate centered target.
+ *
+ * @param options …
+ * @returns …
+ */
 export declare function calculateCenteredTarget({ selectedElement, containerElement, isHorizontal }: {
     selectedElement: HTMLElement;
     containerElement: HTMLElement;
     isHorizontal: boolean;
 }): number;
+/**
+ * Get scroll size.
+ *
+ * @param isHorizontal …
+ * @param element      …
+ */
 export declare function getScrollSize(isHorizontal: boolean, element?: HTMLElement): number;
+/**
+ * Get client size.
+ *
+ * @param isHorizontal …
+ * @param element      …
+ */
 export declare function getClientSize(isHorizontal: boolean, element?: HTMLElement): number;
+/**
+ * Get scroll position.
+ *
+ * @param isHorizontal …
+ * @param isRtl        …
+ * @param element      …
+ */
 export declare function getScrollPosition(isHorizontal: boolean, isRtl: boolean, element?: HTMLElement): number;
+/**
+ * Get offset size.
+ *
+ * @param isHorizontal …
+ * @param element      …
+ */
 export declare function getOffsetSize(isHorizontal: boolean, element?: HTMLElement): number;
+/**
+ * Get offset position.
+ *
+ * @param isHorizontal …
+ * @param element      …
+ */
 export declare function getOffsetPosition(isHorizontal: boolean, element?: HTMLElement): number;

package/dist/src/utils/SliderField/slider-field.util.d.ts

@@ -1 +1,8 @@
+/**
+ * Get slider field offset.
+ *
+ * @param e         …
+ * @param el        …
+ * @param direction …
+ */
 export declare function getSliderFieldOffset(e: MouseEvent | TouchEvent, el: HTMLElement, direction: string): number;