tiny-essentials 1.24.0 → 1.24.1

package/dist/v1/libs/TinyHtml/input/button/TinyHtmlSubmitInput.d.mts

@@ -0,0 +1,74 @@
+export default TinyHtmlSubmitInput;
+/**
+ * TinyHtmlSubmitInput is a helper class for managing
+ * <input type="submit"> elements with validation and attribute/property handling.
+ *
+ * @example
+ * const submitBtn = new TinyHtmlSubmitInput({
+ *   value: 'Send',
+ *   formaction: '/submit',
+ *   formenctype: 'multipart/form-data',
+ *   formmethod: 'post',
+ *   formnovalidate: true,
+ *   formtarget: '_blank'
+ * });
+ */
+declare class TinyHtmlSubmitInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlSubmitInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {string|number} [config.value] - Initial value (button label).
+     * @param {string} [config.name] - Name of the input control.
+     * @param {string} [config.placeholder] - Placeholder text (not common for submit inputs).
+     * @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} [config.formenctype] - Form encoding type.
+     * @param {'get'|'post'|'dialog'} [config.formmethod] - Submission method.
+     * @param {boolean} [config.formnovalidate=false] - Whether to bypass form validation.
+     * @param {'_self'|'_blank'|'_parent'|'_top'|string} [config.formtarget] - Target browsing context for submission.
+     * @param {string} [config.formaction] - URL to which the form is submitted.
+     * @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({ formenctype, formmethod, formnovalidate, formtarget, formaction, readonly, required, value, tags, name, placeholder, mainClass, }?: {
+        value?: string | number | undefined;
+        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;
+        formaction?: 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} 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;
+}
+import TinyHtmlInput from '../../TinyHtmlInput.mjs';
+//# sourceMappingURL=TinyHtmlSubmitInput.d.mts.map

package/dist/v1/libs/TinyHtml/input/button/TinyHtmlSubmitInput.mjs

@@ -0,0 +1,114 @@
+import TinyHtmlInput from '../../TinyHtmlInput.mjs';
+/**
+ * TinyHtmlSubmitInput is a helper class for managing
+ * <input type="submit"> elements with validation and attribute/property handling.
+ *
+ * @example
+ * const submitBtn = new TinyHtmlSubmitInput({
+ *   value: 'Send',
+ *   formaction: '/submit',
+ *   formenctype: 'multipart/form-data',
+ *   formmethod: 'post',
+ *   formnovalidate: true,
+ *   formtarget: '_blank'
+ * });
+ */
+class TinyHtmlSubmitInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlSubmitInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {string|number} [config.value] - Initial value (button label).
+     * @param {string} [config.name] - Name of the input control.
+     * @param {string} [config.placeholder] - Placeholder text (not common for submit inputs).
+     * @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} [config.formenctype] - Form encoding type.
+     * @param {'get'|'post'|'dialog'} [config.formmethod] - Submission method.
+     * @param {boolean} [config.formnovalidate=false] - Whether to bypass form validation.
+     * @param {'_self'|'_blank'|'_parent'|'_top'|string} [config.formtarget] - Target browsing context for submission.
+     * @param {string} [config.formaction] - URL to which the form is submitted.
+     * @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({ formenctype, formmethod, formnovalidate = false, formtarget, formaction, readonly = false, required = false, value, tags = [], name, placeholder, mainClass = '', } = {}) {
+        super({ name, placeholder, type: 'submit', tags, mainClass, readonly, required });
+        if (value !== undefined)
+            this.value = value;
+        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;
+    }
+    /** @param {string|number} value */
+    set value(value) {
+        if (typeof value !== 'string' && typeof value !== 'number')
+            throw new TypeError('TinyHtmlSubmitInput: "value" must be a string or number.');
+        this.setAttr('value', value);
+    }
+    /** @returns {string|null} */
+    get value() {
+        return this.attrString('value');
+    }
+    /** @param {string} formaction */
+    set formaction(formaction) {
+        if (typeof formaction !== 'string')
+            throw new TypeError('TinyHtmlSubmitInput: "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(`TinyHtmlSubmitInput: "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(`TinyHtmlSubmitInput: "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('TinyHtmlSubmitInput: "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('TinyHtmlSubmitInput: "formtarget" must be a string.');
+        this.setAttr('formtarget', formtarget);
+    }
+    /** @returns {string|null} */
+    get formtarget() {
+        return this.attrString('formtarget');
+    }
+}
+export default TinyHtmlSubmitInput;

