@dugararchit/cdk 0.0.0-dugararchit

package/types/stagefright5-cdk-accordion.d.ts

@@ -0,0 +1,95 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, OnChanges, SimpleChanges, EventEmitter, ChangeDetectorRef } from '@angular/core';
+import { UniqueSelectionDispatcher } from '@dugararchit/cdk/collections';
+import { BooleanInput } from '@dugararchit/cdk/coercion';
+import { Subject } from 'rxjs';
+
+/**
+ * Directive whose purpose is to manage the expanded state of CdkAccordionItem children.
+ */
+declare class CdkAccordion implements OnDestroy, OnChanges {
+    /** Emits when the state of the accordion changes */
+    readonly _stateChanges: Subject<{
+        [propName: string]: i0.SimpleChange<any>;
+    }>;
+    /** 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": { "alias": "multi"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * 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.
+ */
+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": { "alias": "expanded"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "closed": "closed"; "opened": "opened"; "destroyed": "destroyed"; "expandedChange": "expandedChange"; }, never, never, false, never>;
+}
+
+declare class CdkAccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkAccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkAccordionModule, [typeof CdkAccordion, typeof CdkAccordionItem], never, [typeof CdkAccordion, typeof CdkAccordionItem]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkAccordionModule>;
+}
+
+export { CdkAccordion, CdkAccordionItem, CdkAccordionModule };

package/types/stagefright5-cdk-bidi.d.ts

@@ -0,0 +1,95 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter, InjectionToken, AfterContentInit } from '@angular/core';
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+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.
+ */
+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>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * 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-brower 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
+ */
+declare const DIR_DOCUMENT: InjectionToken<Document>;
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * 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.
+ */
+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": { "alias": "dir"; "required": false; }; }, { "change": "dirChange"; }, never, never, false, never>;
+}
+
+declare class BidiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BidiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BidiModule, [typeof Dir], never, [typeof Dir]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BidiModule>;
+}
+
+export { BidiModule, DIR_DOCUMENT, Dir, Directionality };
+export type { Direction };

package/types/stagefright5-cdk-clipboard.d.ts

@@ -0,0 +1,116 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, EventEmitter, NgZone } from '@angular/core';
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * A pending copy-to-clipboard operation.
+ *
+ * The implementation of copying text to the clipboard modifies the DOM and
+ * forces a relayout. This relayout 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
+ * relayout 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.
+ */
+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;
+}
+
+/**
+ * A service for copying text to the clipboard.
+ */
+declare class Clipboard {
+    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, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Clipboard>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/** Object that can be used to configure the default options for `CdkCopyToClipboard`. */
+interface CdkCopyToClipboardConfig {
+    /** Default number of attempts to make when copying text to the clipboard. */
+    attempts?: number;
+}
+/** Injection token that can be used to provide the default options to `CdkCopyToClipboard`. */
+declare const CDK_COPY_TO_CLIPBOARD_CONFIG: InjectionToken<CdkCopyToClipboardConfig>;
+/**
+ * Provides behavior for a button that when clicked copies content into user's
+ * clipboard.
+ */
+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, _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": { "alias": "cdkCopyToClipboard"; "required": false; }; "attempts": { "alias": "cdkCopyToClipboardAttempts"; "required": false; }; }, { "copied": "cdkCopyToClipboardCopied"; }, never, never, false, never>;
+}
+
+declare class ClipboardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClipboardModule, [typeof CdkCopyToClipboard], never, [typeof CdkCopyToClipboard]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClipboardModule>;
+}
+
+export { CDK_COPY_TO_CLIPBOARD_CONFIG, CdkCopyToClipboard, Clipboard, ClipboardModule, PendingCopy };
+export type { CdkCopyToClipboardConfig };

package/types/stagefright5-cdk-coercion.d.ts

@@ -0,0 +1,101 @@
+import { ElementRef } from '@angular/core';
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Type describing the allowed values for a boolean input.
+ * @docs-private
+ */
+type BooleanInput = string | boolean | null | undefined;
+/** Coerces a data-bound value (typically a string) to a boolean. */
+declare function coerceBooleanProperty(value: any): boolean;
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Type describing the allowed values for a number input
+ * @docs-private
+ */
+type NumberInput = string | number | null | undefined;
+/** Coerces a data-bound value (typically a string) to a number. */
+declare function coerceNumberProperty(value: any): number;
+declare function coerceNumberProperty<D>(value: any, fallback: D): number | D;
+/**
+ * Whether the provided value is considered a number.
+ * @docs-private
+ */
+declare function _isNumberValue(value: any): boolean;
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/** Wraps the provided value in an array, unless the provided value is an array. */
+declare function coerceArray<T>(value: T | T[]): T[];
+declare function coerceArray<T>(value: T | readonly T[]): readonly T[];
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/** Coerces a value to a CSS pixel value. */
+declare function coerceCssPixelValue(value: any): string;
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * Coerces an ElementRef or an Element into an element.
+ * Useful for APIs that can accept either a ref or the native element itself.
+ */
+declare function coerceElement<T>(elementOrRef: ElementRef<T> | T): T;
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * 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
+ */
+declare function coerceStringArray(value: any, separator?: string | RegExp): string[];
+
+export { _isNumberValue, coerceArray, coerceBooleanProperty, coerceCssPixelValue, coerceElement, coerceNumberProperty, coerceStringArray };
+export type { BooleanInput, NumberInput };