@vkzstudio/muza-ui 1.0.0 → 1.0.1

package/dist/node_modules/imask/esm/core/action-details.js

@@ -0,0 +1,51 @@
+import { DIRECTION as t } from "./utils.js";
+class o {
+  /** Current input value */
+  /** Current cursor position */
+  /** Old input value */
+  /** Old selection */
+  constructor(s) {
+    for (Object.assign(this, s); this.value.slice(0, this.startChangePos) !== this.oldValue.slice(0, this.startChangePos); )
+      --this.oldSelection.start;
+    if (this.insertedCount)
+      for (; this.value.slice(this.cursorPos) !== this.oldValue.slice(this.oldSelection.end); )
+        this.value.length - this.cursorPos < this.oldValue.length - this.oldSelection.end ? ++this.oldSelection.end : ++this.cursorPos;
+  }
+  /** Start changing position */
+  get startChangePos() {
+    return Math.min(this.cursorPos, this.oldSelection.start);
+  }
+  /** Inserted symbols count */
+  get insertedCount() {
+    return this.cursorPos - this.startChangePos;
+  }
+  /** Inserted symbols */
+  get inserted() {
+    return this.value.substr(this.startChangePos, this.insertedCount);
+  }
+  /** Removed symbols count */
+  get removedCount() {
+    return Math.max(this.oldSelection.end - this.startChangePos || // for Delete
+    this.oldValue.length - this.value.length, 0);
+  }
+  /** Removed symbols */
+  get removed() {
+    return this.oldValue.substr(this.startChangePos, this.removedCount);
+  }
+  /** Unchanged head symbols */
+  get head() {
+    return this.value.substring(0, this.startChangePos);
+  }
+  /** Unchanged tail symbols */
+  get tail() {
+    return this.value.substring(this.startChangePos + this.insertedCount);
+  }
+  /** Remove direction */
+  get removeDirection() {
+    return !this.removedCount || this.insertedCount ? t.NONE : (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) && // if not range removed (event with backspace)
+    this.oldSelection.end === this.oldSelection.start ? t.RIGHT : t.LEFT;
+  }
+}
+export {
+  o as default
+};

package/dist/node_modules/imask/esm/core/change-details.js

@@ -0,0 +1,36 @@
+import i from "./holder.js";
+class s {
+  /** Inserted symbols */
+  /** Additional offset if any changes occurred before tail */
+  /** Raw inserted is used by dynamic mask */
+  /** Can skip chars */
+  static normalize(t) {
+    return Array.isArray(t) ? t : [t, new s()];
+  }
+  constructor(t) {
+    Object.assign(this, {
+      inserted: "",
+      rawInserted: "",
+      tailShift: 0,
+      skip: !1
+    }, t);
+  }
+  /** Aggregate changes */
+  aggregate(t) {
+    return this.inserted += t.inserted, this.rawInserted += t.rawInserted, this.tailShift += t.tailShift, this.skip = this.skip || t.skip, this;
+  }
+  /** Total offset considering all changes */
+  get offset() {
+    return this.tailShift + this.inserted.length;
+  }
+  get consumed() {
+    return !!this.rawInserted || this.skip;
+  }
+  equals(t) {
+    return this.inserted === t.inserted && this.tailShift === t.tailShift && this.rawInserted === t.rawInserted && this.skip === t.skip;
+  }
+}
+i.ChangeDetails = s;
+export {
+  s as default
+};

package/dist/node_modules/imask/esm/core/continuous-tail-details.js

@@ -0,0 +1,42 @@
+class h {
+  /** Tail value as string */
+  /** Tail start position */
+  /** Start position */
+  constructor(t, i, s) {
+    t === void 0 && (t = ""), i === void 0 && (i = 0), this.value = t, this.from = i, this.stop = s;
+  }
+  toString() {
+    return this.value;
+  }
+  extend(t) {
+    this.value += String(t);
+  }
+  appendTo(t) {
+    return t.append(this.toString(), {
+      tail: !0
+    }).aggregate(t._appendPlaceholder());
+  }
+  get state() {
+    return {
+      value: this.value,
+      from: this.from,
+      stop: this.stop
+    };
+  }
+  set state(t) {
+    Object.assign(this, t);
+  }
+  unshift(t) {
+    if (!this.value.length || t != null && this.from >= t) return "";
+    const i = this.value[0];
+    return this.value = this.value.slice(1), i;
+  }
+  shift() {
+    if (!this.value.length) return "";
+    const t = this.value[this.value.length - 1];
+    return this.value = this.value.slice(0, -1), t;
+  }
+}
+export {
+  h as default
+};