package/dist/v1/libs/TinyHtml/input/check/TinyHtmlCheckboxInput.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+var TinyHtmlInput = require('../../TinyHtmlInput.cjs');
+
+/**
+ * TinyHtmlCheckboxInput is a helper class for managing <input type="checkbox"> elements.
+ * It allows configuring standard attributes such as name, value, checked, readonly, and required,
+ * with validation and getter/setter consistency.
+ *
+ * @example
+ * const checkbox = new TinyHtmlCheckboxInput({
+ *   name: 'acceptTerms',
+ *   checked: true,
+ *   value: 'yes'
+ * });
+ */
+class TinyHtmlCheckboxInput extends TinyHtmlInput {
+  /**
+   * Creates a new TinyHtmlCheckboxInput instance.
+   * @param {Object} config - Configuration object.
+   * @param {boolean} [config.checked=false] - Whether the checkbox is checked.
+   * @param {string} config.name - Input name attribute.
+   * @param {string|number} [config.value] - Input value when checked.
+   * @param {boolean} [config.readonly=false] - Whether the checkbox is readonly.
+   * @param {boolean} [config.required=false] - Whether the checkbox is required.
+   * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+   * @param {string} [config.mainClass=''] - Main CSS class.
+   * @throws {TypeError} If an attribute is of the wrong type.
+   */
+  constructor({
+    checked = false,
+    name,
+    value,
+    readonly = false,
+    required = false,
+    tags = [],
+    mainClass = '',
+  }) {
+    super({ type: 'checkbox', name, tags, mainClass, readonly, required });
+
+    // checked
+    this.checked = checked;
+
+    // value
+    if (value !== undefined) this.value = value;
+  }
+
+  /** @param {boolean} checked */
+  set checked(checked) {
+    if (typeof checked !== 'boolean') {
+      throw new TypeError('TinyHtmlCheckboxInput: "checked" must be a boolean.');
+    }
+    if (checked) this.addProp('checked');
+    else this.removeProp('checked');
+  }
+
+  /** @returns {boolean} */
+  get checked() {
+    return this.hasProp('checked');
+  }
+
+  /** @param {string|number} value */
+  set value(value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+      throw new TypeError('TinyHtmlCheckboxInput: "value" must be a string or number.');
+    }
+    this.setAttr('value', value);
+  }
+
+  /** @returns {string|null} */
+  get value() {
+    return this.attrString('value');
+  }
+
+  /**
+   * Checks the checkbox.
+   * @returns {this}
+   */
+  check() {
+    this.checked = true;
+    return this;
+  }
+
+  /**
+   * Unchecks the checkbox.
+   * @returns {this}
+   */
+  uncheck() {
+    this.checked = false;
+    return this;
+  }
+
+  /**
+   * Toggles the checkbox state.
+   * @returns {this}
+   */
+  toggle() {
+    this.checked = !this.checked;
+    return this;
+  }
+}
+
+module.exports = TinyHtmlCheckboxInput;

package/dist/v1/libs/TinyHtml/input/check/TinyHtmlCheckboxInput.d.mts

@@ -0,0 +1,61 @@
+export default TinyHtmlCheckboxInput;
+/**
+ * TinyHtmlCheckboxInput is a helper class for managing <input type="checkbox"> elements.
+ * It allows configuring standard attributes such as name, value, checked, readonly, and required,
+ * with validation and getter/setter consistency.
+ *
+ * @example
+ * const checkbox = new TinyHtmlCheckboxInput({
+ *   name: 'acceptTerms',
+ *   checked: true,
+ *   value: 'yes'
+ * });
+ */
+declare class TinyHtmlCheckboxInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlCheckboxInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {boolean} [config.checked=false] - Whether the checkbox is checked.
+     * @param {string} config.name - Input name attribute.
+     * @param {string|number} [config.value] - Input value when checked.
+     * @param {boolean} [config.readonly=false] - Whether the checkbox is readonly.
+     * @param {boolean} [config.required=false] - Whether the checkbox is required.
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+     * @param {string} [config.mainClass=''] - Main CSS class.
+     * @throws {TypeError} If an attribute is of the wrong type.
+     */
+    constructor({ checked, name, value, readonly, required, tags, mainClass, }: {
+        checked?: boolean | undefined;
+        name: string;
+        value?: string | number | undefined;
+        readonly?: boolean | undefined;
+        required?: boolean | undefined;
+        tags?: string | string[] | Set<string> | undefined;
+        mainClass?: string | undefined;
+    });
+    /** @param {boolean} checked */
+    set checked(checked: boolean);
+    /** @returns {boolean} */
+    get checked(): boolean;
+    /** @param {string|number} value */
+    set value(value: string | number);
+    /** @returns {string|null} */
+    get value(): string | null;
+    /**
+     * Checks the checkbox.
+     * @returns {this}
+     */
+    check(): this;
+    /**
+     * Unchecks the checkbox.
+     * @returns {this}
+     */
+    uncheck(): this;
+    /**
+     * Toggles the checkbox state.
+     * @returns {this}
+     */
+    toggle(): this;
+}
+import TinyHtmlInput from '../../TinyHtmlInput.mjs';
+//# sourceMappingURL=TinyHtmlCheckboxInput.d.mts.map

