@progress/kendo-vue-inputs 5.3.0-dev.202409130647 → 5.3.0-develop.1

package/maskedtextbox/MaskedTextBox.mjs

@@ -0,0 +1,386 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+import { defineComponent as y, ref as b, h as c, createVNode as n } from "vue";
+import { MaskingService as C } from "./masking.service.mjs";
+import { defaultRules as h, maskingChanged as w, returnFalse as f } from "./utils.mjs";
+import { templateDefinition as m, validatePackage as x, guid as P, kendoThemeMaps as g, templateRendering as v, getListeners as $, getTemplate as S, Icon as o, getTabIndex as I, setRef as B } from "@progress/kendo-vue-common";
+import { packageMetadata as M } from "../package-metadata.mjs";
+import { checkIcon as L, exclamationCircleIcon as O, xIcon as R } from "@progress/kendo-svg-icons";
+const N = /* @__PURE__ */ y({
+  model: {
+    event: "changemodel"
+  },
+  emits: ["change", "focus", "blur", "update:modelValue", "update:modelRawValue", "changemodel"],
+  props: {
+    type: {
+      type: String,
+      default: "text"
+    },
+    modelValue: String,
+    modelRawValue: String,
+    value: String,
+    defaultValue: String,
+    placeholder: String,
+    title: String,
+    dir: String,
+    id: String,
+    ariaLabelledBy: String,
+    ariaDescribedBy: String,
+    tabIndex: Number,
+    accessKey: String,
+    disabled: Boolean,
+    readonly: Boolean,
+    size: {
+      type: String,
+      default: "medium",
+      validator: function(e) {
+        return [null, "small", "medium", "large"].includes(e);
+      }
+    },
+    rounded: {
+      type: String,
+      default: "medium",
+      validator: function(e) {
+        return [null, "small", "medium", "large", "full"].includes(e);
+      }
+    },
+    fillMode: {
+      type: String,
+      default: "solid",
+      validator: function(e) {
+        return [null, "solid", "flat", "outline"].includes(e);
+      }
+    },
+    prompt: {
+      type: String,
+      default: "_"
+    },
+    promptPlaceholder: {
+      type: String,
+      default: " "
+    },
+    includeLiterals: {
+      type: Boolean,
+      default: !1
+    },
+    maskValidation: {
+      type: Boolean,
+      default: !0
+    },
+    mask: String,
+    rules: {
+      type: Object,
+      default: function() {
+        return h;
+      }
+    },
+    selection: Object,
+    name: String,
+    label: String,
+    validationMessage: String,
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    valid: {
+      type: Boolean,
+      default: void 0
+    },
+    validityStyles: {
+      type: Boolean,
+      default: !0
+    },
+    iconName: String,
+    inputPrefix: m,
+    inputSuffix: m,
+    showValidationIcon: Boolean,
+    showLoadingIcon: Boolean,
+    showClearButton: Boolean,
+    inputClass: String,
+    wrapperClass: String
+  },
+  data() {
+    return {
+      currentValue: void 0,
+      currentFocused: !1,
+      inputValue: void 0,
+      currentSelection: [null, null]
+    };
+  },
+  created() {
+    x(M), this.hasMounted = !1, this.valueDuringOnChange = void 0, this.inputId = `k-${P()}`, this.service = new C(), this.isPasted = !1;
+  },
+  setup() {
+    return {
+      inputRef: b(null)
+    };
+  },
+  mounted() {
+    this.hasMounted = !0, this.element = this.input = this.inputRef, this.updateService(), this.setValidity();
+  },
+  watch: {
+    currentFocused: function(e, t) {
+      this.prevCurrentFocused = t;
+    },
+    selection: function(e, t) {
+      this.prevSelection = t;
+    },
+    includeLiterals: function(e, t) {
+      this.prevIncludeLiterals = t;
+    },
+    mask: function(e, t) {
+      this.prevMask = t;
+    },
+    prompt: function(e, t) {
+      this.prevPrompt = t;
+    },
+    promptPlaceholder: function(e, t) {
+      this.prevPromptPlaceholder = t;
+    },
+    rules: function(e, t) {
+      this.prevRules = t;
+    }
+  },
+  updated() {
+    if (this.element && this.currentFocused) {
+      let [t, i] = this.currentSelection;
+      const s = this.prevSelection, a = this.$props.selection;
+      (!s && a || s && a && (s.start !== a.start || s.end !== a.end)) && (t = a.start, i = a.end), t !== null && i !== null && this.element.setSelectionRange(t, i);
+    }
+    const e = {
+      includeLiterals: this.prevIncludeLiterals,
+      mask: this.prevMask,
+      prompt: this.prevPrompt,
+      promptPlaceholder: this.prevPromptPlaceholder,
+      rules: this.prevRules
+    };
+    w(e, this.$props) && this.updateService(), this.setValidity();
+  },
+  computed: {
+    computedRules() {
+      return Object.assign({}, h, this.$props.rules);
+    },
+    spanClassNames() {
+      const e = !this.hasMounted || !this.$props.validityStyles || this.validity().valid;
+      return {
+        "k-floating-label-container": !0,
+        "k-focus": this.currentFocused,
+        "k-empty": !this.computedValue(),
+        "k-invalid": !e && e !== void 0,
+        "k-rtl": this.$props.dir === "rtl",
+        "k-loading": this.showLoadingIcon,
+        [this.wrapperClass]: this.wrapperClass
+      };
+    },
+    wrapperSpanClass() {
+      const {
+        size: e,
+        fillMode: t,
+        rounded: i
+      } = this.$props, s = !this.$props.validityStyles || this.validity().valid;
+      return {
+        "k-maskedtextbox": !0,
+        "k-input": !0,
+        [`k-input-${g.sizeMap[e] || e}`]: e,
+        [`k-input-${t}`]: t,
+        [`k-rounded-${g.roundedMap[i] || i}`]: i,
+        "k-invalid": !s,
+        "k-required": this.required,
+        "k-disabled": this.$props.disabled,
+        "k-loading": this.showLoadingIcon,
+        [this.wrapperClass]: this.wrapperClass
+      };
+    },
+    inputInnerClass() {
+      return {
+        "k-input-inner": !0,
+        [this.inputClass]: this.inputClass
+      };
+    }
+  },
+  methods: {
+    focus() {
+      this.input && this.input.focus();
+    },
+    computedValue() {
+      let e;
+      return this.valueDuringOnChange !== void 0 ? e = this.valueDuringOnChange : this.$props.value !== void 0 ? e = this.$props.value : this.$props.modelValue !== void 0 ? e = this.$props.modelValue : this.currentValue !== void 0 ? e = this.currentValue : this.$props.defaultValue !== void 0 && (e = this.$props.defaultValue), e || "";
+    },
+    rawValue() {
+      return this.service.rawValue(this.computedValue());
+    },
+    validity() {
+      const e = this.computedValue(), t = this.service.validationValue(e), i = this.$props.validationMessage !== void 0, s = this.$props.valid !== void 0 ? this.$props.valid : (!this.$props.required || !!t) && (!this.$props.maskValidation || !this.$props.prompt || e.indexOf(this.$props.prompt) === -1);
+      return {
+        customError: i,
+        valid: s,
+        valueMissing: !t
+      };
+    },
+    pasteHandler(e) {
+      const {
+        selectionStart: t,
+        selectionEnd: i
+      } = e.target;
+      i !== t && (this.isPasted = !0, this.currentSelection = [t || 0, i || 0]);
+    },
+    clearClick(e) {
+      this.triggerOnChange("", e);
+    },
+    onChangeHandler(e) {
+      const t = e.currentTarget, i = this.inputValue = t.value, s = this.currentSelection[0] || 0, a = this.currentSelection[1] || 0;
+      if (!this.$props.mask) {
+        this.isPasted = !1, this.currentSelection = [null, null], this.triggerOnChange(i, e);
+        return;
+      }
+      const r = this.computedValue();
+      let l;
+      if (this.isPasted) {
+        this.isPasted = !1;
+        const u = r.length - a, p = i.length - u;
+        l = this.service.maskInRange(i.slice(s, p), r, s, a);
+      } else
+        l = this.service.maskInput(i, r, t.selectionStart || 0);
+      this.currentSelection = [l.selection, l.selection], this.triggerOnChange(l.value, e), this.inputValue = void 0;
+    },
+    focusHandler(e) {
+      this.currentFocused || (this.currentFocused = !0, this.$emit("focus", {
+        target: this,
+        event: e
+      }));
+    },
+    blurHandler(e) {
+      this.currentFocused && (this.currentFocused = !1, this.$emit("blur", {
+        target: this,
+        event: e
+      }));
+    },
+    triggerOnChange(e, t) {
+      this.currentValue = e, this.valueDuringOnChange = e, this.$emit("change", {
+        event: t,
+        selectionStart: this.currentSelection[0],
+        selectionEnd: this.currentSelection[1],
+        value: this.computedValue(),
+        component: this,
+        target: {
+          name: this.$props.name,
+          value: this.computedValue(),
+          rawValue: this.rawValue()
+        },
+        validity: this.validity()
+      }), this.$emit("update:modelValue", this.computedValue()), this.$emit("update:modelRawValue", this.rawValue()), this.$emit("changemodel", this.computedValue()), this.valueDuringOnChange = void 0;
+    },
+    updateService(e) {
+      const t = Object.assign({
+        includeLiterals: this.$props.includeLiterals,
+        mask: this.$props.mask,
+        prompt: this.$props.prompt,
+        promptPlaceholder: this.$props.promptPlaceholder,
+        rules: this.$props.rules
+      }, e);
+      this.service.update(t);
+    },
+    setValidity() {
+      this.element && this.element.setCustomValidity(this.validity().valid ? "" : this.$props.validationMessage || "");
+    }
+  },
+  render() {
+    const e = this.$props.id || this.inputId, {
+      iconName: t,
+      showValidationIcon: i,
+      showLoadingIcon: s,
+      showClearButton: a
+    } = this.$props, r = !this.$props.validityStyles || this.validity().valid, l = this.computedValue();
+    this.inputValue;
+    const u = v.call(this, this.$props.inputPrefix, $.call(this)), p = v.call(this, this.$props.inputSuffix, $.call(this)), k = S.call(this, {
+      h: c,
+      template: u,
+      additionalProps: {
+        value: l,
+        valid: r
+      }
+    }), V = S.call(this, {
+      h: c,
+      template: p,
+      additionalProps: {
+        value: l,
+        valid: r
+      }
+    }), d = n("span", {
+      dir: this.$props.dir,
+      class: this.wrapperSpanClass,
+      style: this.$props.label ? void 0 : {
+        width: this.$props.width
+      }
+    }, [t && n(o, {
+      name: t,
+      class: "k-input-icon"
+    }, null), this.$props.inputPrefix && n("span", {
+      class: "k-input-prefix"
+    }, [k]), n("input", {
+      type: this.$props.type,
+      autocomplete: "off",
+      autocorrect: "off",
+      autocapitalize: "off",
+      spellcheck: !1,
+      class: this.inputInnerClass,
+      value: l,
+      id: e,
+      "aria-labelledby": this.$props.ariaLabelledBy,
+      "aria-describedby": this.$props.ariaDescribedBy,
+      "aria-disabled": this.$props.disabled,
+      name: this.$props.name,
+      tabindex: I(this.$props.tabIndex, this.$props.disabled, !0),
+      accesskey: this.$props.accessKey,
+      title: this.$props.title,
+      disabled: this.$props.disabled || void 0,
+      readonly: this.$props.readonly || void 0,
+      placeholder: this.$props.placeholder,
+      "aria-placeholder": this.$props.placeholder,
+      required: this.$props.required,
+      ref: B(this, "input"),
+      onInput: this.onChangeHandler,
+      onPaste: this.pasteHandler,
+      onFocus: this.focusHandler,
+      onBlur: this.blurHandler,
+      onDragstart: f,
+      onDrop: f
+    }, null), this.$props.inputSuffix && n("span", {
+      class: "k-input-suffix"
+    }, [V]), i && r && n(o, {
+      name: "check",
+      icon: L,
+      class: "k-input-validation-icon"
+    }, null), i && !r && n(o, {
+      name: "exclamation-circle",
+      icon: O,
+      class: "k-input-validation-icon"
+    }, null), s && n(o, {
+      name: "loading",
+      class: "k-input-loading-icon"
+    }, null), a && l && n("span", {
+      onClick: this.clearClick,
+      class: "k-clear-value"
+    }, [n(o, {
+      name: "x",
+      icon: R
+    }, null)])]);
+    return this.$props.label ? n("span", {
+      class: this.spanClassNames,
+      dir: this.$props.dir
+    }, [d, this.$props.label ? e ? n("label", {
+      for: e,
+      class: "k-floating-label"
+    }, [this.$props.label]) : n("span", {
+      class: "k-label"
+    }, [this.$props.label]) : null]) : d;
+  }
+});
+export {
+  N as MaskedTextBox
+};

