@kato-lee/cdk 14.2.7

package/a11y-prebuilt.css

@@ -0,0 +1 @@
+.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}

package/accordion/index.d.ts

@@ -0,0 +1,140 @@
+import { BooleanInput } from '@kato-lee/cdk/coercion';
+import { ChangeDetectorRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { Subject } from 'rxjs';
+import { UniqueSelectionDispatcher } from '@kato-lee/cdk/collections';
+
+/**
+ * Injection token that can be used to reference instances of `CdkAccordion`. It serves
+ * as alternative token to the actual `CdkAccordion` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_ACCORDION: InjectionToken<CdkAccordion>;
+
+/**
+ * Directive whose purpose is to manage the expanded state of CdkAccordionItem children.
+ */
+export declare class CdkAccordion implements OnDestroy, OnChanges {
+  /** Emits when the state of the accordion changes */
+  readonly _stateChanges: Subject<SimpleChanges>;
+  /** Stream that emits true/false when openAll/closeAll is triggered. */
+  readonly _openCloseAllActions: Subject<boolean>;
+  /** A readonly id value to use for unique selection coordination. */
+  readonly id: string;
+  /** Whether the accordion should allow multiple expanded accordion items simultaneously. */
+  get multi(): boolean;
+  set multi(multi: BooleanInput);
+  private _multi;
+  /** Opens all enabled accordion items in an accordion where multi is enabled. */
+  openAll(): void;
+  /** Closes all enabled accordion items in an accordion where multi is enabled. */
+  closeAll(): void;
+  ngOnChanges(changes: SimpleChanges): void;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CdkAccordion, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<
+    CdkAccordion,
+    'cdk-accordion, [cdkAccordion]',
+    ['cdkAccordion'],
+    { multi: 'multi' },
+    {},
+    never,
+    never,
+    false
+  >;
+}
+
+/**
+ * An basic directive expected to be extended and decorated as a component.  Sets up all
+ * events and attributes needed to be managed by a CdkAccordion parent.
+ */
+export declare class CdkAccordionItem implements OnDestroy {
+  accordion: CdkAccordion;
+  private _changeDetectorRef;
+  protected _expansionDispatcher: UniqueSelectionDispatcher;
+  /** Subscription to openAll/closeAll events. */
+  private _openCloseAllSubscription;
+  /** Event emitted every time the AccordionItem is closed. */
+  readonly closed: EventEmitter<void>;
+  /** Event emitted every time the AccordionItem is opened. */
+  readonly opened: EventEmitter<void>;
+  /** Event emitted when the AccordionItem is destroyed. */
+  readonly destroyed: EventEmitter<void>;
+  /**
+   * Emits whenever the expanded state of the accordion changes.
+   * Primarily used to facilitate two-way binding.
+   * @docs-private
+   */
+  readonly expandedChange: EventEmitter<boolean>;
+  /** The unique AccordionItem id. */
+  readonly id: string;
+  /** Whether the AccordionItem is expanded. */
+  get expanded(): boolean;
+  set expanded(expanded: BooleanInput);
+  private _expanded;
+  /** Whether the AccordionItem is disabled. */
+  get disabled(): boolean;
+  set disabled(disabled: BooleanInput);
+  private _disabled;
+  /** Unregister function for _expansionDispatcher. */
+  private _removeUniqueSelectionListener;
+  constructor(
+    accordion: CdkAccordion,
+    _changeDetectorRef: ChangeDetectorRef,
+    _expansionDispatcher: UniqueSelectionDispatcher
+  );
+  /** Emits an event for the accordion item being destroyed. */
+  ngOnDestroy(): void;
+  /** Toggles the expanded state of the accordion item. */
+  toggle(): void;
+  /** Sets the expanded state of the accordion item to false. */
+  close(): void;
+  /** Sets the expanded state of the accordion item to true. */
+  open(): void;
+  private _subscribeToOpenCloseAllActions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<
+    CdkAccordionItem,
+    [{ optional: true; skipSelf: true }, null, null]
+  >;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<
+    CdkAccordionItem,
+    'cdk-accordion-item, [cdkAccordionItem]',
+    ['cdkAccordionItem'],
+    { expanded: 'expanded'; disabled: 'disabled' },
+    {
+      closed: 'closed';
+      opened: 'opened';
+      destroyed: 'destroyed';
+      expandedChange: 'expandedChange';
+    },
+    never,
+    never,
+    false
+  >;
+}
+
+export declare class CdkAccordionModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<CdkAccordionModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<
+    CdkAccordionModule,
+    [typeof i1.CdkAccordion, typeof i2.CdkAccordionItem],
+    never,
+    [typeof i1.CdkAccordion, typeof i2.CdkAccordionItem]
+  >;
+  static ɵinj: i0.ɵɵInjectorDeclaration<CdkAccordionModule>;
+}
+
+declare namespace i1 {
+  export { CDK_ACCORDION, CdkAccordion };
+}
+
+declare namespace i2 {
+  export { CdkAccordionItem };
+}
+
+export {};

