tiny-essentials 1.24.0 → 1.24.1

package/dist/v1/libs/TinyHtml/input/TinyHtmlFileInput.mjs

@@ -0,0 +1,92 @@
+import TinyHtmlInput from '../TinyHtmlInput.mjs';
+/**
+ * TinyHtmlFileInput is a helper class for managing <input type="file"> elements.
+ * It allows configuring attributes such as `accept`, `multiple`, `capture`,
+ * `readonly`, and `required` with validation, while exposing a safe getter for files.
+ *
+ * @example
+ * const fileInput = new TinyHtmlFileInput({
+ *   accept: '.png,.jpg',
+ *   multiple: true,
+ *   required: true
+ * });
+ *
+ * document.body.appendChild(fileInput.el);
+ *
+ * @extends TinyHtmlInput
+ */
+class TinyHtmlFileInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlFileInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {string} [config.name] - The name of the input control.
+     * @param {string} [config.placeholder] - Placeholder text (not widely supported for file inputs).
+     * @param {string|boolean} [config.capture] - Capture mode ("user", "environment", or `true`).
+     * @param {boolean} [config.multiple=false] - Whether multiple files can be selected.
+     * @param {string} [config.accept] - Accepted file types (e.g., ".jpg,.png" or "image/*").
+     * @param {boolean} [config.readonly=false] - Whether the input is read-only.
+     * @param {boolean} [config.required=false] - Whether the input is required.
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+     * @param {string} [config.mainClass=''] - Main CSS class.
+     * @throws {TypeError} If any attribute is of the wrong type.
+     */
+    constructor({ name, capture, multiple = false, accept, placeholder, readonly = false, required = false, tags = [], mainClass = '', } = {}) {
+        super({ type: 'file', name, placeholder, tags, mainClass, readonly, required });
+        // --- multiple ---
+        this.multiple = multiple;
+        // --- accept ---
+        if (accept !== undefined)
+            this.accept = accept;
+        // --- capture ---
+        if (capture !== undefined)
+            this.capture = capture;
+    }
+    /** @param {boolean} multiple */
+    set multiple(multiple) {
+        if (typeof multiple !== 'boolean')
+            throw new TypeError('TinyHtmlFileInput: "multiple" must be a boolean.');
+        if (multiple)
+            this.addProp('multiple');
+        else
+            this.removeProp('multiple');
+    }
+    /** @returns {boolean} */
+    get multiple() {
+        return this.hasProp('multiple');
+    }
+    /** @param {string} accept */
+    set accept(accept) {
+        if (typeof accept !== 'string')
+            throw new TypeError('TinyHtmlFileInput: "accept" must be a string.');
+        this.setAttr('accept', accept);
+    }
+    /** @returns {string|null} */
+    get accept() {
+        return this.attrString('accept');
+    }
+    /** @param {string|boolean} capture */
+    set capture(capture) {
+        if (typeof capture !== 'string' && typeof capture !== 'boolean')
+            throw new TypeError('TinyHtmlFileInput: "capture" must be a string or boolean.');
+        this.setAttr('capture', capture);
+    }
+    /** @returns {string|boolean|null} */
+    get capture() {
+        const val = this.attrString('capture');
+        if (val === null)
+            return null;
+        if (val === 'true')
+            return true;
+        if (val === 'false')
+            return false;
+        return val;
+    }
+    /**
+     * Gets the list of selected files.
+     * @returns {FileList|null}
+     */
+    get files() {
+        return this.el.files;
+    }
+}
+export default TinyHtmlFileInput;