package/maskedtextbox/masking.service.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./parsing/combinators.js"),a=require("./parsing/parsers.js");class u{constructor(){this.rules={},this.prompt="_",this.mask="",this.promptPlaceholder=" ",this.includeLiterals=!1,this.maskTokens=[],this.unmaskTokens=[],this.rawTokens=[],this.validationTokens=[]}update({mask:e="",prompt:s="",promptPlaceholder:t=" ",rules:r={},includeLiterals:n=!1}){this.mask=e,this.prompt=s,this.promptPlaceholder=t,this.rules=r,this.includeLiterals=n,this.tokenize()}validationValue(e=""){let s=e;return i.sequence(this.validationTokens).run(e).fold(t=>{s=t.join("")}),s}rawValue(e=""){let s=e;return this.rawTokens.length&&i.sequence(this.rawTokens).run(e).fold(t=>{s=t.join("")}),s}maskRaw(e=""){let s=e;return this.maskTokens.length&&i.sequence(this.maskTokens).run(e).fold(t=>{s=t.join("")}),s}maskInput(e,s,t){return e.length<s.length?this.maskRemoved(e,s,t):this.maskInserted(e,s,t)}maskInRange(e,s,t,r){let n="",l=r;const o=s.split("").slice(0,t),h=s.split("").slice(r);return i.sequence(this.maskTokens.slice(t,r)).run(e).fold(k=>{n=o.concat(k).concat(h).join("")}),{selection:l,value:n}}maskRemoved(e,s,t){let r="",n=t;const l=e.split("").slice(t),o=e.split("").slice(0,t).join(""),h=this.maskTokens.length-(e.length-t);return i.sequence(this.maskTokens.slice(0,h)).run(o,s).fold(k=>{n=this.adjustPosition(k,n),r=k.concat(l).join("")}),{selection:n,value:r}}adjustPosition(e,s){const t=e[s];return!this.maskTokens[s].isLiteral(t)&&t!==this.prompt?s+1:s}maskInserted(e,s,t){let r="",n=t;const l=e.slice(0,t);return i.sequence(this.unmaskTokens).run(l,s).chain(o=>{n=o.join("").length;const h=s.slice(n);return i.sequence(this.maskTokens).run(o.join("")+h,s)}).fold(o=>{r=o.join("")}),{selection:n,value:r}}get maskTokenCreator(){const{prompt:e,promptPlaceholder:s}=this;return{literal:t=>a.literal(t),mask:t=>a.mask({prompt:e,promptPlaceholder:s})(t)}}get unmaskTokenCreator(){return{literal:e=>a.unliteral(e),mask:e=>a.unmask(this.prompt)(e)}}get rawTokenCreator(){const{prompt:e,promptPlaceholder:s,includeLiterals:t}=this;return{literal:r=>a.rawLiteral(t),mask:r=>a.rawMask({prompt:e,promptPlaceholder:s})}}get validationTokenCreator(){const{prompt:e}=this;return{literal:s=>a.rawLiteral(!1),mask:s=>a.rawMask({prompt:e,promptPlaceholder:""})}}tokenize(){i.greedy(a.token(this.rules,this.maskTokenCreator)).run(this.mask).fold((e,s)=>{this.maskTokens=e}),i.greedy(a.token(this.rules,this.unmaskTokenCreator)).run(this.mask).fold((e,s)=>{this.unmaskTokens=e}),i.greedy(a.token(this.rules,this.rawTokenCreator)).run(this.mask).fold((e,s)=>{this.rawTokens=e}),i.greedy(a.token(this.rules,this.validationTokenCreator)).run(this.mask).fold((e,s)=>{this.validationTokens=e})}}exports.MaskingService=u;