package/bidi/index.d.ts

@@ -0,0 +1,80 @@
+import { AfterContentInit } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+export declare class BidiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BidiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BidiModule, [typeof i1.Dir], never, [typeof i1.Dir]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BidiModule>;
+}
+
+/**
+ * Directive to listen for changes of direction of part of the DOM.
+ *
+ * Provides itself as Directionality such that descendant directives only need to ever inject
+ * Directionality to get the closest direction.
+ */
+export declare class Dir implements Directionality, AfterContentInit, OnDestroy {
+    /** Normalized direction that accounts for invalid/unsupported values. */
+    private _dir;
+    /** Whether the `value` has been set to its initial value. */
+    private _isInitialized;
+    /** Direction as passed in by the consumer. */
+    _rawDir: string;
+    /** Event emitted when the direction changes. */
+    readonly change: EventEmitter<Direction>;
+    /** @docs-private */
+    get dir(): Direction;
+    set dir(value: Direction | 'auto');
+    /** Current layout direction of the element. */
+    get value(): Direction;
+    /** Initialize once default value has been set. */
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Dir, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Dir, "[dir]", ["dir"], { "dir": "dir"; }, { "change": "dirChange"; }, never, never, false>;
+}
+
+/**
+ * Injection token used to inject the document into Directionality.
+ * This is used so that the value can be faked in tests.
+ *
+ * We can't use the real document in tests because changing the real `dir` causes geometry-based
+ * tests in Safari to fail.
+ *
+ * We also can't re-provide the DOCUMENT token from platform-browser because the unit tests
+ * themselves use things like `querySelector` in test code.
+ *
+ * This token is defined in a separate file from Directionality as a workaround for
+ * https://github.com/angular/angular/issues/22559
+ *
+ * @docs-private
+ */
+export declare const DIR_DOCUMENT: InjectionToken<Document>;
+
+export declare type Direction = 'ltr' | 'rtl';
+
+/**
+ * The directionality (LTR / RTL) context for the application (or a subtree of it).
+ * Exposes the current direction and a stream of direction changes.
+ */
+export declare class Directionality implements OnDestroy {
+    /** The current 'ltr' or 'rtl' value. */
+    readonly value: Direction;
+    /** Stream that emits whenever the 'ltr' / 'rtl' state changes. */
+    readonly change: EventEmitter<Direction>;
+    constructor(_document?: any);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Directionality, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Directionality>;
+}
+
+declare namespace i1 {
+    export {
+        Dir
+    }
+}
+
+export { }

package/clipboard/index.d.ts