package/dist/v1/libs/TinyHtml/input/TinyHtmlHiddenInput.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+var TinyHtmlInput = require('../TinyHtmlInput.cjs');
+
+/**
+ * TinyHtmlHiddenInput is a helper class for managing
+ * <input type="hidden"> elements. It provides validation
+ * and structured getters/setters for common attributes.
+ *
+ * @example
+ * const hidden = new TinyHtmlHiddenInput({
+ *   name: 'csrf_token',
+ *   value: '12345',
+ *   required: true
+ * });
+ *
+ * @extends TinyHtmlInput
+ */
+class TinyHtmlHiddenInput extends TinyHtmlInput {
+  /**
+   * Creates a new TinyHtmlHiddenInput instance.
+   * @param {Object} config - Configuration object.
+   * @param {string|number} [config.value] - Initial value of the input.
+   * @param {string} [config.name] - The name of the control.
+   * @param {string} [config.autocomplete] - Autocomplete hint (e.g., "on", "off", "email").
+   * @param {string} [config.dirname] - Directionality field name (for text-based inputs).
+   * @param {boolean} [config.readonly=false] - Whether the input is read-only.
+   * @param {boolean} [config.required=false] - Whether the input is required.
+   * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+   * @param {string} [config.mainClass=''] - Main CSS class.
+   * @throws {TypeError} If any attribute is of the wrong type.
+   */
+  constructor({
+    name,
+    value,
+    dirname,
+    autocomplete,
+    readonly = false,
+    required = false,
+    tags = [],
+    mainClass = '',
+  } = {}) {
+    super({ type: 'hidden', name, tags, mainClass });
+
+    if (value !== undefined) this.value = value;
+    if (autocomplete !== undefined) this.autocomplete = autocomplete;
+    if (dirname !== undefined) this.dirname = dirname;
+    this.readonly = readonly;
+    this.required = required;
+  }
+
+  /** @param {string|number} value */
+  set value(value) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+      throw new TypeError('TinyHtmlHiddenInput: "value" must be a string or number.');
+    this.setAttr('value', String(value));
+  }
+
+  /** @returns {string|null} */
+  get value() {
+    return this.attrString('value');
+  }
+
+  /** @param {string} name */
+  set name(name) {
+    if (typeof name !== 'string')
+      throw new TypeError('TinyHtmlHiddenInput: "name" must be a string.');
+    this.setAttr('name', name);
+  }
+
+  /** @returns {string|null} */
+  get name() {
+    return this.attrString('name');
+  }
+
+  /** @param {string} autocomplete */
+  set autocomplete(autocomplete) {
+    if (typeof autocomplete !== 'string')
+      throw new TypeError('TinyHtmlHiddenInput: "autocomplete" must be a string.');
+    this.setAttr('autocomplete', autocomplete);
+  }
+
+  /** @returns {string|null} */
+  get autocomplete() {
+    return this.attrString('autocomplete');
+  }
+
+  /** @param {string} dirname */
+  set dirname(dirname) {
+    if (typeof dirname !== 'string')
+      throw new TypeError('TinyHtmlHiddenInput: "dirname" must be a string.');
+    this.setAttr('dirname', dirname);
+  }
+
+  /** @returns {string|null} */
+  get dirname() {
+    return this.attrString('dirname');
+  }
+}
+
+module.exports = TinyHtmlHiddenInput;

package/dist/v1/libs/TinyHtml/input/TinyHtmlHiddenInput.d.mts

