@quidgest/ui 0.16.75 → 0.17.1

package/esm/utils/index.js

@@ -1,20 +1,43 @@
-import { getComplementaryColor as e, getContrastingColor as t } from "./color/contrast.js";
-import { hslToRgb as l, hueToRgb as m, rgbToHex as a, rgbToHsl as b, rgbToVariableString as p } from "./color/conversion.js";
-import { darken as x, lighten as i } from "./color/manipulate.js";
-import { mergeColorSchemes as C } from "./color/merge.js";
-import { isValidHex as T, parseColor as h, tryParseRgb as H } from "./color/parse.js";
+import { addDays as o, addMonths as r, completePartialDateInput as a, convertDatePatternToMask as s, formatDate as m, formatUsesSeconds as n, formatUsesTime as i, getDaysInMonth as g, getEndOfDay as p, getFirstDayOfMonth as l, getFirstDayOfWeek as f, getLastDayOfMonth as D, getStartOfDay as y, inputIncludesTimePortion as d, isBetween as h, isLeapYear as T, isSameDay as b, isTimeOnlyFormat as x, padNumber as u, parseDate as C, parseDateWithCompletion as O, uses12HourFormat as c } from "./date.js";
+import { getComplementaryColor as S, getContrastingColor as F } from "./color/contrast.js";
+import { hslToRgb as P, hueToRgb as k, rgbToHex as I, rgbToHsl as R, rgbToVariableString as L } from "./color/conversion.js";
+import { darken as V, lighten as W } from "./color/manipulate.js";
+import { mergeColorSchemes as w } from "./color/merge.js";
+import { isValidHex as E, parseColor as N, tryParseRgb as Y } from "./color/parse.js";
 export {
-  x as darken,
-  e as getComplementaryColor,
-  t as getContrastingColor,
-  l as hslToRgb,
-  m as hueToRgb,
-  T as isValidHex,
-  i as lighten,
-  C as mergeColorSchemes,
-  h as parseColor,
-  a as rgbToHex,
-  b as rgbToHsl,
-  p as rgbToVariableString,
-  H as tryParseRgb
+  o as addDays,
+  r as addMonths,
+  a as completePartialDateInput,
+  s as convertDatePatternToMask,
+  V as darken,
+  m as formatDate,
+  n as formatUsesSeconds,
+  i as formatUsesTime,
+  S as getComplementaryColor,
+  F as getContrastingColor,
+  g as getDaysInMonth,
+  p as getEndOfDay,
+  l as getFirstDayOfMonth,
+  f as getFirstDayOfWeek,
+  D as getLastDayOfMonth,
+  y as getStartOfDay,
+  P as hslToRgb,
+  k as hueToRgb,
+  d as inputIncludesTimePortion,
+  h as isBetween,
+  T as isLeapYear,
+  b as isSameDay,
+  x as isTimeOnlyFormat,
+  E as isValidHex,
+  W as lighten,
+  w as mergeColorSchemes,
+  u as padNumber,
+  N as parseColor,
+  C as parseDate,
+  O as parseDateWithCompletion,
+  I as rgbToHex,
+  R as rgbToHsl,
+  L as rgbToVariableString,
+  Y as tryParseRgb,
+  c as uses12HourFormat
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@quidgest/ui",
   "description": "Quidgest's UI framework",
-  "version": "0.16.75",
+  "version": "0.17.1",
   "private": false,
   "type": "module",
   "author": "Quidgest",
@@ -68,11 +68,9 @@
     "vue-tsc": "^2.2.0"
   },
   "peerDependencies": {
-    "vue": "^3.4.15"
+    "vue": "^3.5.38"
   },
   "dependencies": {
-    "@vuepic/vue-datepicker": "^11.0.3",
-    "maska": "^3.1.0",
     "uuid": "^13.0.0"
   },
   "scripts": {

package/esm/composables/maska.d.ts

@@ -1,28 +0,0 @@
-import { MaskOptions, MaskInput } from 'maska';
-import { Ref } from 'vue';
-/**
- * Creates and manages a masked input instance on a given HTML input element.
- *
- * This function initializes a MaskInput instance using the provided HTML input element or a ref to the element.
- * It applies mask options if provided, and listens for changes in the options to update the mask instance dynamically.
- * The mask is automatically destroyed when the component is unmounted.
- *
- * @param target - The HTML input element or a ref to the HTML input element where the mask should be applied.
- * @param options - (Optional) A ref to a set of mask options to configure the input mask. The mask instance will be updated
- *                  when these options change.
- *
- * @returns An object containing a "maska" ref to the MaskInput instance.
- *
- * @example
- * ```ts
- * const inputRef = ref<HTMLInputElement | null>(null);
- * const maskOptions = ref<MaskOptions>({ mask: '###-##-####', tokens: { '#': { pattern: /\d/ } } });
- * const { maska } = useMaska(inputRef, maskOptions);
- * ```
- *
- * @see MaskInput for more details on how the mask is implemented.
- */
-export declare function useMaska(target: HTMLInputElement | Ref<HTMLInputElement | null | undefined>, options?: Ref<MaskOptions>): {
-    maska: Ref<MaskInput, MaskInput>;
-};
-//# sourceMappingURL=maska.d.ts.map

package/esm/composables/maska.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"maska.d.ts","sourceRoot":"","sources":["../../src/composables/maska.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AACxC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGjC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CACvB,MAAM,EAAE,gBAAgB,GAAG,GAAG,CAAC,gBAAgB,GAAG,IAAI,GAAG,SAAS,CAAC,EACnE,OAAO,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC;;EAmC1B"}

package/esm/composables/maska.js

@@ -1,26 +0,0 @@
-import { MaskInput as m } from "../vendors/maska/dist/maska.js";
-import { ref as c, onMounted as d, onUnmounted as f, watch as o } from "vue";
-function M(u, e) {
-  const n = c(null), r = () => {
-    const a = u instanceof HTMLInputElement ? u : u.value;
-    if (!a)
-      throw new Error("Input element is required");
-    n.value = new m(a, e == null ? void 0 : e.value), e && o(
-      e,
-      (s) => {
-        var t;
-        (t = n.value) == null || t.update(s);
-      },
-      { deep: !0 }
-    );
-  }, l = () => {
-    var a;
-    (a = n.value) == null || a.destroy(), n.value = null;
-  };
-  return d(r), f(l), {
-    maska: n
-  };
-}
-export {
-  M as useMaska
-};

package/esm/utils/date/date.d.ts

@@ -1,9 +0,0 @@
-/**
- * Converts a Unicode date format pattern
- * into a mask string compatible with the Maska library.
- *
- * @param pattern - The Unicode date format pattern to be converted.
- * @returns The corresponding mask string for the Maska library.
- */
-export declare function convertDatePatternToMask(format: string): string | string[];
-//# sourceMappingURL=date.d.ts.map

package/esm/utils/date/date.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/utils/date/date.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CA8C1E"}

package/esm/utils/date/date.js

@@ -1,91 +0,0 @@
-import { tokenizeFormat as g, staticTokensMap as h, isUnitRepetition as y, dynamicTokensMap as E } from "./tokens.js";
-function x(n) {
-  const r = g(n);
-  if (!r)
-    throw Error("Failed to tokenize format string.");
-  const i = [...r.sort((e, a) => a.length - e.length)], t = [n];
-  if (r.filter((e) => h[e] !== void 0).forEach((e) => {
-    const a = h[e];
-    d(a, t, e);
-    const c = i.indexOf(e);
-    i.splice(c, 1);
-  }), [...i].forEach((e) => {
-    if (!y(e))
-      throw new Error(`Invalid token format: ${e}. Tokens must be repeated characters.`);
-    const a = e[0], c = w(a, e.length);
-    d(c, t, e);
-    const f = i.indexOf(e);
-    i.splice(f, 1);
-  }), i.length > 0)
-    throw new Error(`Unhandled tokens remain: ${i.join(", ")}`);
-  return t.forEach((e, a) => {
-    t[a] = T(e);
-  }), t.length === 1 ? t[0] : t;
-}
-function T(n) {
-  const r = "\0";
-  return n.replace(/'((?:[^']|'')+)'/g, (i, t) => t.replace(/''/g, r).split("").map((e) => e === r ? "!'" : "!" + e).join(""));
-}
-function w(n, r) {
-  const i = [], t = E[n];
-  if (t === void 0)
-    throw new Error(`Dynamic token '${n}' not found.`);
-  if (typeof t == "string") {
-    const s = p(t, r);
-    i.push(s);
-  } else Array.isArray(i) && t.forEach((o) => {
-    const s = p(o, r);
-    i.push(s);
-  });
-  return i;
-}
-function p(n, r) {
-  const i = n.startsWith("-");
-  return i && (n = n.substring(1)), n = n.repeat(r), i && (n = `-${n}`), n;
-}
-function d(n, r, i) {
-  if (typeof n == "string") {
-    const t = n;
-    r.forEach((o, s) => {
-      r[s] = u(o, i, t);
-    });
-  } else if (Array.isArray(n)) {
-    const t = n.length, o = [...r], s = o.length;
-    for (let e = 1; e < t; e++)
-      r.push(...o);
-    n.forEach((e, a) => {
-      const c = a * s, f = c + s - 1;
-      for (let l = c; l <= f; l++)
-        r[l] = u(r[l], i, e);
-    });
-  }
-}
-function u(n, r, i) {
-  let t = "", o = 0, s = !1, e = "";
-  const a = r.length;
-  for (; o < n.length; ) {
-    const c = n[o];
-    if (!s && (c === "'" || c === '"')) {
-      s = !0, e = c, t += c, o++;
-      continue;
-    }
-    if (s)
-      if (c === e)
-        if (o + 1 < n.length && n[o + 1] === e) {
-          t += e + e, o += 2;
-          continue;
-        } else {
-          s = !1, t += c, o++;
-          continue;
-        }
-      else {
-        t += c, o++;
-        continue;
-      }
-    n.substring(o, o + a) === r ? (t += i, o += a) : (t += c, o++);
-  }
-  return t;
-}
-export {
-  x as convertDatePatternToMask
-};