@@ -0,0 +1,115 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { NgZone } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+/** Injection token that can be used to provide the default options to `CdkCopyToClipboard`. */
+export declare const CDK_COPY_TO_CLIPBOARD_CONFIG: InjectionToken<CdkCopyToClipboardConfig>;
+
+/**
+ * Provides behavior for a button that when clicked copies content into user's
+ * clipboard.
+ */
+export declare class CdkCopyToClipboard implements OnDestroy {
+    private _clipboard;
+    private _ngZone;
+    /** Content to be copied. */
+    text: string;
+    /**
+     * How many times to attempt to copy the text. This may be necessary for longer text, because
+     * the browser needs time to fill an intermediate textarea element and copy the content.
+     */
+    attempts: number;
+    /**
+     * Emits when some text is copied to the clipboard. The
+     * emitted value indicates whether copying was successful.
+     */
+    readonly copied: EventEmitter<boolean>;
+    /** Copies that are currently being attempted. */
+    private _pending;
+    /** Whether the directive has been destroyed. */
+    private _destroyed;
+    /** Timeout for the current copy attempt. */
+    private _currentTimeout;
+    constructor(_clipboard: Clipboard_2, _ngZone: NgZone, config?: CdkCopyToClipboardConfig);
+    /** Copies the current text to the clipboard. */
+    copy(attempts?: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkCopyToClipboard, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkCopyToClipboard, "[cdkCopyToClipboard]", never, { "text": "cdkCopyToClipboard"; "attempts": "cdkCopyToClipboardAttempts"; }, { "copied": "cdkCopyToClipboardCopied"; }, never, never, false>;
+}
+
+/** Object that can be used to configure the default options for `CdkCopyToClipboard`. */
+export declare interface CdkCopyToClipboardConfig {
+    /** Default number of attempts to make when copying text to the clipboard. */
+    attempts?: number;
+}
+
+/**
+ * A service for copying text to the clipboard.
+ */
+declare class Clipboard_2 {
+    private readonly _document;
+    constructor(document: any);
+    /**
+     * Copies the provided text into the user's clipboard.
+     *
+     * @param text The string to copy.
+     * @returns Whether the operation was successful.
+     */
+    copy(text: string): boolean;
+    /**
+     * Prepares a string to be copied later. This is useful for large strings
+     * which take too long to successfully render and be copied in the same tick.
+     *
+     * The caller must call `destroy` on the returned `PendingCopy`.
+     *
+     * @param text The string to copy.
+     * @returns the pending copy operation.
+     */
+    beginCopy(text: string): PendingCopy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Clipboard_2, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Clipboard_2>;
+}
+export { Clipboard_2 as Clipboard }
+
+export declare class ClipboardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClipboardModule, [typeof i1.CdkCopyToClipboard], never, [typeof i1.CdkCopyToClipboard]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClipboardModule>;
+}
+
+declare namespace i1 {
+    export {
+        CdkCopyToClipboardConfig,
+        CDK_COPY_TO_CLIPBOARD_CONFIG,
+        CdkCopyToClipboard
+    }
+}
+
+
+/**
+ * A pending copy-to-clipboard operation.
+ *
+ * The implementation of copying text to the clipboard modifies the DOM and
+ * forces a re-layout. This re-layout can take too long if the string is large,
+ * causing the execCommand('copy') to happen too long after the user clicked.
+ * This results in the browser refusing to copy. This object lets the
+ * re-layout happen in a separate tick from copying by providing a copy function
+ * that can be called later.
+ *
+ * Destroy must be called when no longer in use, regardless of whether `copy` is
+ * called.
+ */
+export declare class PendingCopy {
+    private readonly _document;
+    private _textarea;
+    constructor(text: string, _document: Document);
+    /** Finishes copying the text. */
+    copy(): boolean;
+    /** Cleans up DOM changes used to perform the copy operation. */
+    destroy(): void;
+}
+
+export { }

package/coercion/index.d.ts

@@ -0,0 +1,67 @@
+import { ElementRef } from '@angular/core';
+
+
+/**
+ * Type describing the allowed values for a boolean input.
+ * @docs-private
+ */
+export declare type BooleanInput = string | boolean | null | undefined;
+
+
+/** Wraps the provided value in an array, unless the provided value is an array. */
+export declare function coerceArray<T>(value: T | T[]): T[];
+
+export declare function coerceArray<T>(value: T | readonly T[]): readonly T[];
+
+/** Coerces a data-bound value (typically a string) to a boolean. */
+export declare function coerceBooleanProperty(value: any): boolean;
+
+
+/** Coerces a value to a CSS pixel value. */
+export declare function coerceCssPixelValue(value: any): string;
+
+/**
+ * Coerces an ElementRef or an Element into an element.
+ * Useful for APIs that can accept either a ref or the native element itself.
+ */
+export declare function coerceElement<T>(elementOrRef: ElementRef<T> | T): T;
+
+/** Coerces a data-bound value (typically a string) to a number. */
+export declare function coerceNumberProperty(value: any): number;
+
+export declare function coerceNumberProperty<D>(value: any, fallback: D): number | D;
+
+
+/**
+ * Coerces a value to an array of trimmed non-empty strings.
+ * Any input that is not an array, `null` or `undefined` will be turned into a string
+ * via `toString()` and subsequently split with the given separator.
+ * `null` and `undefined` will result in an empty array.
+ * This results in the following outcomes:
+ * - `null` -&gt; `[]`
+ * - `[null]` -&gt; `["null"]`
+ * - `["a", "b ", " "]` -&gt; `["a", "b"]`
+ * - `[1, [2, 3]]` -&gt; `["1", "2,3"]`
+ * - `[{ a: 0 }]` -&gt; `["[object Object]"]`
+ * - `{ a: 0 }` -&gt; `["[object", "Object]"]`
+ *
+ * Useful for defining CSS classes or table columns.
+ * @param value the value to coerce into an array of strings
+ * @param separator split-separator if value isn't an array
+ */
+export declare function coerceStringArray(value: any, separator?: string | RegExp): string[];
+
+/**
+ * Whether the provided value is considered a number.
+ * @docs-private
+ */
+export declare function _isNumberValue(value: any): boolean;
+
+
+/**
+ * Type describing the allowed values for a number input
+ * @docs-private
+ */
+export declare type NumberInput = string | number | null | undefined;
+
+export { }