package/dist/node_modules/imask/esm/core/holder.js

@@ -0,0 +1,6 @@
+function a(n, t) {
+  return new a.InputMask(n, t);
+}
+export {
+  a as default
+};

package/dist/node_modules/imask/esm/core/utils.js

@@ -0,0 +1,67 @@
+function p(e) {
+  return typeof e == "string" || e instanceof String;
+}
+function E(e) {
+  var t;
+  return typeof e == "object" && e != null && (e == null || (t = e.constructor) == null ? void 0 : t.name) === "Object";
+}
+function a(e, t) {
+  return Array.isArray(t) ? a(e, (n, i) => t.includes(i)) : Object.entries(e).reduce((n, i) => {
+    let [r, f] = i;
+    return t(f, r) && (n[r] = f), n;
+  }, {});
+}
+const o = {
+  NONE: "NONE",
+  LEFT: "LEFT",
+  FORCE_LEFT: "FORCE_LEFT",
+  RIGHT: "RIGHT",
+  FORCE_RIGHT: "FORCE_RIGHT"
+};
+function R(e) {
+  switch (e) {
+    case o.LEFT:
+      return o.FORCE_LEFT;
+    case o.RIGHT:
+      return o.FORCE_RIGHT;
+    default:
+      return e;
+  }
+}
+function O(e) {
+  return e.replace(/([.*+?^=!:${}()|[\]/\\])/g, "\\$1");
+}
+function g(e, t) {
+  if (t === e) return !0;
+  const n = Array.isArray(t), i = Array.isArray(e);
+  let r;
+  if (n && i) {
+    if (t.length != e.length) return !1;
+    for (r = 0; r < t.length; r++) if (!g(t[r], e[r])) return !1;
+    return !0;
+  }
+  if (n != i) return !1;
+  if (t && e && typeof t == "object" && typeof e == "object") {
+    const f = t instanceof Date, c = e instanceof Date;
+    if (f && c) return t.getTime() == e.getTime();
+    if (f != c) return !1;
+    const s = t instanceof RegExp, l = e instanceof RegExp;
+    if (s && l) return t.toString() == e.toString();
+    if (s != l) return !1;
+    const u = Object.keys(t);
+    for (r = 0; r < u.length; r++) if (!Object.prototype.hasOwnProperty.call(e, u[r])) return !1;
+    for (r = 0; r < u.length; r++) if (!g(e[u[r]], t[u[r]])) return !1;
+    return !0;
+  } else if (t && e && typeof t == "function" && typeof e == "function")
+    return t.toString() === e.toString();
+  return !1;
+}
+export {
+  o as DIRECTION,
+  O as escapeRegExp,
+  R as forceDirection,
+  E as isObject,
+  p as isString,
+  g as objectIncludes,
+  a as pick
+};

package/dist/node_modules/imask/esm/index.js

@@ -0,0 +1,50 @@
+import { default as f } from "./controls/input.js";
+import e from "./core/holder.js";
+import { default as p } from "./controls/html-contenteditable-mask-element.js";
+import { default as d } from "./controls/html-input-mask-element.js";
+import { default as u } from "./controls/html-mask-element.js";
+import { default as n } from "./controls/mask-element.js";
+import { default as k } from "./core/change-details.js";
+import { default as E } from "./masked/base.js";
+import { default as I } from "./masked/date.js";
+import { default as T } from "./masked/dynamic.js";
+import { default as D } from "./masked/enum.js";
+import { default as h, normalizeOpts as H } from "./masked/factory.js";
+import { default as R } from "./masked/function.js";
+import { default as C } from "./masked/number.js";
+import { default as B } from "./masked/pattern.js";
+import { default as N } from "./masked/pattern/input-definition.js";
+import { PIPE_TYPE as Y, createPipe as _, pipe as j } from "./masked/pipe.js";
+import { default as v } from "./masked/range.js";
+import { default as A } from "./masked/regexp.js";
+import { default as J } from "./masked/repeat.js";
+import "./controls/input-history.js";
+try {
+  globalThis.IMask = e;
+} catch {
+}
+export {
+  k as ChangeDetails,
+  p as HTMLContenteditableMaskElement,
+  d as HTMLInputMaskElement,
+  u as HTMLMaskElement,
+  f as InputMask,
+  n as MaskElement,
+  E as Masked,
+  I as MaskedDate,
+  T as MaskedDynamic,
+  D as MaskedEnum,
+  R as MaskedFunction,
+  C as MaskedNumber,
+  B as MaskedPattern,
+  v as MaskedRange,
+  A as MaskedRegExp,
+  Y as PIPE_TYPE,
+  N as PatternInputDefinition,
+  J as RepeatBlock,
+  h as createMask,
+  _ as createPipe,
+  e as default,
+  H as normalizeOpts,
+  j as pipe
+};