package/esm/utils/date/index.d.ts

@@ -1,4 +0,0 @@
-import { convertDatePatternToMask } from './date';
-import { isTimeOnlyFormat } from './tokens';
-export { convertDatePatternToMask, isTimeOnlyFormat };
-//# sourceMappingURL=index.d.ts.map

package/esm/utils/date/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/date/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE3C,OAAO,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,CAAA"}

package/esm/utils/date/tokens.d.ts

@@ -1,49 +0,0 @@
-export type TokenMap = {
-    [token: string]: string | string[];
-};
-export declare const staticTokensMap: TokenMap;
-export declare const dynamicTokensMap: TokenMap;
-/**
- * Tokenizes a given format string by matching against both variable and fixed token patterns.
- *
- * This function dynamically constructs a regular expression that first targets variable tokens
- * (allowing for 1 to 4 greedy occurrences) and then fixed tokens (sorted in descending order of length).
- * It escapes any special regex characters in both token maps to ensure that they are correctly interpreted
- * as literal strings in the resulting Regex.
- *
- * @remarks
- * The generated regular expression is used to match and extract tokens from the provided format string.
- * If any tokens are found based on the specified patterns from `variableTokensMap` and `tokensMap`, an array
- * of tokens is returned; otherwise, `null` is returned.
- *
- * @param format - The string containing the format to be tokenized.
- * @returns An array of matched tokens if present, or `null` if no tokens match.
- *
- * @example
- * ```ts
- * const tokens = tokenizeFormat("YYYY-MM-DD");
- * console.log(tokens); // ['YYYY', 'MM', 'DD']
- * ```
- *
- * @see dynamicTokensMap
- * @see staticTokensMap
- */
-export declare function tokenizeFormat(format: string): RegExpMatchArray | null;
-/**
- * Determines if a given format string represents a time-only format.
- *
- * @param format - The format string to check (e.g., 'HH:mm:ss', 'YYYY-MM-DD HH:mm').
- * @returns `true` if the format is time-only, `false` if it includes date components.
- */
-export declare function isTimeOnlyFormat(format: string): boolean;
-/**
- * Checks whether the given token is not composed entirely of a single repeated character.
- *
- * A valid unit repetition (e.g., 'yyyy') consists of the same character repeated. This function
- * returns false if the token consists solely of one repeating character, and true otherwise.
- *
- * @param token - The string token to evaluate.
- * @returns False if the token is a unit repetition; true if it is not.
- */
-export declare function isUnitRepetition(token: string): boolean;
-//# sourceMappingURL=tokens.d.ts.map