package/maskedtextbox/masking.service.mjs

@@ -0,0 +1,120 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+import { sequence as i, greedy as k } from "./parsing/combinators.mjs";
+import { literal as d, mask as T, unliteral as p, unmask as f, rawLiteral as m, rawMask as c, token as u } from "./parsing/parsers.mjs";
+class C {
+  constructor() {
+    this.rules = {}, this.prompt = "_", this.mask = "", this.promptPlaceholder = " ", this.includeLiterals = !1, this.maskTokens = [], this.unmaskTokens = [], this.rawTokens = [], this.validationTokens = [];
+  }
+  update({ mask: e = "", prompt: s = "", promptPlaceholder: t = " ", rules: r = {}, includeLiterals: n = !1 }) {
+    this.mask = e, this.prompt = s, this.promptPlaceholder = t, this.rules = r, this.includeLiterals = n, this.tokenize();
+  }
+  validationValue(e = "") {
+    let s = e;
+    return i(this.validationTokens).run(e).fold((t) => {
+      s = t.join("");
+    }), s;
+  }
+  rawValue(e = "") {
+    let s = e;
+    return this.rawTokens.length && i(this.rawTokens).run(e).fold((t) => {
+      s = t.join("");
+    }), s;
+  }
+  /**
+   * @hidden
+   */
+  maskRaw(e = "") {
+    let s = e;
+    return this.maskTokens.length && i(this.maskTokens).run(e).fold((t) => {
+      s = t.join("");
+    }), s;
+  }
+  maskInput(e, s, t) {
+    return e.length < s.length ? this.maskRemoved(e, s, t) : this.maskInserted(e, s, t);
+  }
+  maskInRange(e, s, t, r) {
+    let n = "", o = r;
+    const a = s.split("").slice(0, t), l = s.split("").slice(r);
+    return i(this.maskTokens.slice(t, r)).run(e).fold((h) => {
+      n = a.concat(h).concat(l).join("");
+    }), {
+      selection: o,
+      value: n
+    };
+  }
+  maskRemoved(e, s, t) {
+    let r = "", n = t;
+    const o = e.split("").slice(t), a = e.split("").slice(0, t).join(""), l = this.maskTokens.length - (e.length - t);
+    return i(this.maskTokens.slice(0, l)).run(a, s).fold((h) => {
+      n = this.adjustPosition(h, n), r = h.concat(o).join("");
+    }), {
+      selection: n,
+      value: r
+    };
+  }
+  adjustPosition(e, s) {
+    const t = e[s];
+    return !this.maskTokens[s].isLiteral(t) && t !== this.prompt ? s + 1 : s;
+  }
+  maskInserted(e, s, t) {
+    let r = "", n = t;
+    const o = e.slice(0, t);
+    return i(this.unmaskTokens).run(o, s).chain((a) => {
+      n = a.join("").length;
+      const l = s.slice(n);
+      return i(this.maskTokens).run(a.join("") + l, s);
+    }).fold((a) => {
+      r = a.join("");
+    }), {
+      selection: n,
+      value: r
+    };
+  }
+  get maskTokenCreator() {
+    const { prompt: e, promptPlaceholder: s } = this;
+    return {
+      literal: (t) => d(t),
+      mask: (t) => T({ prompt: e, promptPlaceholder: s })(t)
+    };
+  }
+  get unmaskTokenCreator() {
+    return {
+      literal: (e) => p(e),
+      mask: (e) => f(this.prompt)(e)
+    };
+  }
+  get rawTokenCreator() {
+    const { prompt: e, promptPlaceholder: s, includeLiterals: t } = this;
+    return {
+      literal: (r) => m(t),
+      mask: (r) => c({ prompt: e, promptPlaceholder: s })
+    };
+  }
+  get validationTokenCreator() {
+    const { prompt: e } = this;
+    return {
+      literal: (s) => m(!1),
+      mask: (s) => c({ prompt: e, promptPlaceholder: "" })
+    };
+  }
+  tokenize() {
+    k(u(this.rules, this.maskTokenCreator)).run(this.mask).fold((e, s) => {
+      this.maskTokens = e;
+    }), k(u(this.rules, this.unmaskTokenCreator)).run(this.mask).fold((e, s) => {
+      this.unmaskTokens = e;
+    }), k(u(this.rules, this.rawTokenCreator)).run(this.mask).fold((e, s) => {
+      this.rawTokens = e;
+    }), k(u(this.rules, this.validationTokenCreator)).run(this.mask).fold((e, s) => {
+      this.validationTokens = e;
+    });
+  }
+}
+export {
+  C as MaskingService
+};

