mlform 0.1.0

package/dist/mlform/extensions.mjs

@@ -0,0 +1,38 @@
+import { F as h } from "../FieldStrategy-pPekBtH-.js";
+import { B as x, a as y, R as C } from "../ReportStrategy-DY3GC_mJ.js";
+import { i as o, a as l } from "../property-jKFNMQpR.js";
+import { r as d } from "../state-CLlTRyl1.js";
+var p = Object.defineProperty, c = (s, t, a, m) => {
+  for (var e = void 0, r = s.length - 1, i; r >= 0; r--)
+    (i = s[r]) && (e = i(t, a, e) || e);
+  return e && p(t, a, e), e;
+};
+class n extends o {
+  static baseStyles = l`
+    * {
+      box-sizing: border-box;
+    }
+  `;
+  connectedCallback() {
+    super.connectedCallback(), this.value = void 0, this.dispatchState("empty");
+  }
+  dispatchState(t, a = "") {
+    this.dispatchEvent(
+      new CustomEvent("field-state", {
+        detail: { state: t, message: a, value: this.value },
+        bubbles: !0,
+        composed: !0
+      })
+    );
+  }
+}
+c([
+  d()
+], n.prototype, "value");
+export {
+  x as BaseFieldSchema,
+  y as BaseModelSchema,
+  n as FieldElement,
+  h as FieldStrategy,
+  C as ReportStrategy
+};

package/dist/mlform/strategies.mjs

