mlform 0.1.0

package/dist/src/strategies/app/index.d.ts

@@ -0,0 +1,7 @@
+export { BooleanStrategy } from './BooleanStrategy';
+export { CategoryStrategy } from './CategoryStrategy';
+export { ClassifierStrategy } from './ClassifierStrategy';
+export { DateStrategy } from './DateStrategy';
+export { NumberStrategy } from './NumberStrategy';
+export { RegressorStrategy } from './RegressorStrategy';
+export { TextStrategy } from './TextStrategy';

package/dist/src/strategies/domain/BooleanField.d.ts

@@ -0,0 +1,10 @@
+import { FieldTypes } from './FieldTypes';
+import * as z from "zod";
+export declare const BooleanFieldSchema: z.ZodObject<{
+    type: z.ZodLiteral<FieldTypes.BOOLEAN>;
+    value: z.ZodOptional<z.ZodBoolean>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type BooleanField = z.infer<typeof BooleanFieldSchema>;

package/dist/src/strategies/domain/CategoryField.d.ts

@@ -0,0 +1,11 @@
+import { FieldTypes } from './FieldTypes';
+import * as z from "zod";
+export declare const CategoryFieldSchema: z.ZodObject<{
+    type: z.ZodLiteral<FieldTypes.CATEGORY>;
+    value: z.ZodOptional<z.ZodString>;
+    options: z.ZodArray<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type CategoryField = z.infer<typeof CategoryFieldSchema>;

package/dist/src/strategies/domain/ClassifierModel.d.ts

@@ -0,0 +1,11 @@
+import { ModelTypes } from './ModelTypes';
+import * as z from "zod";
+export declare const ClassifierModelSchema: z.ZodObject<{
+    type: z.ZodLiteral<ModelTypes.CLASSIFIER>;
+    mapping: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    probabilities: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+    details: z.ZodDefault<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    execution_time: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ClassifierModel = z.infer<typeof ClassifierModelSchema>;

package/dist/src/strategies/domain/DateField.d.ts

@@ -0,0 +1,13 @@
+import { FieldTypes } from './FieldTypes';
+import * as z from "zod";
+export declare const DateFieldSchema: z.ZodObject<{
+    type: z.ZodLiteral<FieldTypes.DATE>;
+    value: z.ZodOptional<z.ZodISODateTime>;
+    min: z.ZodOptional<z.ZodISODateTime>;
+    max: z.ZodOptional<z.ZodISODateTime>;
+    step: z.ZodOptional<z.ZodDefault<z.ZodInt>>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type DateField = z.infer<typeof DateFieldSchema>;

package/dist/src/strategies/domain/FieldTypes.d.ts

@@ -0,0 +1,7 @@
+export declare enum FieldTypes {
+    TEXT = "text",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    CATEGORY = "category",
+    DATE = "date"
+}

package/dist/src/strategies/domain/ModelTypes.d.ts

@@ -0,0 +1,4 @@
+export declare enum ModelTypes {
+    REGRESSOR = "regressor",
+    CLASSIFIER = "classifier"
+}

package/dist/src/strategies/domain/NumberField.d.ts

@@ -0,0 +1,15 @@
+import { FieldTypes } from './FieldTypes';
+import * as z from "zod";
+export declare const NumberFieldSchema: z.ZodObject<{
+    type: z.ZodLiteral<FieldTypes.NUMBER>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type NumberField = z.infer<typeof NumberFieldSchema>;

package/dist/src/strategies/domain/RegressorModel.d.ts

@@ -0,0 +1,11 @@
+import { ModelTypes } from './ModelTypes';
+import * as z from "zod";
+export declare const RegressorModelSchema: z.ZodObject<{
+    type: z.ZodLiteral<ModelTypes.REGRESSOR>;
+    values: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    unit: z.ZodOptional<z.ZodString>;
+    interval: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    title: z.ZodOptional<z.ZodString>;
+    execution_time: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type RegressorModel = z.infer<typeof RegressorModelSchema>;

package/dist/src/strategies/domain/TextField.d.ts

@@ -0,0 +1,14 @@
+import { FieldTypes } from './FieldTypes';
+import * as z from "zod";
+export declare const TextFieldSchema: z.ZodObject<{
+    type: z.ZodLiteral<FieldTypes.TEXT>;
+    value: z.ZodOptional<z.ZodString>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodInt>;
+    maxLength: z.ZodOptional<z.ZodInt>;
+    pattern: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type TextField = z.infer<typeof TextFieldSchema>;

package/dist/src/strategies/domain/index.d.ts

@@ -0,0 +1,9 @@
+export { type BooleanField, BooleanFieldSchema } from './BooleanField';
+export { type CategoryField, CategoryFieldSchema } from './CategoryField';
+export { type ClassifierModel, ClassifierModelSchema } from './ClassifierModel';
+export { type DateField, DateFieldSchema } from './DateField';
+export { FieldTypes } from './FieldTypes';
+export { ModelTypes } from './ModelTypes';
+export { type NumberField, NumberFieldSchema } from './NumberField';
+export { type RegressorModel, RegressorModelSchema } from './RegressorModel';
+export { type TextField, TextFieldSchema } from './TextField';

package/dist/src/strategies/index.d.ts

@@ -0,0 +1 @@
+export { BooleanStrategy, CategoryStrategy, ClassifierStrategy, DateStrategy, NumberStrategy, RegressorStrategy, TextStrategy, } from './app';

package/dist/src/strategies/ui/boolean-field.d.ts

@@ -0,0 +1,13 @@
+import { FieldElement } from '../../extensions/ui';
+export declare class BooleanField extends FieldElement<boolean> {
+    static styles: import('lit').CSSResultGroup[];
+    defaultValue: string;
+    firstUpdated(): void;
+    private onChange;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "boolean-field": BooleanField;
+    }
+}

package/dist/src/strategies/ui/category-field.d.ts

@@ -0,0 +1,14 @@
+import { FieldElement } from '../../extensions/ui';
+export declare class CategoryField extends FieldElement<string> {
+    static styles: import('lit').CSSResultGroup[];
+    optionList: string[];
+    defaultValue: string;
+    firstUpdated(): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private handleChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "category-field": CategoryField;
+    }
+}

package/dist/src/strategies/ui/classifier-prediction.d.ts

@@ -0,0 +1,39 @@
+import { LitElement } from 'lit';
+/**
+ * <classifier-prediction>
+ * --------------------------------------------------
+ * Visualiza las predicciones de un clasificador.
+ * - `mapping`          → lista de etiquetas CSV
+ * - `probabilities`    → array plano o matriz de probabilidades
+ * - `details`          → modo detallado (true) o compacto (false)
+ * - `title`            → título del bloque
+ *
+ * Ejemplo de uso:
+ * <classifier-prediction
+ *   title="Vehicle type"
+ *   mapping="Car,Motorcycle,Train"
+ *   probabilities="0.12,0.68,0.20"
+ *   details="true">
+ * </classifier-prediction>
+ * --------------------------------------------------
+ */
+type FlatProbs = number[];
+type MatrixProbs = number[][];
+export declare class ClassifierPrediction extends LitElement {
+    static styles: import('lit').CSSResult;
+    title: string;
+    mapping: string[];
+    probabilities: FlatProbs | MatrixProbs;
+    details: boolean;
+    private _resolveMapping;
+    private _flatToMatrix;
+    private get _probMatrix();
+    private get _predictions();
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "classifier-prediction": ClassifierPrediction;
+    }
+}
+export {};

package/dist/src/strategies/ui/date-field.d.ts

@@ -0,0 +1,18 @@
+import { FieldElement } from '../../extensions/ui';
+export declare class DateField extends FieldElement<Date> {
+    static styles: import('lit').CSSResultGroup[];
+    step: string;
+    min: Date;
+    max: Date;
+    defaultValue: Date;
+    protected firstUpdated(): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private onInput;
+    private startOfDayUTC;
+    private formatDateUTC;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "date-field": DateField;
+    }
+}

package/dist/src/strategies/ui/index.d.ts

@@ -0,0 +1,8 @@
+export { BooleanField } from './boolean-field';
+export { CategoryField } from './category-field';
+export { ClassifierPrediction } from './classifier-prediction';
+export { DateField } from './date-field';
+export { NumberField } from './number-field';
+export { RangeField } from './range-field';
+export { RegressorPrediction } from './regressor-prediction';
+export { TextField } from './text-field';

package/dist/src/strategies/ui/number-field.d.ts

@@ -0,0 +1,19 @@
+import { FieldElement } from '../../extensions/ui';
+export declare class NumberField extends FieldElement<number> {
+    static styles: import('lit').CSSResultGroup[];
+    unit: string;
+    step: string;
+    min: string;
+    max: string;
+    defaultValue: string;
+    placeholder: string;
+    firstUpdated(): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private onInput;
+    private parseLocaleNumber;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "number-field": NumberField;
+    }
+}

package/dist/src/strategies/ui/range-field.d.ts

@@ -0,0 +1,17 @@
+import { FieldElement } from '../../extensions/ui';
+export declare class RangeField extends FieldElement<number> {
+    static styles: import('lit').CSSResultGroup[];
+    unit: string;
+    step: string;
+    min: string;
+    max: string;
+    defaultValue: string;
+    protected firstUpdated(): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private onInput;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "range-field": RangeField;
+    }
+}

package/dist/src/strategies/ui/regressor-prediction.d.ts

@@ -0,0 +1,29 @@
+import { LitElement } from 'lit';
+/**
+ * <regressor-prediction>
+ * – Barra ±3 × (max-min) con gradiente lineal continuo.
+ * – Límites representados con marcadores más finos que sobresalen verticalmente
+ *   respecto a la barra.
+ * – Etiquetas de los límites alineadas directamente bajo su marcador.
+ */
+export declare class RegressorPrediction extends LitElement {
+    static styles: import('lit').CSSResult;
+    title: string;
+    values: number[];
+    unit: string;
+    interval: [number, number];
+    private min;
+    private max;
+    protected firstUpdated(): void;
+    private _barExtents;
+    private _hasInterval;
+    private _calcPercent;
+    /** Gradiente lineal continuo: rojo → naranja → amarillo → verde → amarillo → naranja → rojo */
+    private _buildGradient;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "regressor-prediction": RegressorPrediction;
+    }
+}