package/maskedtextbox/parsing/combinators.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./parsers.js"),s=require("./result.js"),u=n=>new t.Parser(e=>new s.Result(n,e)),o=(n,e)=>n.chain(r=>e.map(c=>r.concat([c]))),a=n=>n.reduce((e,r)=>o(e,r),u([])),l=n=>new t.Parser(e=>{let r=new s.Result([],e);for(;!e.eof();)r=r.concat(n.run(e));return r});exports.greedy=l;exports.sequence=a;

package/maskedtextbox/parsing/combinators.mjs

@@ -0,0 +1,19 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+import { Parser as c } from "./parsers.mjs";
+import { Result as r } from "./result.mjs";
+const s = (n) => new c((e) => new r(n, e)), a = (n, e) => n.chain((o) => e.map((t) => o.concat([t]))), w = (n) => n.reduce((e, o) => a(e, o), s([])), l = (n) => new c((e) => {
+  let o = new r([], e);
+  for (; !e.eof(); )
+    o = o.concat(n.run(e));
+  return o;
+});
+export {
+  l as greedy,
+  w as sequence
+};

package/maskedtextbox/parsing/parsers.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("./result.js"),w=require("./stream.js"),c=l=>(l||"").split(""),a="\\";class i{constructor(e){this.parse=e}run(e,n=""){return e instanceof w.Stream?this.parse(e):this.parse(new w.Stream(c(e),c(n)))}map(e){return new i(n=>this.parse(n).map(e))}chain(e){return new i(n=>this.parse(n).chain((t,r)=>e(t).run(r)))}isLiteral(e){return this.run(e).type===u.ResultType.Literal}}const R=({prompt:l,promptPlaceholder:e})=>n=>new i(t=>{for(;!t.eof();){const{char:r,control:s}=t.peek();if(r===s&&s===l)return t.eat(),new u.Result(l,t,u.ResultType.Mask);if(n.test(r))return t.eat(),new u.Result(r,t,u.ResultType.Mask);if(r===e)return t.eat(),new u.Result(l,t,u.ResultType.Mask);t.eat_input()}return t.eat(),new u.Result(l,t,u.ResultType.Mask)}),o=l=>new i(e=>e.peek().char===l?(e.eat(),new u.Result(l,e,u.ResultType.Literal)):new u.Result(l,e,u.ResultType.Literal)),h=l=>e=>new i(n=>{for(;!n.eof();){const{char:t,control:r}=n.peek();if(t===l&&r===l)return n.eat(),new u.Result(t,n);if(e.test(t))return n.eat(),new u.Result(t,n);n.eat_input()}return n.eat(),new u.Result("",n)}),f=l=>new i(e=>{if(e.eof())return new u.Result("",e);const{char:n}=e.peek();return n===l&&e.eat(),new u.Result(l,e)}),k=(l,e)=>new i(n=>{let{char:t}=n.next();const r=l[t];return t===a?(t=n.next().char,new u.Result(e.literal(t),n)):r?new u.Result(e.mask(r),n):new u.Result(e.literal(t),n)}),p=({prompt:l,promptPlaceholder:e})=>new i(n=>{let{char:t}=n.next();return t===l?new u.Result(e,n):new u.Result(t,n)}),y=l=>new i(e=>{let{char:n}=e.next();return l?new u.Result(n,e):new u.Result("",e)});exports.Parser=i;exports.literal=o;exports.mask=R;exports.rawLiteral=y;exports.rawMask=p;exports.token=k;exports.unliteral=f;exports.unmask=h;