package/esm/utils/date/tokens.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/utils/date/tokens.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,QAAQ,GAAG;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAA;AA0I7D,eAAO,MAAM,eAAe,EAAE,QAG7B,CAAA;AAuBD,eAAO,MAAM,gBAAgB,EAAE,QAG9B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAuBtE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAOxD;AA4BD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,WAG7C"}

package/esm/utils/date/tokens.js

@@ -1,243 +0,0 @@
-const c = {
-  // Era
-  GGGGG: "A",
-  // A, B
-  GGGG: "S",
-  // Anno Domini, Before Christ
-  GGG: "AA",
-  // AD, BC
-  GG: "AA",
-  // AD, BC
-  G: "AA",
-  // AD, BC
-  // Calendar year (y)
-  yy: "##",
-  // 44, 01, 00, 17
-  y: "N",
-  // 44, 1, 1900, 2017, 9999
-  // Local week-numbering year (Y)
-  YY: "##",
-  // 44, 01, 00, 17
-  Y: "N",
-  // 44, 1, 1900, 2017, 9999
-  // Quarter (formatting) – Q tokens
-  QQQQQ: "#",
-  // 1, 2, 3, 4
-  QQQQ: "#aa W",
-  // 1st quarter, 2nd quarter, ...
-  QQQ: "Q#",
-  // Q1, Q2, Q3, Q4
-  QQ: "##",
-  // 01, 02, 03, 04
-  Q: "#",
-  // 1, 2, 3, 4
-  // Quarter (stand-alone) – q tokens
-  qqqqq: "#",
-  // 1, 2, 3, 4
-  qqqq: "#aa W",
-  // 1st quarter, 2nd quarter, ...
-  qqq: "Q#",
-  // Q1, Q2, Q3, Q4
-  qq: "##",
-  // 01, 02, 03, 04
-  q: "#",
-  // 1, 2, 3, 4
-  // Month (formatting) – M tokens
-  MMMMM: "A",
-  // J, F, ..., D
-  MMMM: "W",
-  // January, February, ..., December
-  MMM: "Aaa",
-  // Jan, Feb, ..., Dec
-  MM: "##",
-  // 01, 02, ..., 12
-  M: "#n",
-  // 1, 2, ..., 12
-  // Month (stand-alone) – L tokens
-  LLLLL: "A",
-  // J, F, ..., D
-  LLLL: "W",
-  // January, February, ..., December
-  LLL: "Aaa",
-  // Jan, Feb, ..., Dec
-  LL: "##",
-  // 01, 02, ..., 12
-  L: "#n",
-  // 1, 2, ..., 12
-  // Local week of year (w tokens)
-  ww: "##",
-  // 01, 02, ..., 53
-  w: "#n",
-  // 1, 2, ..., 53
-  // Day of month (d tokens)
-  dd: "##",
-  // 01, 02, ..., 31
-  d: "#n",
-  // 1, 2, ..., 31
-  // Day of week (formatting) using E tokens
-  EEEEEE: "Aa",
-  // Mo, Tu, We, Th, Fr, Sa, Su
-  EEEEE: "A",
-  // M, T, W, T, F, S, S
-  EEEE: "W",
-  // Monday, Tuesday, ..., Sunday
-  EEE: "Aaa",
-  // Mon, Tue, Wed, ..., Sun
-  EE: "Aaa",
-  // Mon, Tue, Wed, ..., Sun
-  E: "Aaa",
-  // Mon, Tue, Wed, ..., Sun
-  // Local day of week (formatting) using e tokens
-  eeeeee: "Aa",
-  // Mo, Tu, We, Th, Fr, Sa, Su
-  eeeee: "A",
-  // M, T, W, T, F, S, S
-  eeee: "W",
-  // Monday, Tuesday, ..., Sunday
-  eee: "Aaa",
-  // Mon, Tue, Wed, ..., Sun
-  ee: "##",
-  // 02, 03, ..., 01
-  e: "#",
-  // 2, 3, 4, ..., 1
-  // Local day of week (stand-alone) using c tokens
-  cccccc: "Aa",
-  // Mo, Tu, We, Th, Fr, Sa, Su
-  ccccc: "A",
-  // M, T, W, T, F, S, S
-  cccc: "W",
-  // Monday, Tuesday, ..., Sunday
-  ccc: "Aaa",
-  // Mon, Tue, Wed, ..., Sun
-  cc: "##",
-  // 02, 03, ..., 01
-  c: "#"
-  // 2, 3, 4, ..., 1
-}, o = {
-  // AM, PM (a tokens)
-  aaaaa: "a",
-  // a, p
-  aaaa: "a.a.",
-  // a.m., p.m.
-  aaa: "AA",
-  // AM, PM
-  aa: "AA",
-  // AM, PM
-  a: "AA",
-  // AM, PM
-  // AM, PM, noon, midnight (b tokens)
-  bbbbb: "a",
-  // a, p
-  bbbb: "a.a.",
-  // a.m., p.m.
-  bbb: "AA",
-  // AM, PM
-  bb: "AA",
-  // AM, PM
-  b: "AA",
-  // AM, PM
-  // Flexible day period (B tokens)
-  B: "S",
-  // AM, PM, noon, midnight
-  // Hour [1-12] (h tokens)
-  hh: "##",
-  // 01, 02, ..., 11, 12
-  h: "#n",
-  // 1, 2, ..., 11, 12
-  // Hour [0-23] (H tokens)
-  HH: "##",
-  // 00, 01, 02, ..., 23
-  H: "#n",
-  // 0, 1, 2, ..., 23
-  // Hour [0-11] (K tokens)
-  KK: "##",
-  // 01, 02, ..., 11, 00
-  K: "#n",
-  // 1, 2, ..., 11, 0
-  // Hour [1-24] (k tokens)
-  kk: "##",
-  // 24, 01, 02, ..., 23
-  k: "#n",
-  // 24, 1, 2, ..., 23
-  // Minute (m tokens)
-  mm: "##",
-  // 00, 01, ..., 59
-  m: "#n",
-  // 0, 1, ..., 59
-  // Second (s tokens)
-  ss: "##",
-  // 00, 01, ..., 59
-  s: "#n",
-  // 0, 1, ..., 59,
-  // Timezone (ISO-8601 with Z) – X tokens
-  XXXXX: ["-##:##", "+##:##", "-##:##:##", "+##:##:##", "Z"],
-  // -08:00, +05:30, Z, +12:34:56
-  XXXX: ["-####", "+####", "-######", "+######", "Z"],
-  // -0800, +0530, Z, +123456
-  XXX: ["-##:##", "+##:##", "Z"],
-  // -08:00, +05:30, Z
-  XX: ["-####", "+####", "Z"],
-  // -0800, +0530, Z
-  X: ["-##", "+##", "-####", "+####", "Z"],
-  // -08, +0530, Z
-  // Timezone (ISO-8601 without Z) – x tokens
-  xxxxx: ["-##:##", "+##:##", "-##:##:##", "+##:##:##"],
-  // -08:00, +05:30, +00:00, +12:34:56
-  xxxx: ["-####", "+####", "-######", "+######"],
-  // -0800, +0530, +0000, +123456
-  xxx: ["-##:##", "+##:##"],
-  // -08:00, +05:30, +00:00
-  xx: ["-####", "+####"],
-  // -0800, +0530, +0000
-  x: ["-##", "+##", "-####", "+####"]
-  // -08, +0530, +00
-}, d = {
-  ...c,
-  ...o
-}, s = {
-  // Calendar year (y)
-  y: "#",
-  // 44, 1, 1900, 2017, 9999
-  // Local week-numbering year (Y)
-  Y: "#",
-  // 44, 1, 1900, 2017, 9000
-  // Extended year (u)
-  u: ["-#", "#"],
-  // -43, 1, 1900, 2017, 9999, -999
-  // Day of year (D tokens)
-  D: "#"
-  // 1, 2, ..., 365, 366
-}, i = {
-  // Fraction of second (S tokens)
-  S: "#"
-  // 0, 1, ..., 9
-}, x = {
-  ...s,
-  ...i
-};
-function b(e) {
-  const a = e.replace(/(['"]).*?\1/g, ""), r = Object.keys(x).map((n) => `${n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}{1,4}`).join("|"), E = Object.keys(d).sort((n, t) => t.length - n.length).map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), M = `(${r}|${E})`, m = new RegExp(M, "g");
-  return a.match(m);
-}
-function Q(e) {
-  const a = b(e);
-  if (!a)
-    throw Error("Failed to tokenize format string.");
-  return a.some(u) && !a.some(p);
-}
-function p(e) {
-  return c[e] !== void 0 || A(e) && s[e[0]] !== void 0;
-}
-function u(e) {
-  return o[e] !== void 0 || A(e) && i[e[0]] !== void 0;
-}
-function A(e) {
-  return /^(\w)\1*$/.test(e);
-}
-export {
-  x as dynamicTokensMap,
-  Q as isTimeOnlyFormat,
-  A as isUnitRepetition,
-  d as staticTokensMap,
-  b as tokenizeFormat
-};

package/esm/utils/time.js

@@ -1,14 +0,0 @@
-function s(e) {
-  return e ? /hh/.test(e) || /a/.test(e) : !1;
-}
-function t(e) {
-  return e ? /hh|HH|mm|ss|a/.test(e) : !1;
-}
-function n(e) {
-  return e ? /ss/.test(e) : !1;
-}
-export {
-  n as formatUsesSeconds,
-  t as formatUsesTime,
-  s as uses12HourFormat
-};