@@ -0,0 +1,54 @@
+export default TinyHtmlHiddenInput;
+/**
+ * TinyHtmlHiddenInput is a helper class for managing
+ * <input type="hidden"> elements. It provides validation
+ * and structured getters/setters for common attributes.
+ *
+ * @example
+ * const hidden = new TinyHtmlHiddenInput({
+ *   name: 'csrf_token',
+ *   value: '12345',
+ *   required: true
+ * });
+ *
+ * @extends TinyHtmlInput
+ */
+declare class TinyHtmlHiddenInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlHiddenInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {string|number} [config.value] - Initial value of the input.
+     * @param {string} [config.name] - The name of the control.
+     * @param {string} [config.autocomplete] - Autocomplete hint (e.g., "on", "off", "email").
+     * @param {string} [config.dirname] - Directionality field name (for text-based inputs).
+     * @param {boolean} [config.readonly=false] - Whether the input is read-only.
+     * @param {boolean} [config.required=false] - Whether the input is required.
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+     * @param {string} [config.mainClass=''] - Main CSS class.
+     * @throws {TypeError} If any attribute is of the wrong type.
+     */
+    constructor({ name, value, dirname, autocomplete, readonly, required, tags, mainClass, }?: {
+        value?: string | number | undefined;
+        name?: string | undefined;
+        autocomplete?: string | undefined;
+        dirname?: string | undefined;
+        readonly?: boolean | undefined;
+        required?: boolean | undefined;
+        tags?: string | string[] | Set<string> | undefined;
+        mainClass?: string | undefined;
+    });
+    /** @param {string|number} value */
+    set value(value: string | number);
+    /** @returns {string|null} */
+    get value(): string | null;
+    /** @param {string} autocomplete */
+    set autocomplete(autocomplete: string);
+    /** @returns {string|null} */
+    get autocomplete(): string | null;
+    /** @param {string} dirname */
+    set dirname(dirname: string);
+    /** @returns {string|null} */
+    get dirname(): string | null;
+}
+import TinyHtmlInput from '../TinyHtmlInput.mjs';
+//# sourceMappingURL=TinyHtmlHiddenInput.d.mts.map

package/dist/v1/libs/TinyHtml/input/TinyHtmlHiddenInput.mjs

@@ -0,0 +1,82 @@
+import TinyHtmlInput from '../TinyHtmlInput.mjs';
+/**
+ * TinyHtmlHiddenInput is a helper class for managing
+ * <input type="hidden"> elements. It provides validation
+ * and structured getters/setters for common attributes.
+ *
+ * @example
+ * const hidden = new TinyHtmlHiddenInput({
+ *   name: 'csrf_token',
+ *   value: '12345',
+ *   required: true
+ * });
+ *
+ * @extends TinyHtmlInput
+ */
+class TinyHtmlHiddenInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlHiddenInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {string|number} [config.value] - Initial value of the input.
+     * @param {string} [config.name] - The name of the control.
+     * @param {string} [config.autocomplete] - Autocomplete hint (e.g., "on", "off", "email").
+     * @param {string} [config.dirname] - Directionality field name (for text-based inputs).
+     * @param {boolean} [config.readonly=false] - Whether the input is read-only.
+     * @param {boolean} [config.required=false] - Whether the input is required.
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+     * @param {string} [config.mainClass=''] - Main CSS class.
+     * @throws {TypeError} If any attribute is of the wrong type.
+     */
+    constructor({ name, value, dirname, autocomplete, readonly = false, required = false, tags = [], mainClass = '', } = {}) {
+        super({ type: 'hidden', name, tags, mainClass });
+        if (value !== undefined)
+            this.value = value;
+        if (autocomplete !== undefined)
+            this.autocomplete = autocomplete;
+        if (dirname !== undefined)
+            this.dirname = dirname;
+        this.readonly = readonly;
+        this.required = required;
+    }
+    /** @param {string|number} value */
+    set value(value) {
+        if (typeof value !== 'string' && typeof value !== 'number')
+            throw new TypeError('TinyHtmlHiddenInput: "value" must be a string or number.');
+        this.setAttr('value', String(value));
+    }
+    /** @returns {string|null} */
+    get value() {
+        return this.attrString('value');
+    }
+    /** @param {string} name */
+    set name(name) {
+        if (typeof name !== 'string')
+            throw new TypeError('TinyHtmlHiddenInput: "name" must be a string.');
+        this.setAttr('name', name);
+    }
+    /** @returns {string|null} */
+    get name() {
+        return this.attrString('name');
+    }
+    /** @param {string} autocomplete */
+    set autocomplete(autocomplete) {
+        if (typeof autocomplete !== 'string')
+            throw new TypeError('TinyHtmlHiddenInput: "autocomplete" must be a string.');
+        this.setAttr('autocomplete', autocomplete);
+    }
+    /** @returns {string|null} */
+    get autocomplete() {
+        return this.attrString('autocomplete');
+    }
+    /** @param {string} dirname */
+    set dirname(dirname) {
+        if (typeof dirname !== 'string')
+            throw new TypeError('TinyHtmlHiddenInput: "dirname" must be a string.');
+        this.setAttr('dirname', dirname);
+    }
+    /** @returns {string|null} */
+    get dirname() {
+        return this.attrString('dirname');
+    }
+}
+export default TinyHtmlHiddenInput;