package/dist/node_modules/imask/esm/masked/base.js

@@ -0,0 +1,252 @@
+import h from "../core/change-details.js";
+import f from "../core/continuous-tail-details.js";
+import { isString as v, DIRECTION as o, objectIncludes as V, forceDirection as I } from "../core/utils.js";
+import _ from "../core/holder.js";
+class p {
+  /** */
+  /** */
+  /** Transforms value before mask processing */
+  /** Transforms each char before mask processing */
+  /** Validates if value is acceptable */
+  /** Does additional processing at the end of editing */
+  /** Format typed value to string */
+  /** Parse string to get typed value */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  /** */
+  constructor(t) {
+    this._value = "", this._update({
+      ...p.DEFAULTS,
+      ...t
+    }), this._initialized = !0;
+  }
+  /** Sets and applies new options */
+  updateOptions(t) {
+    this.optionsIsChanged(t) && this.withValueRefresh(this._update.bind(this, t));
+  }
+  /** Sets new options */
+  _update(t) {
+    Object.assign(this, t);
+  }
+  /** Mask state */
+  get state() {
+    return {
+      _value: this.value,
+      _rawInputValue: this.rawInputValue
+    };
+  }
+  set state(t) {
+    this._value = t._value;
+  }
+  /** Resets value */
+  reset() {
+    this._value = "";
+  }
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    this.resolve(t, {
+      input: !0
+    });
+  }
+  /** Resolve new value */
+  resolve(t, e) {
+    e === void 0 && (e = {
+      input: !0
+    }), this.reset(), this.append(t, e, ""), this.doCommit();
+  }
+  get unmaskedValue() {
+    return this.value;
+  }
+  set unmaskedValue(t) {
+    this.resolve(t, {});
+  }
+  get typedValue() {
+    return this.parse ? this.parse(this.value, this) : this.unmaskedValue;
+  }
+  set typedValue(t) {
+    this.format ? this.value = this.format(t, this) : this.unmaskedValue = String(t);
+  }
+  /** Value that includes raw user input */
+  get rawInputValue() {
+    return this.extractInput(0, this.displayValue.length, {
+      raw: !0
+    });
+  }
+  set rawInputValue(t) {
+    this.resolve(t, {
+      raw: !0
+    });
+  }
+  get displayValue() {
+    return this.value;
+  }
+  get isComplete() {
+    return !0;
+  }
+  get isFilled() {
+    return this.isComplete;
+  }
+  /** Finds nearest input position in direction */
+  nearestInputPos(t, e) {
+    return t;
+  }
+  totalInputPositions(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), Math.min(this.displayValue.length, e - t);
+  }
+  /** Extracts value in range considering flags */
+  extractInput(t, e, i) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), this.displayValue.slice(t, e);
+  }
+  /** Extracts tail in range */
+  extractTail(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), new f(this.extractInput(t, e), t);
+  }
+  /** Appends tail */
+  appendTail(t) {
+    return v(t) && (t = new f(String(t))), t.appendTo(this);
+  }
+  /** Appends char */
+  _appendCharRaw(t, e) {
+    return t ? (this._value += t, new h({
+      inserted: t,
+      rawInserted: t
+    })) : new h();
+  }
+  /** Appends char */
+  _appendChar(t, e, i) {
+    e === void 0 && (e = {});
+    const s = this.state;
+    let a;
+    if ([t, a] = this.doPrepareChar(t, e), t && (a = a.aggregate(this._appendCharRaw(t, e)), !a.rawInserted && this.autofix === "pad")) {
+      const n = this.state;
+      this.state = s;
+      let r = this.pad(e);
+      const l = this._appendCharRaw(t, e);
+      r = r.aggregate(l), l.rawInserted || r.equals(a) ? a = r : this.state = n;
+    }
+    if (a.inserted) {
+      let n, r = this.doValidate(e) !== !1;
+      if (r && i != null) {
+        const l = this.state;
+        if (this.overwrite === !0) {
+          n = i.state;
+          for (let d = 0; d < a.rawInserted.length; ++d)
+            i.unshift(this.displayValue.length - a.tailShift);
+        }
+        let u = this.appendTail(i);
+        if (r = u.rawInserted.length === i.toString().length, !(r && u.inserted) && this.overwrite === "shift") {
+          this.state = l, n = i.state;
+          for (let d = 0; d < a.rawInserted.length; ++d)
+            i.shift();
+          u = this.appendTail(i), r = u.rawInserted.length === i.toString().length;
+        }
+        r && u.inserted && (this.state = l);
+      }
+      r || (a = new h(), this.state = s, i && n && (i.state = n));
+    }
+    return a;
+  }
+  /** Appends optional placeholder at the end */
+  _appendPlaceholder() {
+    return new h();
+  }
+  /** Appends optional eager placeholder at the end */
+  _appendEager() {
+    return new h();
+  }
+  /** Appends symbols considering flags */
+  append(t, e, i) {
+    if (!v(t)) throw new Error("value should be string");
+    const s = v(i) ? new f(String(i)) : i;
+    e != null && e.tail && (e._beforeTailState = this.state);
+    let a;
+    [t, a] = this.doPrepare(t, e);
+    for (let n = 0; n < t.length; ++n) {
+      const r = this._appendChar(t[n], e, s);
+      if (!r.rawInserted && !this.doSkipInvalid(t[n], e, s)) break;
+      a.aggregate(r);
+    }
+    return (this.eager === !0 || this.eager === "append") && e != null && e.input && t && a.aggregate(this._appendEager()), s != null && (a.tailShift += this.appendTail(s).tailShift), a;
+  }
+  remove(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), this._value = this.displayValue.slice(0, t) + this.displayValue.slice(e), new h();
+  }
+  /** Calls function and reapplies current value */
+  withValueRefresh(t) {
+    if (this._refreshing || !this._initialized) return t();
+    this._refreshing = !0;
+    const e = this.rawInputValue, i = this.value, s = t();
+    return this.rawInputValue = e, this.value && this.value !== i && i.indexOf(this.value) === 0 && (this.append(i.slice(this.displayValue.length), {}, ""), this.doCommit()), delete this._refreshing, s;
+  }
+  runIsolated(t) {
+    if (this._isolated || !this._initialized) return t(this);
+    this._isolated = !0;
+    const e = this.state, i = t(this);
+    return this.state = e, delete this._isolated, i;
+  }
+  doSkipInvalid(t, e, i) {
+    return !!this.skipInvalid;
+  }
+  /** Prepares string before mask processing */
+  doPrepare(t, e) {
+    return e === void 0 && (e = {}), h.normalize(this.prepare ? this.prepare(t, this, e) : t);
+  }
+  /** Prepares each char before mask processing */
+  doPrepareChar(t, e) {
+    return e === void 0 && (e = {}), h.normalize(this.prepareChar ? this.prepareChar(t, this, e) : t);
+  }
+  /** Validates if value is acceptable */
+  doValidate(t) {
+    return (!this.validate || this.validate(this.value, this, t)) && (!this.parent || this.parent.doValidate(t));
+  }
+  /** Does additional processing at the end of editing */
+  doCommit() {
+    this.commit && this.commit(this.value, this);
+  }
+  splice(t, e, i, s, a) {
+    i === void 0 && (i = ""), s === void 0 && (s = o.NONE), a === void 0 && (a = {
+      input: !0
+    });
+    const n = t + e, r = this.extractTail(n), l = this.eager === !0 || this.eager === "remove";
+    let u;
+    l && (s = I(s), u = this.extractInput(0, n, {
+      raw: !0
+    }));
+    let d = t;
+    const g = new h();
+    if (s !== o.NONE && (d = this.nearestInputPos(t, e > 1 && t !== 0 && !l ? o.NONE : s), g.tailShift = d - t), g.aggregate(this.remove(d)), l && s !== o.NONE && u === this.rawInputValue)
+      if (s === o.FORCE_LEFT) {
+        let w;
+        for (; u === this.rawInputValue && (w = this.displayValue.length); )
+          g.aggregate(new h({
+            tailShift: -1
+          })).aggregate(this.remove(w - 1));
+      } else s === o.FORCE_RIGHT && r.unshift();
+    return g.aggregate(this.append(i, a, r));
+  }
+  maskEquals(t) {
+    return this.mask === t;
+  }
+  optionsIsChanged(t) {
+    return !V(this, t);
+  }
+  typedValueEquals(t) {
+    const e = this.typedValue;
+    return t === e || p.EMPTY_VALUES.includes(t) && p.EMPTY_VALUES.includes(e) || (this.format ? this.format(t, this) === this.format(this.typedValue, this) : !1);
+  }
+  pad(t) {
+    return new h();
+  }
+}
+p.DEFAULTS = {
+  skipInvalid: !0
+};
+p.EMPTY_VALUES = [void 0, null, ""];
+_.Masked = p;
+export {
+  p as default
+};