package/dist/src/strategies/ui/text-field.d.ts

@@ -0,0 +1,17 @@
+import { FieldElement } from '../../extensions/ui';
+export declare class TextField extends FieldElement<string> {
+    static styles: import('lit').CSSResultGroup[];
+    placeholder: string;
+    pattern: string;
+    defaultValue: string;
+    minlength: string;
+    maxlength: string;
+    firstUpdated(): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private onInput;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "text-field": TextField;
+    }
+}

package/dist/state-CLlTRyl1.js

@@ -0,0 +1,12 @@
+import { n as r } from "./property-jKFNMQpR.js";
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+function n(t) {
+  return r({ ...t, state: !0, attribute: !1 });
+}
+export {
+  n as r
+};

package/dist/test/_fixtures/DummyField.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { DescriptorItem } from '../../src/core/app/DescriptorItem';
+export declare class DummyField {
+    readonly type: string;
+    readonly schema: z.ZodString;
+    readonly comment: string;
+    constructor(type?: string, schema?: z.ZodString, comment?: string);
+    buildDescriptor(payload: Record<string, unknown>): DescriptorItem;
+}

package/dist/test/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/DummyField.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/text-field-DwP-Fa1w.js

@@ -0,0 +1,114 @@
+import { FieldElement as u } from "./mlform/extensions.mjs";
+import { x as m, a as d, n as l } from "./property-jKFNMQpR.js";
+import { t as c } from "./custom-element-ttkHUa8w.js";
+var p = Object.defineProperty, g = Object.getOwnPropertyDescriptor, v = (t, e, r) => e in t ? p(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, a = (t, e, r, h) => {
+  for (var n = h > 1 ? void 0 : h ? g(e, r) : e, s = t.length - 1, o; s >= 0; s--)
+    (o = t[s]) && (n = (h ? o(e, r, n) : o(n)) || n);
+  return h && n && p(e, r, n), n;
+}, f = (t, e, r) => v(t, e + "", r);
+let i = class extends u {
+  placeholder = "Enter text...";
+  pattern = "";
+  firstUpdated() {
+    if (this.defaultValue) {
+      this.value = this.defaultValue, console.log(this.value);
+      const t = new InputEvent("input", {
+        bubbles: !0,
+        composed: !0
+      });
+      Object.defineProperty(t, "target", {
+        value: { value: this.defaultValue },
+        writable: !1
+      }), this.onInput(t);
+    } else
+      this.value = "";
+  }
+  render() {
+    return m`
+      <div class="input-wrapper">
+        <input
+          type="text"
+          autocomplete="off"
+          @input=${this.onInput}
+          .value=${this.value}
+          .placeholder=${this.placeholder}
+          .minlength=${this.minlength}
+          .maxlength=${this.maxlength}
+        />
+      </div>
+    `;
+  }
+  onInput(t) {
+    if (this.value = t.target.value, this.value === "") {
+      this.dispatchState("empty");
+      return;
+    }
+    if (this.minlength && this.maxlength && this.value.length < Number(this.minlength) && this.value.length > Number(this.maxlength)) {
+      this.dispatchState(
+        "error",
+        `Length must be between ${this.minlength} and ${this.maxlength} characters.`
+      );
+      return;
+    }
+    if (this.minlength && this.value.length < Number(this.minlength)) {
+      this.dispatchState(
+        "error",
+        `Minimum length is ${this.minlength} characters.`
+      );
+      return;
+    }
+    if (this.maxlength && this.value.length > Number(this.maxlength)) {
+      this.dispatchState(
+        "error",
+        `Maximum length of ${this.maxlength} characters exceeded.`
+      );
+      return;
+    }
+    if (this.pattern !== "" && !new RegExp(this.pattern).test(this.value)) {
+      this.dispatchState("error", "Invalid characters detected.");
+      return;
+    }
+    this.dispatchState(
+      "success",
+      this.maxlength ? `Note recorded (${this.value.length}/${this.maxlength}).` : `Note recorded (Length: ${this.value.length}).`
+    );
+  }
+};
+f(i, "styles", [
+  u.baseStyles,
+  d`
+      input[type="text"] {
+        width: 100%;
+        padding: 0.75rem 1rem;
+        font-size: 1rem;
+        border: 1px solid var(--ml-color-border);
+        border-radius: var(--radius);
+        outline: none;
+        transition: border-color 0.2s ease;
+      }
+      input[type="text"]:focus {
+        border-color: var(--ml-color-accent);
+      }
+    `
+]);
+a([
+  l({ type: String })
+], i.prototype, "placeholder", 2);
+a([
+  l({ type: String })
+], i.prototype, "pattern", 2);
+a([
+  l({ type: String })
+], i.prototype, "defaultValue", 2);
+a([
+  l({ type: String })
+], i.prototype, "minlength", 2);
+a([
+  l({ type: String })
+], i.prototype, "maxlength", 2);
+i = a([
+  c("text-field")
+], i);
+export {
+  i as TextField
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "mlform",
+  "version": "0.1.0",
+  "license": "MIT",
+  "author": "UlloaSP <ulloasantinpablo2@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UlloaSP/mlform"
+  },
+  "private": false,
+  "type": "module",
+  "files": ["dist/**"],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mlform.mjs"
+    },
+    "./extensions": {
+      "types": "./dist/types/extensions/index.d.ts",
+      "import": "./dist/mlform/extensions.mjs"
+    },
+    "./strategies": {
+      "types": "./dist/types/strategies/index.d.ts",
+      "import": "./dist/mlform/strategies.mjs"
+    }
+  },
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "packageManager": "npm@11.5.1",
+  "scripts": {
+    "lint": "npx @biomejs/biome check --write",
+    "type": "tsc -p tsconfig.json --noEmit",
+    "build": "vite build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "link": "npm run build && npm link",
+    "ci": "npm run lint && npm run type && npm run test && npm run build"
+  },
+  "dependencies": {
+    "lit": "3.3.1",
+    "zod": "4.0.10"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.1.2",
+    "@types/node": "^24.1.0",
+    "globals": "^16.3.0",
+    "jsdom": "^26.1.0",
+    "rollup-plugin-visualizer": "^6.0.3",
+    "typescript": "~5.8.3",
+    "vite": "^7.0.6",
+    "vitest": "^3.2.4",
+    "vite-plugin-dts": "^4.5.4",
+    "@vitest/coverage-v8": "^3.2.4"
+  }
+}