package/maskedtextbox/parsing/parsers.mjs

@@ -0,0 +1,77 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+import { Result as i, ResultType as c } from "./result.mjs";
+import { Stream as o } from "./stream.mjs";
+const h = (r) => (r || "").split(""), f = "\\";
+class w {
+  constructor(n) {
+    this.parse = n;
+  }
+  run(n, e = "") {
+    return n instanceof o ? this.parse(n) : this.parse(new o(h(n), h(e)));
+  }
+  // map :: Functor f => f a ~> (a -> b) -> f b
+  map(n) {
+    return new w((e) => this.parse(e).map(n));
+  }
+  // chain :: Chain m => m a ~> (a -> m b) -> m b
+  chain(n) {
+    return new w((e) => this.parse(e).chain((t, u) => n(t).run(u)));
+  }
+  isLiteral(n) {
+    return this.run(n).type === c.Literal;
+  }
+}
+const p = ({ prompt: r, promptPlaceholder: n }) => (e) => new w((t) => {
+  for (; !t.eof(); ) {
+    const { char: u, control: l } = t.peek();
+    if (u === l && l === r)
+      return t.eat(), new i(r, t, c.Mask);
+    if (e.test(u))
+      return t.eat(), new i(u, t, c.Mask);
+    if (u === n)
+      return t.eat(), new i(r, t, c.Mask);
+    t.eat_input();
+  }
+  return t.eat(), new i(r, t, c.Mask);
+}), s = (r) => new w((n) => n.peek().char === r ? (n.eat(), new i(r, n, c.Literal)) : new i(r, n, c.Literal)), x = (r) => (n) => new w((e) => {
+  for (; !e.eof(); ) {
+    const { char: t, control: u } = e.peek();
+    if (t === r && u === r)
+      return e.eat(), new i(t, e);
+    if (n.test(t))
+      return e.eat(), new i(t, e);
+    e.eat_input();
+  }
+  return e.eat(), new i("", e);
+}), L = (r) => new w((n) => {
+  if (n.eof())
+    return new i("", n);
+  const { char: e } = n.peek();
+  return e === r && n.eat(), new i(r, n);
+}), M = (r, n) => new w((e) => {
+  let { char: t } = e.next();
+  const u = r[t];
+  return t === f ? (t = e.next().char, new i(n.literal(t), e)) : u ? new i(n.mask(u), e) : new i(n.literal(t), e);
+}), A = ({ prompt: r, promptPlaceholder: n }) => new w((e) => {
+  let { char: t } = e.next();
+  return t === r ? new i(n, e) : new i(t, e);
+}), R = (r) => new w((n) => {
+  let { char: e } = n.next();
+  return r ? new i(e, n) : new i("", n);
+});
+export {
+  w as Parser,
+  s as literal,
+  p as mask,
+  R as rawLiteral,
+  A as rawMask,
+  M as token,
+  L as unliteral,
+  x as unmask
+};

