@tolle_/tolle-ui 18.2.28 → 18.2.30

package/esm2022/lib/native-select.component.mjs

@@ -0,0 +1,201 @@
+import { Component, Input, Output, EventEmitter, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const nativeSelectVariants = cva('flex w-full appearance-none items-center rounded-md border border-input bg-background text-foreground shadow-sm transition-colors ' +
+    'focus:outline-none focus-visible:border-primary/80 focus-visible:ring-4 focus-visible:ring-ring/30 ' +
+    'disabled:cursor-not-allowed disabled:opacity-50', {
+    variants: {
+        size: {
+            xs: 'h-8 pl-2 pr-7 text-xs',
+            sm: 'h-9 pl-3 pr-8 text-sm',
+            default: 'h-10 pl-3 pr-8 text-sm',
+            lg: 'h-11 pl-4 pr-9 text-base',
+        },
+        invalid: {
+            true: 'border-destructive focus-visible:border-destructive/80 focus-visible:ring-destructive/30',
+            false: '',
+        },
+    },
+    defaultVariants: { size: 'default', invalid: false },
+});
+/**
+ * A styled native `<select>`. Unlike `tolle-select` it uses the platform
+ * dropdown, so it needs no portal or floating-ui and works well on mobile and
+ * inside forms that must degrade without JavaScript.
+ *
+ * Options come from `options`, or from projected `<option>` elements when you
+ * need `<optgroup>` or custom markup.
+ * @new
+ */
+export class NativeSelectComponent {
+    cdr;
+    /** Id applied to the underlying `<select>`; pair it with a `tolle-label`. */
+    id = `native-select-${Math.random().toString(36).slice(2, 11)}`;
+    /** Options to render. Omit and project `<option>` elements for custom markup. @default [] */
+    options = [];
+    /** Non-selectable prompt shown when no value is set. @default '' */
+    placeholder = '';
+    /** Height and text size of the control. @default 'default' */
+    size = 'default';
+    /** Applies the destructive border and sets `aria-invalid`. @default false */
+    invalid = false;
+    /** Disables the control. @default false */
+    disabled = false;
+    /** Accessible name when there is no associated visible label. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the `<select>` via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the newly selected value whenever the user picks an option. */
+    valueChange = new EventEmitter();
+    value = null;
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    get computedClass() {
+        return cn(nativeSelectVariants({ size: this.size, invalid: this.invalid }), this.class);
+    }
+    onSelectChange(event) {
+        const raw = event.target.value;
+        // Options rendered from `options` carry their index as the DOM value, so we
+        // can hand back the ORIGINAL value — object, number or string — untouched.
+        // Anything else came from a projected <option>, where the string is all
+        // there is.
+        const index = Number(raw);
+        const fromOptions = raw !== '' && Number.isInteger(index) && index >= 0 && index < this.options.length;
+        const next = fromOptions ? this.options[index].value : raw;
+        this.value = next;
+        this.onChange(next);
+        this.valueChange.emit(next);
+    }
+    writeValue(value) {
+        this.value = value;
+        this.cdr.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.cdr.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NativeSelectComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: NativeSelectComponent, isStandalone: true, selector: "tolle-native-select", inputs: { id: "id", options: "options", placeholder: "placeholder", size: "size", invalid: "invalid", disabled: "disabled", ariaLabel: "ariaLabel", class: "class" }, outputs: { valueChange: "valueChange" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => NativeSelectComponent),
+                multi: true,
+            },
+        ], ngImport: i0, template: `
+    <div class="relative w-full">
+      <select
+        [id]="id"
+        [disabled]="disabled"
+        [attr.aria-invalid]="invalid || null"
+        [attr.aria-label]="ariaLabel || null"
+        [class]="computedClass"
+        (change)="onSelectChange($event)"
+        (blur)="onTouched()"
+      >
+        <option *ngIf="placeholder" value="" [selected]="value === null || value === undefined || value === ''" disabled>
+          {{ placeholder }}
+        </option>
+        <!--
+          The DOM value is the option's INDEX, not its value. A select element
+          coerces every option value to a string, which collapses all object
+          options to "[object Object]" and makes them indistinguishable on the
+          way back out. Indexing keeps object- and number-valued options
+          round-tripping exactly.
+        -->
+        <option
+          *ngFor="let option of options; let i = index"
+          [value]="i"
+          [disabled]="option.disabled || false"
+          [selected]="option.value === value"
+        >
+          {{ option.label }}
+        </option>
+        <ng-content></ng-content>
+      </select>
+
+      <i
+        class="ri-arrow-down-s-line pointer-events-none absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground"
+        aria-hidden="true"
+      ></i>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NativeSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-native-select', standalone: true, imports: [CommonModule], providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => NativeSelectComponent),
+                            multi: true,
+                        },
+                    ], template: `
+    <div class="relative w-full">
+      <select
+        [id]="id"
+        [disabled]="disabled"
+        [attr.aria-invalid]="invalid || null"
+        [attr.aria-label]="ariaLabel || null"
+        [class]="computedClass"
+        (change)="onSelectChange($event)"
+        (blur)="onTouched()"
+      >
+        <option *ngIf="placeholder" value="" [selected]="value === null || value === undefined || value === ''" disabled>
+          {{ placeholder }}
+        </option>
+        <!--
+          The DOM value is the option's INDEX, not its value. A select element
+          coerces every option value to a string, which collapses all object
+          options to "[object Object]" and makes them indistinguishable on the
+          way back out. Indexing keeps object- and number-valued options
+          round-tripping exactly.
+        -->
+        <option
+          *ngFor="let option of options; let i = index"
+          [value]="i"
+          [disabled]="option.disabled || false"
+          [selected]="option.value === value"
+        >
+          {{ option.label }}
+        </option>
+        <ng-content></ng-content>
+      </select>
+
+      <i
+        class="ri-arrow-down-s-line pointer-events-none absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground"
+        aria-hidden="true"
+      ></i>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { id: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-select.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/native-select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, forwardRef, ChangeDetectorRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nconst nativeSelectVariants = cva(\n  'flex w-full appearance-none items-center rounded-md border border-input bg-background text-foreground shadow-sm transition-colors ' +\n    'focus:outline-none focus-visible:border-primary/80 focus-visible:ring-4 focus-visible:ring-ring/30 ' +\n    'disabled:cursor-not-allowed disabled:opacity-50',\n  {\n    variants: {\n      size: {\n        xs: 'h-8 pl-2 pr-7 text-xs',\n        sm: 'h-9 pl-3 pr-8 text-sm',\n        default: 'h-10 pl-3 pr-8 text-sm',\n        lg: 'h-11 pl-4 pr-9 text-base',\n      },\n      invalid: {\n        true: 'border-destructive focus-visible:border-destructive/80 focus-visible:ring-destructive/30',\n        false: '',\n      },\n    },\n    defaultVariants: { size: 'default', invalid: false },\n  }\n);\n\nexport type NativeSelectProps = VariantProps<typeof nativeSelectVariants>;\n\nexport type NativeSelectOption = {\n  label: string;\n  value: any;\n  disabled?: boolean;\n};\n\n/**\n * A styled native `<select>`. Unlike `tolle-select` it uses the platform\n * dropdown, so it needs no portal or floating-ui and works well on mobile and\n * inside forms that must degrade without JavaScript.\n *\n * Options come from `options`, or from projected `<option>` elements when you\n * need `<optgroup>` or custom markup.\n * @new\n */\n@Component({\n  selector: 'tolle-native-select',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => NativeSelectComponent),\n      multi: true,\n    },\n  ],\n  template: `\n    <div class=\"relative w-full\">\n      <select\n        [id]=\"id\"\n        [disabled]=\"disabled\"\n        [attr.aria-invalid]=\"invalid || null\"\n        [attr.aria-label]=\"ariaLabel || null\"\n        [class]=\"computedClass\"\n        (change)=\"onSelectChange($event)\"\n        (blur)=\"onTouched()\"\n      >\n        <option *ngIf=\"placeholder\" value=\"\" [selected]=\"value === null || value === undefined || value === ''\" disabled>\n          {{ placeholder }}\n        </option>\n        <!--\n          The DOM value is the option's INDEX, not its value. A select element\n          coerces every option value to a string, which collapses all object\n          options to \"[object Object]\" and makes them indistinguishable on the\n          way back out. Indexing keeps object- and number-valued options\n          round-tripping exactly.\n        -->\n        <option\n          *ngFor=\"let option of options; let i = index\"\n          [value]=\"i\"\n          [disabled]=\"option.disabled || false\"\n          [selected]=\"option.value === value\"\n        >\n          {{ option.label }}\n        </option>\n        <ng-content></ng-content>\n      </select>\n\n      <i\n        class=\"ri-arrow-down-s-line pointer-events-none absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground\"\n        aria-hidden=\"true\"\n      ></i>\n    </div>\n  `,\n})\nexport class NativeSelectComponent implements ControlValueAccessor {\n  /** Id applied to the underlying `<select>`; pair it with a `tolle-label`. */\n  @Input() id = `native-select-${Math.random().toString(36).slice(2, 11)}`;\n  /** Options to render. Omit and project `<option>` elements for custom markup. @default [] */\n  @Input() options: NativeSelectOption[] = [];\n  /** Non-selectable prompt shown when no value is set. @default '' */\n  @Input() placeholder = '';\n  /** Height and text size of the control. @default 'default' */\n  @Input() size: NativeSelectProps['size'] = 'default';\n  /** Applies the destructive border and sets `aria-invalid`. @default false */\n  @Input() invalid = false;\n  /** Disables the control. @default false */\n  @Input() disabled = false;\n  /** Accessible name when there is no associated visible label. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the `<select>` via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the newly selected value whenever the user picks an option. */\n  @Output() valueChange = new EventEmitter<any>();\n\n  value: any = null;\n  onChange: (value: any) => void = () => {};\n  onTouched: () => void = () => {};\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  get computedClass() {\n    return cn(nativeSelectVariants({ size: this.size, invalid: this.invalid }), this.class);\n  }\n\n  onSelectChange(event: Event): void {\n    const raw = (event.target as HTMLSelectElement).value;\n\n    // Options rendered from `options` carry their index as the DOM value, so we\n    // can hand back the ORIGINAL value — object, number or string — untouched.\n    // Anything else came from a projected <option>, where the string is all\n    // there is.\n    const index = Number(raw);\n    const fromOptions = raw !== '' && Number.isInteger(index) && index >= 0 && index < this.options.length;\n    const next = fromOptions ? this.options[index].value : raw;\n\n    this.value = next;\n    this.onChange(next);\n    this.valueChange.emit(next);\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: (value: any) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.cdr.markForCheck();\n  }\n}\n"]}