package/dist/node_modules/imask/esm/masked/date.js

@@ -0,0 +1,117 @@
+import u from "./pattern.js";
+import m from "./range.js";
+import l from "../core/holder.js";
+import { isString as o } from "../core/utils.js";
+import "../core/change-details.js";
+import "./base.js";
+import "./factory.js";
+import "./pattern/input-definition.js";
+import "./regexp.js";
+const d = "d{.}`m{.}`Y";
+class r extends u {
+  static extractPatternOptions(t) {
+    const {
+      mask: e,
+      pattern: s,
+      ...n
+    } = t;
+    return {
+      ...n,
+      mask: o(e) ? e : s
+    };
+  }
+  /** Pattern mask for date according to {@link MaskedDate#format} */
+  /** Start date */
+  /** End date */
+  /** Format typed value to string */
+  /** Parse string to get typed value */
+  constructor(t) {
+    super(r.extractPatternOptions({
+      ...r.DEFAULTS,
+      ...t
+    }));
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    const {
+      mask: e,
+      pattern: s,
+      blocks: n,
+      ...p
+    } = {
+      ...r.DEFAULTS,
+      ...t
+    }, a = Object.assign({}, r.GET_DEFAULT_BLOCKS());
+    t.min && (a.Y.from = t.min.getFullYear()), t.max && (a.Y.to = t.max.getFullYear()), t.min && t.max && a.Y.from === a.Y.to && (a.m.from = t.min.getMonth() + 1, a.m.to = t.max.getMonth() + 1, a.m.from === a.m.to && (a.d.from = t.min.getDate(), a.d.to = t.max.getDate())), Object.assign(a, this.blocks, n), super._update({
+      ...p,
+      mask: o(e) ? e : s,
+      blocks: a
+    });
+  }
+  doValidate(t) {
+    const e = this.date;
+    return super.doValidate(t) && (!this.isComplete || this.isDateExist(this.value) && e != null && (this.min == null || this.min <= e) && (this.max == null || e <= this.max));
+  }
+  /** Checks if date is exists */
+  isDateExist(t) {
+    return this.format(this.parse(t, this), this).indexOf(t) >= 0;
+  }
+  /** Parsed Date */
+  get date() {
+    return this.typedValue;
+  }
+  set date(t) {
+    this.typedValue = t;
+  }
+  get typedValue() {
+    return this.isComplete ? super.typedValue : null;
+  }
+  set typedValue(t) {
+    super.typedValue = t;
+  }
+  maskEquals(t) {
+    return t === Date || super.maskEquals(t);
+  }
+  optionsIsChanged(t) {
+    return super.optionsIsChanged(r.extractPatternOptions(t));
+  }
+}
+r.GET_DEFAULT_BLOCKS = () => ({
+  d: {
+    mask: m,
+    from: 1,
+    to: 31,
+    maxLength: 2
+  },
+  m: {
+    mask: m,
+    from: 1,
+    to: 12,
+    maxLength: 2
+  },
+  Y: {
+    mask: m,
+    from: 1900,
+    to: 9999
+  }
+});
+r.DEFAULTS = {
+  ...u.DEFAULTS,
+  mask: Date,
+  pattern: d,
+  format: (i, t) => {
+    if (!i) return "";
+    const e = String(i.getDate()).padStart(2, "0"), s = String(i.getMonth() + 1).padStart(2, "0"), n = i.getFullYear();
+    return [e, s, n].join(".");
+  },
+  parse: (i, t) => {
+    const [e, s, n] = i.split(".").map(Number);
+    return new Date(n, s - 1, e);
+  }
+};
+l.MaskedDate = r;
+export {
+  r as default
+};