package/dist/v1/libs/TinyHtml/input/TinyHtmlImageInput.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+var TinyHtmlInput = require('../TinyHtmlInput.cjs');
+
+/**
+ * TinyHtmlImageInput is a helper class for managing <input type="image"> elements.
+ * It supports validation and configuration of attributes such as alt, list, form actions,
+ * form behaviors, and size constraints.
+ *
+ * @example
+ * const imageInput = new TinyHtmlImageInput({
+ *   name: 'submitImage',
+ *   alt: 'Submit',
+ *   formaction: '/submit',
+ *   height: 40,
+ *   width: 100,
+ *   required: true
+ * });
+ */
+class TinyHtmlImageInput extends TinyHtmlInput {
+  /**
+   * Creates a new TinyHtmlImageInput instance.
+   * @param {Object} config - Configuration object.
+   * @param {string} [config.name] - The name of the input.
+   * @param {string} [config.placeholder] - Placeholder text.
+   * @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} [config.formenctype] - Encoding type.
+   * @param {'get'|'post'|'dialog'} [config.formmethod] - Submission method.
+   * @param {boolean} [config.formnovalidate=false] - Whether to bypass form validation.
+   * @param {string} [config.formtarget] - Where to display the response.
+   * @param {string} [config.autocomplete] - Autocomplete hint (e.g., "on", "off", "email").
+   * @param {string} [config.alt] - Alternative text for the image input.
+   * @param {string} [config.formaction] - URL to submit the form.
+   * @param {number} [config.height] - Height in CSS pixels.
+   * @param {number} [config.width] - Width in CSS pixels.
+   * @param {string} [config.list] - ID of a <datalist>.
+   * @param {string} [config.src] - Image source URL (**required**).
+   * @param {boolean} [config.readonly=false] - Whether the input is read-only.
+   * @param {boolean} [config.required=false] - Whether the input is required.
+   * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+   * @param {string} [config.mainClass=''] - Main CSS class.
+   * @throws {TypeError} If any attribute has an invalid type or value.
+   */
+  constructor({
+    list,
+    formenctype,
+    formmethod,
+    formnovalidate = false,
+    height,
+    width,
+    formtarget,
+    formaction,
+    placeholder,
+    name,
+    readonly = false,
+    required = false,
+    alt,
+    autocomplete,
+    src,
+    tags = [],
+    mainClass = '',
+  } = {}) {
+    super({ type: 'image', name, placeholder, tags, mainClass, readonly, required });
+    if (src !== undefined) this.src = src;
+    if (alt !== undefined) this.alt = alt;
+    if (list !== undefined) this.list = list;
+    if (formaction !== undefined) this.formaction = formaction;
+    if (formenctype !== undefined) this.formenctype = formenctype;
+    if (formmethod !== undefined) this.formmethod = formmethod;
+    this.formnovalidate = formnovalidate;
+    if (formtarget !== undefined) this.formtarget = formtarget;
+    if (height !== undefined) this.height = height;
+    if (width !== undefined) this.width = width;
+    if (autocomplete !== undefined) this.autocomplete = autocomplete;
+  }
+
+  /** @param {string} value */
+  set src(value) {
+    if (typeof value !== 'string')
+      throw new TypeError('TinyHtmlImageInput: "src" must be a string.');
+    this.setAttr('src', value);
+  }
+
+  /** @returns {string|null} */
+  get src() {
+    return this.attrString('src');
+  }
+
+  /** @param {string} alt */
+  set alt(alt) {
+    if (typeof alt !== 'string') throw new TypeError('TinyHtmlImageInput: "alt" must be a string.');
+    this.setAttr('alt', alt);
+  }
+  /** @returns {string|null} */
+  get alt() {
+    return this.attrString('alt');
+  }
+
+  /** @param {string} list */
+  set list(list) {
+    if (typeof list !== 'string')
+      throw new TypeError('TinyHtmlImageInput: "list" must be a string (datalist id).');
+    this.setAttr('list', list);
+  }
+  /** @returns {string|null} */
+  get list() {
+    return this.attrString('list');
+  }
+
+  /** @param {string} formaction */
+  set formaction(formaction) {
+    if (typeof formaction !== 'string')
+      throw new TypeError('TinyHtmlImageInput: "formaction" must be a string.');
+    this.setAttr('formaction', formaction);
+  }
+  /** @returns {string|null} */
+  get formaction() {
+    return this.attrString('formaction');
+  }
+
+  /** @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} formenctype */
+  set formenctype(formenctype) {
+    const allowed = ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'];
+    if (!allowed.includes(formenctype))
+      throw new TypeError(
+        `TinyHtmlImageInput: "formenctype" must be one of ${allowed.join(', ')}.`,
+      );
+    this.setAttr('formenctype', formenctype);
+  }
+  /** @returns {string|null} */
+  get formenctype() {
+    return this.attrString('formenctype');
+  }
+
+  /** @param {'get'|'post'|'dialog'} formmethod */
+  set formmethod(formmethod) {
+    const allowed = ['get', 'post', 'dialog'];
+    if (!allowed.includes(formmethod))
+      throw new TypeError(`TinyHtmlImageInput: "formmethod" must be one of ${allowed.join(', ')}.`);
+    this.setAttr('formmethod', formmethod);
+  }
+  /** @returns {string|null} */
+  get formmethod() {
+    return this.attrString('formmethod');
+  }
+
+  /** @param {boolean} formnovalidate */
+  set formnovalidate(formnovalidate) {
+    if (typeof formnovalidate !== 'boolean')
+      throw new TypeError('TinyHtmlImageInput: "formnovalidate" must be a boolean.');
+    if (formnovalidate) this.addProp('formnovalidate');
+    else this.removeProp('formnovalidate');
+  }
+  /** @returns {boolean} */
+  get formnovalidate() {
+    return this.hasProp('formnovalidate');
+  }
+
+  /** @param {string} formtarget */
+  set formtarget(formtarget) {
+    if (typeof formtarget !== 'string')
+      throw new TypeError('TinyHtmlImageInput: "formtarget" must be a string.');
+    this.setAttr('formtarget', formtarget);
+  }
+  /** @returns {string|null} */
+  get formtarget() {
+    return this.attrString('formtarget');
+  }
+
+  /** @param {string} autocomplete */
+  set autocomplete(autocomplete) {
+    if (typeof autocomplete !== 'string')
+      throw new TypeError('TinyHtmlImageInput: "autocomplete" must be a string.');
+    this.setAttr('autocomplete', autocomplete);
+  }
+  /** @returns {string|null} */
+  get autocomplete() {
+    return this.attrString('autocomplete');
+  }
+}
+
+module.exports = TinyHtmlImageInput;