@@ -0,0 +1,292 @@
+import { s as i, o as a, e as o, b as E, d as r, a as u, n, i as d, f as h, t as M, F as l } from "../FieldStrategy-pPekBtH-.js";
+import { F as s, M as p } from "../ModelTypes-B9_veCKB.js";
+import { B as m, a as S, R as A } from "../ReportStrategy-DY3GC_mJ.js";
+const T = i({
+  ...m.shape,
+  type: o(s.BOOLEAN),
+  value: a(E())
+}), _ = "The value must match one of the allowed options", L = (e, t) => !(t === void 0 || e.includes(t)), b = i({
+  ...m.shape,
+  type: o(s.CATEGORY),
+  value: a(u()),
+  options: r(u()).min(1)
+}).check((e) => {
+  L(e.value.options, e.value.value) && e.issues.push({
+    code: "custom",
+    path: ["value"],
+    message: _,
+    input: e.value,
+    continue: !0
+  });
+}), y = i({
+  ...S.shape,
+  type: o(p.CLASSIFIER),
+  mapping: a(r(u().min(1))),
+  probabilities: a(
+    r(r(n().min(0).max(1)).min(1)).min(1)
+  ),
+  details: E().default(!1)
+}), N = "The minimum date must be earlier than or equal to the maximum date", R = "The selected date must be later than or equal to the minimum date", O = "The selected date must be earlier than or equal to the maximum date", v = (e, t) => !(e === void 0 || t === void 0 || new Date(e) <= new Date(t)), I = i({
+  ...m.shape,
+  type: o(s.DATE),
+  value: a(h()),
+  min: a(h()),
+  max: a(h()),
+  step: a(d().min(1).default(1))
+}).check((e) => {
+  v(e.value.min, e.value.max) && e.issues.push({
+    code: "custom",
+    path: ["min"],
+    message: N,
+    input: e.value,
+    continue: !0
+  }), v(e.value.value, e.value.max) && e.issues.push({
+    code: "custom",
+    path: ["value"],
+    message: O,
+    input: e.value,
+    continue: !0
+  }), v(e.value.min, e.value.value) && e.issues.push({
+    code: "custom",
+    path: ["min"],
+    message: R,
+    input: e.value,
+    continue: !0
+  });
+}), C = "The minimum value must be less than or equal to the maximum value", G = "The selected value must be greater than or equal to the minimum value", f = "The selected value must be less than or equal to the maximum value", c = (e, t) => !(e === void 0 || t === void 0 || e <= t), V = i({
+  ...m.shape,
+  type: o(s.NUMBER),
+  min: a(n()),
+  max: a(n()),
+  step: a(n().positive().default(1)),
+  placeholder: a(u()),
+  value: a(n()),
+  unit: a(u())
+}).check((e) => {
+  c(e.value.min, e.value.max) && e.issues.push({
+    code: "custom",
+    path: ["min"],
+    message: C,
+    input: e.value,
+    continue: !0
+  }), c(e.value.min, e.value.value) && e.issues.push({
+    code: "custom",
+    path: ["min"],
+    message: G,
+    input: e.value,
+    continue: !0
+  }), c(e.value.value, e.value.max) && e.issues.push({
+    code: "custom",
+    path: ["value"],
+    message: f,
+    input: e.value,
+    continue: !0
+  });
+}), B = i({
+  ...S.shape,
+  type: o(p.REGRESSOR),
+  values: a(r(n()).min(1)),
+  unit: a(u()),
+  interval: a(M([n(), n()]))
+}), D = "Invalid regex pattern", F = "Minimum length must be less than or equal to maximum length", U = "Minimum length is <<minLength>> characters", X = "Maximum length of <<maxLength>> characters exceeded.", q = (e) => {
+  if (e === void 0) return !0;
+  try {
+    return new RegExp(e), !0;
+  } catch {
+    return !1;
+  }
+}, g = (e, t) => !(e === void 0 || t === void 0 || e <= t), w = i({
+  ...m.shape,
+  type: o(s.TEXT),
+  value: a(u()),
+  placeholder: a(u()),
+  minLength: a(d().min(0)),
+  maxLength: a(d().min(0)),
+  pattern: a(u())
+}).check((e) => {
+  q(e.value.pattern) || e.issues.push({
+    code: "custom",
+    message: D,
+    input: e.value,
+    continue: !0
+  }), g(e.value.minLength, e.value.maxLength) && e.issues.push({
+    code: "custom",
+    path: ["minLength"],
+    message: F,
+    input: e.value,
+    continue: !0
+  }), g(e.value.minLength, e.value.value?.length) && e.issues.push({
+    code: "custom",
+    path: ["minLength"],
+    message: U.replace(
+      "<<minLength>>",
+      e.value.minLength?.toString() || "0"
+    ),
+    input: e.value,
+    continue: !0
+  }), g(e.value.value?.length, e.value.maxLength) && e.issues.push({
+    code: "custom",
+    path: ["value"],
+    message: X.replace(
+      "<<maxLength>>",
+      e.value.maxLength?.toString() || "infinity"
+    ),
+    input: e.value,
+    continue: !0
+  });
+});
+class j extends l {
+  constructor() {
+    super(
+      s.BOOLEAN,
+      T,
+      () => import("../boolean-field-Cd3uhIPj.js")
+    );
+  }
+  buildControl(t) {
+    return {
+      tag: "boolean-field",
+      props: {
+        defaultValue: t.value !== void 0 ? String(t.value) : void 0
+      }
+    };
+  }
+}
+class $ extends l {
+  constructor() {
+    super(
+      s.CATEGORY,
+      b,
+      () => import("../category-field-D_Ms1x9u.js")
+    );
+  }
+  buildControl(t) {
+    return {
+      tag: "category-field",
+      props: {
+        defaultValue: t.value ?? "",
+        optionList: t.options
+      }
+    };
+  }
+}
+class z extends A {
+  constructor() {
+    super(
+      p.CLASSIFIER,
+      y,
+      () => import("../classifier-prediction-C5QzorTo.js")
+    );
+  }
+  buildControl(t) {
+    return {
+      tag: "classifier-prediction",
+      props: {
+        title: t.title,
+        mapping: t.mapping,
+        probabilities: t.probabilities,
+        details: t.details.toString()
+      }
+    };
+  }
+}
+class H extends l {
+  constructor() {
+    super(
+      s.DATE,
+      I,
+      () => import("../date-field-Cg_ja679.js")
+    );
+  }
+  buildControl(t) {
+    return {
+      tag: "date-field",
+      props: {
+        min: t.min ? new Date(t.min).toISOString() : void 0,
+        max: t.max ? new Date(t.max).toISOString() : void 0,
+        step: t.step,
+        defaultValue: t.value ? new Date(t.value).toISOString() : void 0
+      }
+    };
+  }
+}
+class J extends l {
+  constructor() {
+    super(s.NUMBER, V, async () => {
+      await Promise.resolve(), import("../range-field-Cr7LEtsJ.js"), import("../number-field-CC2DrVEb.js");
+    });
+  }
+  buildControl(t) {
+    return t.min != null && t.max != null && !t.required && t.value != null ? {
+      tag: "range-field",
+      props: {
+        unit: t.unit,
+        min: t.min,
+        max: t.max,
+        step: t.step,
+        defaultValue: t.value
+      },
+      slot: "inputs"
+    } : {
+      tag: "number-field",
+      props: {
+        unit: t.unit,
+        min: t.min,
+        max: t.max,
+        step: t.step,
+        defaultValue: t.value,
+        placeholder: t.placeholder
+      }
+    };
+  }
+}
+class K extends A {
+  constructor() {
+    super(
+      p.REGRESSOR,
+      B,
+      () => import("../regressor-prediction-C18dHlfK.js")
+    );
+  }
+  buildControl(t) {
+    return {
+      tag: "regressor-prediction",
+      props: {
+        title: t.title,
+        values: t.values,
+        unit: t.unit,
+        interval: t.interval
+      }
+    };
+  }
+}
+class Q extends l {
+  constructor() {
+    super(
+      s.TEXT,
+      w,
+      () => import("../text-field-DwP-Fa1w.js")
+    );
+  }
+  buildControl(t) {
+    return {
+      tag: "text-field",
+      props: {
+        minlength: t.minLength,
+        maxlength: t.maxLength,
+        placeholder: t.placeholder,
+        defaultValue: t.value,
+        pattern: t.pattern
+      }
+    };
+  }
+}
+export {
+  j as BooleanStrategy,
+  $ as CategoryStrategy,
+  z as ClassifierStrategy,
+  H as DateStrategy,
+  J as NumberStrategy,
+  K as RegressorStrategy,
+  Q as TextStrategy
+};