package/maskedtextbox/parsing/result.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var a=(r=>(r[r.Literal=0]="Literal",r[r.Mask=1]="Mask",r[r.Undefined=2]="Undefined",r))(a||{});class s{constructor(t,e,i=2){this.value=t,this.rest=e,this.type=i}map(t){return new s(t(this.value),this.rest)}chain(t){return t(this.value,this.rest)}fold(t){return t(this.value,this.rest)}concat(t){return this.map((e,i)=>t.chain((n,h)=>e.concat([n])))}toString(){return`Result({ value: '${this.value}', rest: ${this.rest} })`}}exports.Result=s;exports.ResultType=a;

package/maskedtextbox/parsing/result.mjs

@@ -0,0 +1,34 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+var n = /* @__PURE__ */ ((r) => (r[r.Literal = 0] = "Literal", r[r.Mask = 1] = "Mask", r[r.Undefined = 2] = "Undefined", r))(n || {});
+class a {
+  constructor(t, i, s = 2) {
+    this.value = t, this.rest = i, this.type = s;
+  }
+  // map :: Functor f => f a ~> (a -> b) -> f b
+  map(t) {
+    return new a(t(this.value), this.rest);
+  }
+  // chain :: Chain m => m a ~> (a -> m b) -> m b
+  chain(t) {
+    return t(this.value, this.rest);
+  }
+  fold(t) {
+    return t(this.value, this.rest);
+  }
+  concat(t) {
+    return this.map((i, s) => t.chain((e, h) => i.concat([e])));
+  }
+  toString() {
+    return `Result({ value: '${this.value}', rest: ${this.rest} })`;
+  }
+}
+export {
+  a as Result,
+  n as ResultType
+};