package/dist/v1/libs/TinyHtml/input/TinyHtmlImageInput.d.mts

@@ -0,0 +1,97 @@
+export default TinyHtmlImageInput;
+/**
+ * TinyHtmlImageInput is a helper class for managing <input type="image"> elements.
+ * It supports validation and configuration of attributes such as alt, list, form actions,
+ * form behaviors, and size constraints.
+ *
+ * @example
+ * const imageInput = new TinyHtmlImageInput({
+ *   name: 'submitImage',
+ *   alt: 'Submit',
+ *   formaction: '/submit',
+ *   height: 40,
+ *   width: 100,
+ *   required: true
+ * });
+ */
+declare class TinyHtmlImageInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlImageInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {string} [config.name] - The name of the input.
+     * @param {string} [config.placeholder] - Placeholder text.
+     * @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} [config.formenctype] - Encoding type.
+     * @param {'get'|'post'|'dialog'} [config.formmethod] - Submission method.
+     * @param {boolean} [config.formnovalidate=false] - Whether to bypass form validation.
+     * @param {string} [config.formtarget] - Where to display the response.
+     * @param {string} [config.autocomplete] - Autocomplete hint (e.g., "on", "off", "email").
+     * @param {string} [config.alt] - Alternative text for the image input.
+     * @param {string} [config.formaction] - URL to submit the form.
+     * @param {number} [config.height] - Height in CSS pixels.
+     * @param {number} [config.width] - Width in CSS pixels.
+     * @param {string} [config.list] - ID of a <datalist>.
+     * @param {string} [config.src] - Image source URL (**required**).
+     * @param {boolean} [config.readonly=false] - Whether the input is read-only.
+     * @param {boolean} [config.required=false] - Whether the input is required.
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+     * @param {string} [config.mainClass=''] - Main CSS class.
+     * @throws {TypeError} If any attribute has an invalid type or value.
+     */
+    constructor({ list, formenctype, formmethod, formnovalidate, height, width, formtarget, formaction, placeholder, name, readonly, required, alt, autocomplete, src, tags, mainClass, }?: {
+        name?: string | undefined;
+        placeholder?: string | undefined;
+        formenctype?: "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | undefined;
+        formmethod?: "dialog" | "get" | "post" | undefined;
+        formnovalidate?: boolean | undefined;
+        formtarget?: string | undefined;
+        autocomplete?: string | undefined;
+        alt?: string | undefined;
+        formaction?: string | undefined;
+        height?: number | undefined;
+        width?: number | undefined;
+        list?: string | undefined;
+        src?: string | undefined;
+        readonly?: boolean | undefined;
+        required?: boolean | undefined;
+        tags?: string | string[] | Set<string> | undefined;
+        mainClass?: string | undefined;
+    });
+    /** @param {string} value */
+    set src(value: string);
+    /** @returns {string|null} */
+    get src(): string | null;
+    /** @param {string} alt */
+    set alt(alt: string);
+    /** @returns {string|null} */
+    get alt(): string | null;
+    /** @param {string} list */
+    set list(list: string);
+    /** @returns {string|null} */
+    get list(): string | null;
+    /** @param {string} formaction */
+    set formaction(formaction: string);
+    /** @returns {string|null} */
+    get formaction(): string | null;
+    /** @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} formenctype */
+    set formenctype(formenctype: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain");
+    /** @returns {string|null} */
+    get formenctype(): string | null;
+    /** @param {'get'|'post'|'dialog'} formmethod */
+    set formmethod(formmethod: "get" | "post" | "dialog");
+    /** @returns {string|null} */
+    get formmethod(): string | null;
+    /** @param {boolean} formnovalidate */
+    set formnovalidate(formnovalidate: boolean);
+    /** @returns {boolean} */
+    get formnovalidate(): boolean;
+    /** @param {string} formtarget */
+    set formtarget(formtarget: string);
+    /** @returns {string|null} */
+    get formtarget(): string | null;
+    /** @param {string} autocomplete */
+    set autocomplete(autocomplete: string);
+    /** @returns {string|null} */
+    get autocomplete(): string | null;
+}
+import TinyHtmlInput from '../TinyHtmlInput.mjs';
+//# sourceMappingURL=TinyHtmlImageInput.d.mts.map