package/dist/v1/libs/TinyHtml/input/check/TinyHtmlCheckboxInput.mjs

@@ -0,0 +1,85 @@
+import TinyHtmlInput from '../../TinyHtmlInput.mjs';
+/**
+ * TinyHtmlCheckboxInput is a helper class for managing <input type="checkbox"> elements.
+ * It allows configuring standard attributes such as name, value, checked, readonly, and required,
+ * with validation and getter/setter consistency.
+ *
+ * @example
+ * const checkbox = new TinyHtmlCheckboxInput({
+ *   name: 'acceptTerms',
+ *   checked: true,
+ *   value: 'yes'
+ * });
+ */
+class TinyHtmlCheckboxInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlCheckboxInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {boolean} [config.checked=false] - Whether the checkbox is checked.
+     * @param {string} config.name - Input name attribute.
+     * @param {string|number} [config.value] - Input value when checked.
+     * @param {boolean} [config.readonly=false] - Whether the checkbox is readonly.
+     * @param {boolean} [config.required=false] - Whether the checkbox is required.
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes.
+     * @param {string} [config.mainClass=''] - Main CSS class.
+     * @throws {TypeError} If an attribute is of the wrong type.
+     */
+    constructor({ checked = false, name, value, readonly = false, required = false, tags = [], mainClass = '', }) {
+        super({ type: 'checkbox', name, tags, mainClass, readonly, required });
+        // checked
+        this.checked = checked;
+        // value
+        if (value !== undefined)
+            this.value = value;
+    }
+    /** @param {boolean} checked */
+    set checked(checked) {
+        if (typeof checked !== 'boolean') {
+            throw new TypeError('TinyHtmlCheckboxInput: "checked" must be a boolean.');
+        }
+        if (checked)
+            this.addProp('checked');
+        else
+            this.removeProp('checked');
+    }
+    /** @returns {boolean} */
+    get checked() {
+        return this.hasProp('checked');
+    }
+    /** @param {string|number} value */
+    set value(value) {
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new TypeError('TinyHtmlCheckboxInput: "value" must be a string or number.');
+        }
+        this.setAttr('value', value);
+    }
+    /** @returns {string|null} */
+    get value() {
+        return this.attrString('value');
+    }
+    /**
+     * Checks the checkbox.
+     * @returns {this}
+     */
+    check() {
+        this.checked = true;
+        return this;
+    }
+    /**
+     * Unchecks the checkbox.
+     * @returns {this}
+     */
+    uncheck() {
+        this.checked = false;
+        return this;
+    }
+    /**
+     * Toggles the checkbox state.
+     * @returns {this}
+     */
+    toggle() {
+        this.checked = !this.checked;
+        return this;
+    }
+}
+export default TinyHtmlCheckboxInput;

