@daikin-oss/design-system-web-components 1.2.0 → 1.3.0-next.2

package/dist/cjs/components/text-field/number-utils.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Big = require("big.js");
+function updateNumberValue(currentValue, direction, options) {
+  const { step, min, max } = options;
+  try {
+    const current = new Big(currentValue || "0");
+    const stepBig = new Big(step || "1");
+    const minBig = min != null && min !== "" ? new Big(min) : null;
+    const maxBig = max != null && max !== "" ? new Big(max) : null;
+    if (minBig && maxBig && maxBig.lt(minBig)) {
+      return direction === 1 ? minBig.toString() : maxBig.toString();
+    }
+    const isOnStepBoundary = (value) => {
+      const diff = value.sub(minBig ?? 0);
+      return diff.mod(stepBig).eq(0);
+    };
+    const findNearestStepInDirection = (value, dir) => {
+      const base = minBig || new Big(0);
+      const offset = value.sub(base);
+      const steps = offset.div(stepBig);
+      let targetSteps;
+      if (dir === 1) {
+        targetSteps = steps.round(0, Big.roundUp);
+      } else {
+        targetSteps = steps.round(0, Big.roundDown);
+      }
+      return base.add(targetSteps.mul(stepBig));
+    };
+    const isInRange = (!minBig || current.gte(minBig)) && (!maxBig || current.lte(maxBig));
+    if (!isInRange || !isOnStepBoundary(current)) {
+      if (!isInRange) {
+        const isBelowMin = minBig && current.lt(minBig);
+        const isAboveMax = maxBig && current.gt(maxBig);
+        if (isBelowMin && direction === -1 || isAboveMax && direction === 1) {
+          return currentValue;
+        }
+      }
+      let nearestStep = findNearestStepInDirection(current, direction);
+      if (minBig && nearestStep.lt(minBig)) {
+        nearestStep = minBig;
+      }
+      if (maxBig && nearestStep.gt(maxBig)) {
+        nearestStep = maxBig;
+      }
+      return nearestStep.toString();
+    }
+    const newValue = direction === 1 ? current.add(stepBig) : current.sub(stepBig);
+    let result = newValue;
+    if (minBig && result.lt(minBig)) {
+      result = minBig;
+    }
+    if (maxBig && result.gt(maxBig)) {
+      result = maxBig;
+    }
+    return result.toString();
+  } catch (error) {
+    return currentValue;
+  }
+}
+exports.updateNumberValue = updateNumberValue;

package/dist/cjs/components/text-field/number-utils.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Options for updating number values with step constraints.
+ */
+export interface NumberUpdateOptions {
+    /** Step increment/decrement amount */
+    step?: string | null;
+    /** Minimum allowed value */
+    min?: string | null;
+    /** Maximum allowed value */
+    max?: string | null;
+}
+/**
+ * Updates a number value according to step constraints and min/max bounds.
+ *
+ * Logic (compliant with Google Chrome behavior):
+ * 0. Valid output range: min <= value <= max, and (value - min) is a multiple of step, or value equals min/max
+ * 1. If max < min, direction up goes to min (max value), direction down goes to max (min value)
+ * 2. If value is out of range or not on step boundary, round to nearest step in the direction and finish
+ * 3. Otherwise, increment/decrement by step
+ *
+ * @param currentValue Current value as string
+ * @param direction Direction: 1 for increment, -1 for decrement
+ * @param options The update options
+ * @returns The new value as string
+ */
+export declare function updateNumberValue(currentValue: string, direction: 1 | -1, options: NumberUpdateOptions): string;