package/dist/v1/libs/TinyHtml/input/check/TinyHtmlRadioInput.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+var TinyHtmlInput = require('../../TinyHtmlInput.cjs');
+
+/**
+ * TinyHtmlRadioInput is a helper class for managing `<input type="radio">` elements.
+ * It provides strict validation for attributes like `name`, `value`, `checked`, `readonly`,
+ * and `required`, with convenient getters and setters.
+ *
+ * @example
+ * const radio = new TinyHtmlRadioInput({
+ *   name: 'gender',
+ *   value: 'female',
+ *   checked: true,
+ *   required: true
+ * });
+ *
+ * // Check state
+ * radio.checked = false;
+ * console.log(radio.checked); // false
+ */
+class TinyHtmlRadioInput extends TinyHtmlInput {
+  /**
+   * Creates a new TinyHtmlRadioInput instance.
+   * @param {Object} config - Configuration object.
+   * @param {string} config.name - Radio group name (required).
+   * @param {string|number} [config.value] - Value for this radio option.
+   * @param {boolean} [config.checked=false] - Whether this radio is selected.
+   * @param {boolean} [config.readonly=false] - Whether the input is readonly.
+   * @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 an attribute is of the wrong type.
+   */
+  constructor({
+    name,
+    value,
+    checked = false,
+    readonly = false,
+    required = false,
+    tags = [],
+    mainClass = '',
+  }) {
+    super({ tags, mainClass, type: 'radio' });
+
+    // --- name (required) ---
+    if (typeof name !== 'string') {
+      throw new TypeError('TinyHtmlRadioInput: "name" is required and must be a string.');
+    }
+    this.name = name;
+
+    // --- value ---
+    if (value !== undefined) this.value = value;
+
+    // --- checked ---
+    this.checked = checked;
+
+    // --- readonly ---
+    this.readonly = readonly;
+
+    // --- required ---
+    this.required = required;
+  }
+
+  /** @param {string|number} value */
+  set value(value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+      throw new TypeError('TinyHtmlRadioInput: "value" must be a string or number.');
+    }
+    this.setAttr('value', value);
+  }
+
+  /** @returns {string|null} */
+  get value() {
+    return this.attrString('value');
+  }
+
+  /** @param {string} name */
+  set name(name) {
+    if (typeof name !== 'string') {
+      throw new TypeError('TinyHtmlRadioInput: "name" must be a string.');
+    }
+    this.setAttr('name', name);
+  }
+
+  /** @returns {string|null} */
+  get name() {
+    return this.attrString('name');
+  }
+
+  /** @param {boolean} checked */
+  set checked(checked) {
+    if (typeof checked !== 'boolean') {
+      throw new TypeError('TinyHtmlRadioInput: "checked" must be a boolean.');
+    }
+    if (checked) this.addProp('checked');
+    else this.removeProp('checked');
+  }
+
+  /** @returns {boolean} */
+  get checked() {
+    return this.hasProp('checked');
+  }
+
+  /**
+   * Toggles the checked state of the radio.
+   * @returns {this}
+   */
+  toggle() {
+    this.checked = !this.checked;
+    return this;
+  }
+}
+
+module.exports = TinyHtmlRadioInput;

package/dist/v1/libs/TinyHtml/input/check/TinyHtmlRadioInput.d.mts

@@ -0,0 +1,56 @@
+export default TinyHtmlRadioInput;
+/**
+ * TinyHtmlRadioInput is a helper class for managing `<input type="radio">` elements.
+ * It provides strict validation for attributes like `name`, `value`, `checked`, `readonly`,
+ * and `required`, with convenient getters and setters.
+ *
+ * @example
+ * const radio = new TinyHtmlRadioInput({
+ *   name: 'gender',
+ *   value: 'female',
+ *   checked: true,
+ *   required: true
+ * });
+ *
+ * // Check state
+ * radio.checked = false;
+ * console.log(radio.checked); // false
+ */
+declare class TinyHtmlRadioInput extends TinyHtmlInput {
+    /**
+     * Creates a new TinyHtmlRadioInput instance.
+     * @param {Object} config - Configuration object.
+     * @param {string} config.name - Radio group name (required).
+     * @param {string|number} [config.value] - Value for this radio option.
+     * @param {boolean} [config.checked=false] - Whether this radio is selected.
+     * @param {boolean} [config.readonly=false] - Whether the input is readonly.
+     * @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 an attribute is of the wrong type.
+     */
+    constructor({ name, value, checked, readonly, required, tags, mainClass, }: {
+        name: string;
+        value?: string | number | undefined;
+        checked?: boolean | 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 {boolean} checked */
+    set checked(checked: boolean);
+    /** @returns {boolean} */
+    get checked(): boolean;
+    /**
+     * Toggles the checked state of the radio.
+     * @returns {this}
+     */
+    toggle(): this;
+}
+import TinyHtmlInput from '../../TinyHtmlInput.mjs';
+//# sourceMappingURL=TinyHtmlRadioInput.d.mts.map