package/dist/cjs/components/text-masked-field/daikin-text-masked-field.cjs

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const classVarianceAuthority = require("class-variance-authority");
+const IMask = require("imask");
+const lit = require("lit");
+const decorators_js = require("lit/decorators.js");
+const ifDefined_js = require("lit/directives/if-defined.js");
+const ref_js = require("lit/directives/ref.js");
+require("../../base/dds-element.cjs");
+const decorators = require("../../base/decorators.cjs");
+require("../../base/define.cjs");
+const ddsFormElement = require("../../base/dds-form-element.cjs");
+const tailwind = require("../../tailwind.css.cjs");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators2, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators2.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators2[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+const cvaInput = classVarianceAuthority.cva(
+  [
+    "flex",
+    "items-center",
+    "w-full",
+    "h-full",
+    "bg-ddt-color-common-background-default",
+    "relative",
+    "rounded",
+    "overflow-hidden",
+    "font-daikinSerif",
+    "outline",
+    "outline-[--color-border]",
+    "outline-0",
+    "-outline-offset-2",
+    "placeholder:text-ddt-color-common-text-secondary",
+    // Define `--color-border` as a CSS variable that references `--color-state-focus` and `--color-base` in that order.
+    // `--color-base` indicates the color of the border when the element is normal, hovered, or disabled.
+    "define-[--color-state-focus,--color-base]/color-border",
+    "border",
+    "border-[--color-border]",
+    "enabled:text-ddt-color-common-text-primary",
+    "enabled:data-[empty]:text-ddt-color-common-text-secondary",
+    "enabled:hover:bg-ddt-color-common-surface-hover",
+    "enabled:active:bg-ddt-color-common-surface-press",
+    "focus-visible:outline-2",
+    "disabled:var-color-ddt-color-common-disabled/color-base",
+    "disabled:text-ddt-color-common-disabled",
+    "disabled:bg-ddt-color-common-background-default",
+    "disabled:placeholder:text-ddt-color-common-disabled"
+  ],
+  {
+    variants: {
+      error: {
+        false: [
+          "enabled:var-color-ddt-color-common-neutral-default/color-base",
+          "enabled:hover:var-color-ddt-color-common-neutral-hover/color-base",
+          "enabled:active:var-color-ddt-color-common-neutral-press/color-base",
+          "focus-visible:var-color-ddt-color-common-border-focus/color-state-focus"
+        ],
+        true: ["enabled:var-color-ddt-color-common-danger-default/color-base"]
+      },
+      leftIcon: {
+        false: ["pl-4"],
+        true: ["pl-11"]
+      },
+      rightIcon: {
+        false: ["pr-4"],
+        true: ["pr-11"]
+      }
+    }
+  }
+);
+const cvaIcon = classVarianceAuthority.cva(
+  ["flex", "items-center", "absolute", "pointer-events-none"],
+  {
+    variants: {
+      icon: {
+        left: ["left-3"],
+        right: ["right-3"]
+      },
+      disabled: {
+        false: ["text-ddt-color-common-text-primary"],
+        true: ["text-ddt-color-common-disabled"]
+      }
+    }
+  }
+);
+exports.DaikinTextMaskedField = class DaikinTextMaskedField extends ddsFormElement.DDSFormElement {
+  constructor() {
+    super(...arguments);
+    this.placeholder = null;
+    this.readonly = false;
+    this.disabled = false;
+    this.required = false;
+    this.error = false;
+    this.minlength = null;
+    this.maxlength = null;
+    this.pattern = null;
+    this.mask = null;
+    this._unmaskedValue = "";
+    this._label = null;
+    this._hasLeftSlot = false;
+    this._hasRightSlot = false;
+    this._inputRef = ref_js.createRef();
+    this._maskInstance = null;
+  }
+  _initializeMask() {
+    if (!this._inputRef.value || !this.mask) {
+      return;
+    }
+    this._destroyMask();
+    const maskOptions = typeof this.mask === "string" ? { mask: this.mask, lazy: false, placeholderChar: "X" } : this.mask;
+    this._maskInstance = IMask(this._inputRef.value, maskOptions);
+    this._maskInstance.on("accept", () => {
+      if (this._maskInstance) {
+        this._unmaskedValue = this._maskInstance.unmaskedValue;
+        this.value = this._maskInstance.value;
+      }
+    });
+  }
+  _destroyMask() {
+    var _a;
+    (_a = this._maskInstance) == null ? void 0 : _a.destroy();
+    this._maskInstance = null;
+  }
+  /**
+   * The unmasked value of the input.
+   */
+  get unmaskedValue() {
+    return this._unmaskedValue;
+  }
+  set unmaskedValue(value) {
+    if (this._maskInstance) {
+      this._maskInstance.unmaskedValue = value;
+      this.value = this._maskInstance.value;
+      this._unmaskedValue = this._maskInstance.unmaskedValue;
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this._initializeMask();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._destroyMask();
+  }
+  _handleChange(event) {
+    this.dispatchEvent(new Event("change", event));
+  }
+  _handleSlotChange(event) {
+    const target = event.target;
+    const name = target.name;
+    const hasIcon = !!target.assignedNodes().length;
+    switch (name) {
+      case "left-icon":
+        this._hasLeftSlot = hasIcon;
+        break;
+      case "right-icon":
+        this._hasRightSlot = hasIcon;
+        break;
+    }
+  }
+  _handleInput(event) {
+    this.value = event.target.value;
+  }
+  _createIcon() {
+    return lit.html`<span
+        class=${cvaIcon({
+      icon: "left",
+      disabled: this.disabled
+    })}
+      >
+        <slot
+          name="left-icon"
+          class="icon-size-6"
+          @slotchange=${this._handleSlotChange}
+        ></slot>
+      </span>
+      <span
+        class=${cvaIcon({
+      icon: "right",
+      disabled: this.disabled
+    })}
+      >
+        <slot
+          name="right-icon"
+          class="icon-size-6"
+          @slotchange=${this._handleSlotChange}
+        ></slot>
+      </span>`;
+  }
+  render() {
+    const error = !this.disabled && this.error;
+    const hasLeftSlot = this._hasLeftSlot;
+    const hasRightSlot = this._hasRightSlot;
+    const leftIcon = hasLeftSlot;
+    const rightIcon = hasRightSlot;
+    return lit.html`<input
+        ${ref_js.ref(this._inputRef)}
+        class=${cvaInput({
+      error,
+      leftIcon,
+      rightIcon
+    })}
+        type="text"
+        placeholder=${ifDefined_js.ifDefined(this.placeholder ?? void 0)}
+        name=${ifDefined_js.ifDefined(this.name)}
+        minlength=${ifDefined_js.ifDefined(this.minlength ?? void 0)}
+        maxlength=${ifDefined_js.ifDefined(this.maxlength ?? void 0)}
+        pattern=${ifDefined_js.ifDefined(this.pattern ?? void 0)}
+        autocomplete=${// eslint-disable-next-line @typescript-eslint/no-explicit-any -- workaround lit-analyzer checking
+    ifDefined_js.ifDefined(this.autocomplete)}
+        aria-label=${ifDefined_js.ifDefined(this._label ?? void 0)}
+        .value=${this.value}
+        ?data-empty=${!this._unmaskedValue}
+        ?disabled=${this.disabled}
+        ?readonly=${this.readonly}
+        ?required=${this.required}
+        @change=${this._handleChange}
+        @input=${this._handleInput}
+      />
+      ${this._createIcon()}`;
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("mask")) {
+      this._destroyMask();
+      this._initializeMask();
+    }
+    if (!changedProperties.has("value")) {
+      return;
+    }
+    this.setFormValue(this.value);
+  }
+  /**
+   * This method is used by `daikin-input-group` to reflect it's attributes to this component.
+   * @private
+   */
+  reflectInputGroup(inputGroup) {
+    const isError = !inputGroup.disabled && !!inputGroup.error;
+    this.disabled = !!inputGroup.disabled;
+    this.required = !!inputGroup.required;
+    this.error = isError;
+    this._label = inputGroup.label;
+  }
+};
+exports.DaikinTextMaskedField.styles = lit.css`
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      display: flex;
+      align-items: center;
+      height: 3rem;
+      position: relative;
+    }
+
+    input::-ms-reveal {
+      display: none !important;
+    }
+
+    input::-ms-clear {
+      display: none !important;
+    }
+  `;
+__decorateClass([
+  decorators_js.property({ type: String })
+], exports.DaikinTextMaskedField.prototype, "placeholder", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "readonly", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "disabled", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "required", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "error", 2);
+__decorateClass([
+  decorators_js.property({ type: Number, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "minlength", 2);
+__decorateClass([
+  decorators_js.property({ type: Number, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "maxlength", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "pattern", 2);
+__decorateClass([
+  decorators_js.property({ attribute: false })
+], exports.DaikinTextMaskedField.prototype, "mask", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinTextMaskedField.prototype, "autocomplete", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.DaikinTextMaskedField.prototype, "_unmaskedValue", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.DaikinTextMaskedField.prototype, "_label", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.DaikinTextMaskedField.prototype, "_hasLeftSlot", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.DaikinTextMaskedField.prototype, "_hasRightSlot", 2);
+exports.DaikinTextMaskedField = __decorateClass([
+  decorators.ddsElement("daikin-text-masked-field")
+], exports.DaikinTextMaskedField);

package/dist/cjs/components/text-masked-field/daikin-text-masked-field.d.cts

@@ -0,0 +1,136 @@
+import { InputMask, FactoryOpts } from 'imask';
+import { PropertyValues, TemplateResult } from 'lit';
+import { DDSFormElement } from "../../base/dds-form-element.cjs";
+import { DaikinInputGroup } from "../input-group/index.cjs";
+export type { FactoryOpts, InputMask };
+/**
+ * The text masked field component is a UI element that allows users to input single-line text data with input masking support.
+ * It functions similarly to the HTML `<input type="text">` tag, providing a simple and efficient way for users to enter and edit short pieces of texts with masking functionality using IMask.js.
+ * Can be used within `daikin-input-group` component.
+ *
+ * Hierarchies:
+ * - `daikin-text-masked-field` (can be used solely)
+ * - `daikin-input-group` > `daikin-text-masked-field`
+ *
+ * @fires change - A cloned event of a [change event](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event) emitted from the inner `<input>` element.
+ * @fires input - A retargeted event of a [input event](https://developer.mozilla.org/en-US/docs/Web/API/Element/input_event).
+ *
+ * @slot left-icon - Specify the icon you want to use on the left. You can also use something other than `daikin-icon`.
+ *
+ * @slot right-icon - Specify the icon you want to use on the right. You can also use something other than `daikin-icon`.
+ *
+ * @example
+ *
+ * ```js
+ * import "@daikin-oss/design-system-web-components/components/text-masked-field/index.js";
+ * ```
+ *
+ * ```html
+ * <!-- See `daikin-input-group` component for complete example. -->
+ * <daikin-text-masked-field name="name"></daikin-text-masked-field>
+ *
+ * <script>
+ *   const textField = document.querySelector("daikin-text-masked-field");
+ *   textField.mask = "00/00/0000";
+ * </script>
+ * ```
+ */
+export declare class DaikinTextMaskedField extends DDSFormElement {
+    static readonly styles: import('lit').CSSResult;
+    /**
+     * Placeholder text.
+     */
+    placeholder: string | null;
+    /**
+     * Whether the text masked field is readonly.
+     */
+    readonly: boolean;
+    /**
+     * Whether the text masked field is disabled.
+     * Controlled by `daikin-input-group` when used within `daikin-input-group`.
+     */
+    disabled: boolean;
+    /**
+     * Whether the text masked field is required.
+     * Controlled by `daikin-input-group` when used within `daikin-input-group`.
+     */
+    required: boolean;
+    /**
+     * Whether or not to display error states.
+     * Ignored if the `disabled` is `true`.
+     * Controlled by `daikin-input-group` when used within `daikin-input-group`.
+     */
+    error: boolean;
+    /**
+     * Minimum length of value.
+     */
+    minlength: number | null;
+    /**
+     * Maximum length of value.
+     */
+    maxlength: number | null;
+    /**
+     * The pattern of value.
+     */
+    pattern: string | null;
+    /**
+     * Input mask configuration. When provided as a string, it will be used as `{ mask: string, lazy: false }`.
+     * When provided as an object, it will be passed directly to IMask.
+     *
+     * Pattern symbols:
+     * - `0` - any digit
+     * - `a` - any letter
+     * - `*` - any char
+     * - `[]` - make input optional
+     * - `{}` - include fixed part in unmasked value
+     * - `` ` `` - prevent symbols shift back
+     * - Other chars are treated as fixed
+     * - Use `\\` to escape definition characters (e.g., `\\0`)
+     *
+     * Examples:
+     * - `"00/00/0000"` - date format (MM/DD/YYYY)
+     * - `"{#}000[aaa]/NIC-\`*[**]"` - complex pattern with optional parts
+     *
+     * For more details, see: https://imask.js.org/guide.html#masked-pattern
+     */
+    mask: string | FactoryOpts | null;
+    /**
+     * Value of `autocomplete` attribute of the internal `<input>`.
+     */
+    autocomplete?: HTMLInputElement["autocomplete"];
+    private _unmaskedValue;
+    /**
+     * The label text used as the value of aria-label.
+     * Set automatically by `reflectInputGroup` method.
+     */
+    private _label;
+    private _hasLeftSlot;
+    private _hasRightSlot;
+    private _inputRef;
+    private _maskInstance;
+    private _initializeMask;
+    private _destroyMask;
+    /**
+     * The unmasked value of the input.
+     */
+    get unmaskedValue(): string;
+    set unmaskedValue(value: string);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _handleChange;
+    private _handleSlotChange;
+    private _handleInput;
+    private _createIcon;
+    render(): TemplateResult<1>;
+    updated(changedProperties: PropertyValues<this>): void;
+    /**
+     * This method is used by `daikin-input-group` to reflect it's attributes to this component.
+     * @private
+     */
+    reflectInputGroup(inputGroup: DaikinInputGroup): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-text-masked-field": DaikinTextMaskedField;
+    }
+}

package/dist/cjs/components/text-masked-field/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const daikinTextMaskedField = require("./daikin-text-masked-field.cjs");
+Object.defineProperty(exports, "DaikinTextMaskedField", {
+  enumerable: true,
+  get: () => daikinTextMaskedField.DaikinTextMaskedField
+});

package/dist/cjs/components/text-masked-field/index.d.cts

@@ -0,0 +1 @@
+export * from "./daikin-text-masked-field.cjs";