@breadstone/mosaik-elements-angular 0.0.75 → 0.0.77

package/esm2022/Cdk/Breakpoint/BreakpointRegistry.mjs

@@ -0,0 +1,128 @@
+// #region Imports
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+// #endregion
+/**
+ * Registry of 1..n MediaQuery breakpoint ranges
+ * This is published as a provider and may be overridden from custom, application-specific ranges
+ *
+ * @public
+ */
+export class BreakpointRegistry {
+    // #region Fields
+    _items;
+    _findByMap = new Map();
+    // #endregion
+    // #region Ctor
+    /**
+     * Constructs a new instance of the `BreakPointRegistry` class.
+     *
+     * @public
+     */
+    constructor() {
+        this._items = new Array();
+    }
+    // #endregion
+    // #region Properties
+    /**
+     * Get all the breakpoints whose ranges could overlapping `normal` ranges;
+     * e.g. gt-sm overlaps md, lg, and xl
+     *
+     * @public
+     * @readonly
+     */
+    get overlapping() {
+        return this._items.filter((it) => it.overlapping);
+    }
+    /**
+     * Get list of all registered (non-empty) breakpoint aliases
+     *
+     * @public
+     * @readonly
+     */
+    get aliases() {
+        return this._items.map((it) => it.alias);
+    }
+    /**
+     * Aliases are mapped to properties using suffixes
+     * e.g.  'gt-sm' for property 'layout'  uses suffix 'GtSm'
+     * for property layoutGtSM.
+     *
+     * @public
+     * @readonly
+     */
+    get suffixes() {
+        return this._items.map((it) => it.suffix ?? '');
+    }
+    // #endregion
+    // #region Methods
+    /**
+     * Register a new breakpoint or array of breakpoints
+     *
+     * @public
+     */
+    register(breakpoint) {
+        const breakpoints = Array.isArray(breakpoint) ? breakpoint : [breakpoint];
+        breakpoints.forEach((x) => {
+            this._items.push(x);
+        });
+        reset(this._items, [...this._items].sort(sortAscendingPriority));
+    }
+    /**
+     * Search breakpoints by alias (e.g. gt-xs)
+     *
+     * @public
+     */
+    findByAlias(alias) {
+        return !alias ? null : this.findWithPredicate(alias, (bp) => bp.alias === alias);
+    }
+    /**
+     * Search breakpoints by media query (e.g. (min-width: 600px))
+     *
+     * @public
+     */
+    findByQuery(query) {
+        return this.findWithPredicate(query, (bp) => bp.mediaQuery === query);
+    }
+    /**
+     * Memoized lookup using custom predicate function
+     *
+     * @private
+     */
+    findWithPredicate(key, searchFn) {
+        let response = this._findByMap.get(key);
+        if (!response) {
+            response = this._items.find(searchFn) ?? null;
+            this._findByMap.set(key, response);
+        }
+        return response ?? null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: BreakpointRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: BreakpointRegistry });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: BreakpointRegistry, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+function sortAscendingPriority(a, b) {
+    const pA = a.priority ?? 0;
+    const pB = b.priority ?? 0;
+    return pA - pB;
+}
+function clear(self, fn) {
+    const splicedItems = self.splice(0, self.length);
+    if (fn) {
+        each(splicedItems, fn);
+    }
+    return self;
+}
+function reset(self, values) {
+    clear(self).push(...values);
+    return self;
+}
+function each(self, fn) {
+    self.forEach((x, i) => {
+        fn(x, i);
+    });
+    return self;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BreakpointRegistry.js","sourceRoot":"","sources":["../../../../src/Cdk/Breakpoint/BreakpointRegistry.ts"],"names":[],"mappings":"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","sourcesContent":["// #region Imports\n\nimport { Injectable } from '@angular/core';\nimport type { IBreakpoint } from '@breadstone/mosaik-elements-foundation';\n\n// #endregion\n\n/**\n * Registry of 1..n MediaQuery breakpoint ranges\n * This is published as a provider and may be overridden from custom, application-specific ranges\n *\n * @public\n */\n@Injectable()\nexport class BreakpointRegistry {\n\n    // #region Fields\n\n    private readonly _items: Array<IBreakpoint>;\n    private readonly _findByMap: Map<string, IBreakpoint | null> = new Map<string, IBreakpoint | null>();\n\n    // #endregion\n\n    // #region Ctor\n\n    /**\n     * Constructs a new instance of the `BreakPointRegistry` class.\n     *\n     * @public\n     */\n    public constructor() {\n        this._items = new Array<IBreakpoint>();\n    }\n\n    // #endregion\n\n    // #region Properties\n\n    /**\n     * Get all the breakpoints whose ranges could overlapping `normal` ranges;\n     * e.g. gt-sm overlaps md, lg, and xl\n     *\n     * @public\n     * @readonly\n     */\n    public get overlapping(): Array<IBreakpoint> {\n        return this._items.filter((it) => it.overlapping);\n    }\n\n    /**\n     * Get list of all registered (non-empty) breakpoint aliases\n     *\n     * @public\n     * @readonly\n     */\n    public get aliases(): Array<string> {\n        return this._items.map((it) => it.alias);\n    }\n\n    /**\n     * Aliases are mapped to properties using suffixes\n     * e.g.  'gt-sm' for property 'layout'  uses suffix 'GtSm'\n     * for property layoutGtSM.\n     *\n     * @public\n     * @readonly\n     */\n    public get suffixes(): Array<string> {\n        return this._items.map((it) => it.suffix ?? '');\n    }\n\n    // #endregion\n\n    // #region Methods\n\n    /**\n     * Register a new breakpoint or array of breakpoints\n     *\n     * @public\n     */\n    public register(breakpoint: IBreakpoint | Array<IBreakpoint>): void {\n        const breakpoints = Array.isArray(breakpoint) ? breakpoint : [breakpoint];\n\n        breakpoints.forEach((x) => {\n            this._items.push(x);\n        });\n\n        reset(this._items, [...this._items].sort(sortAscendingPriority));\n    }\n\n    /**\n     * Search breakpoints by alias (e.g. gt-xs)\n     *\n     * @public\n     */\n    public findByAlias(alias: string): IBreakpoint | null {\n        return !alias ? null : this.findWithPredicate(alias, (bp) => bp.alias === alias);\n    }\n\n    /**\n     * Search breakpoints by media query (e.g. (min-width: 600px))\n     *\n     * @public\n     */\n    public findByQuery(query: string): IBreakpoint | null {\n        return this.findWithPredicate(query, (bp) => bp.mediaQuery === query);\n    }\n\n    /**\n     * Memoized lookup using custom predicate function\n     *\n     * @private\n     */\n    private findWithPredicate(key: string, searchFn: (bp: IBreakpoint) => boolean): IBreakpoint | null {\n        let response = this._findByMap.get(key);\n        if (!response) {\n            response = this._items.find(searchFn) ?? null;\n            this._findByMap.set(key, response);\n        }\n        return response ?? null;\n    }\n\n    // #endregion\n\n}\n\nfunction sortAscendingPriority<T extends { priority?: number }>(a: T, b: T): number {\n    const pA = a.priority ?? 0;\n    const pB = b.priority ?? 0;\n    return pA - pB;\n}\n\nfunction clear<T>(self: Array<T>, fn?: (value: T, index: number) => void): Array<T> {\n    const splicedItems = self.splice(0, self.length);\n    if (fn) {\n        each(splicedItems, fn);\n    }\n    return self;\n}\n\nfunction reset<T>(self: Array<T>, values: Array<T>): Array<T> {\n    clear(self).push(...values);\n    return self;\n}\n\nfunction each<T>(self: Array<T> | ReadonlyArray<T>, fn: (value: T, index: number) => void): Array<T> | ReadonlyArray<T> {\n    self.forEach((x, i) => {\n        fn(x, i);\n    });\n    return self;\n}\n"]}

package/esm2022/Cdk/Cancel.mjs

@@ -0,0 +1,53 @@
+// #region Imports
+// #endregion
+/**
+ * @public
+ */
+export class Cancel {
+    // #region Fields
+    _result;
+    _reason;
+    // #endregion
+    // #region Ctor
+    /**
+     * Constructs a new instance of the `Cancel` class.
+     *
+     * @private
+     */
+    constructor(reason, result) {
+        this._reason = reason;
+        this._result = result;
+    }
+    // #endregion
+    // #region Properties
+    /**
+     * Gets or sets the `reason` property.
+     *
+     * @public
+     * @readonly
+     */
+    get reason() {
+        return this._reason;
+    }
+    /**
+     * Returns the `result` property.
+     *
+     * @public
+     * @readonly
+     */
+    get result() {
+        return this._result;
+    }
+    // #endregion
+    // #region Methods
+    static positive(result) {
+        return new Cancel('positive', result);
+    }
+    static negative(result) {
+        return new Cancel('negative', result);
+    }
+    static none(result) {
+        return new Cancel('none', result);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/Cdk/CancelReason.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FuY2VsUmVhc29uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL0Nkay9DYW5jZWxSZWFzb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQHB1YmxpY1xuICovXG5leHBvcnQgdHlwZSBDYW5jZWxSZWFzb24gPSAncG9zaXRpdmUnIHwgJ25lZ2F0aXZlJyB8ICdub25lJztcbiJdfQ==

package/esm2022/Cdk/Cdk.mjs

@@ -0,0 +1,31 @@
+export { Cancel } from './Cancel';
+export { DialogPortalComponent } from './Dialog/DialogPortalComponent';
+export { DIALOG_CONFIG, DIALOG_REF, DIALOG_REF_DATA } from './Dialog/DialogTokens';
+export { DialogRef } from './Dialog/DialogRef';
+export { DialogService } from './Dialog/DialogService';
+export { ToastService } from './Toast/ToastService';
+export { TypographyDirective } from './Theming/TypographyDirective';
+export { FormValidator } from './Forms/FormValidator';
+export { IconDirective } from './Icon/IconDirective';
+export { IconNameDirective } from './Icon/IconNameDirective';
+export { provideIcons } from './Icon/IconProvider';
+export { IconRegistry } from './Icon/IconRegistry';
+export { Validators } from './Forms/Validators/Validators';
+export { FormStatusDirective, FORM_STATUS_HOST } from './Forms/FormStatusDirective';
+export { FlipToDirective } from './Controls/Primitives/Directives/FlipToDirective';
+export { PerspectiveDirective } from './Controls/Effects/PerspectiveDirective';
+export { RippleDirective } from './Controls/Effects/RippleDirective';
+export { ScaleDirective } from './Controls/Effects/ScaleDirective';
+export { provideTranslations } from './Translate/TranslationProvider';
+export { TranslateDirective } from './Translate/TranslateDirective';
+export { TranslatePipe } from './Translate/TranslatePipe';
+export { BreakpointRegistry } from './Breakpoint/BreakpointRegistry';
+export { BreakpointDirective } from './Breakpoint/BreakpointDirective';
+export { provideBreakpoints } from './Breakpoint/BreakpointProvider';
+export { FlexDirective } from './Layout/FlexDirective';
+export { THEME, THEME_MODE } from './Theme/ThemeTokens';
+export { provideTheme } from './Theme/ThemeProvider';
+export { provideAnimate } from './Animations/AnimateProvider';
+export { AnimateDirective } from './Animations/AnimateDirective';
+export { AnimationRegistry } from './Animations/AnimationRegistry';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2RrLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL0Nkay9DZGsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUdsQyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN2RSxPQUFPLEVBQUUsYUFBYSxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRixPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHL0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXZELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNwRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzdELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDbkQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzNELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3BGLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrREFBa0QsQ0FBQztBQUNuRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUMvRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDckUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMxRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUN2RSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV4RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDckQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzlELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQ2FuY2VsIH0gZnJvbSAnLi9DYW5jZWwnO1xuZXhwb3J0IHR5cGUgeyBDYW5jZWxSZWFzb24gfSBmcm9tICcuL0NhbmNlbFJlYXNvbic7XG5leHBvcnQgdHlwZSB7IElDYW5jZWwgfSBmcm9tICcuL0lDYW5jZWwnO1xuZXhwb3J0IHsgRGlhbG9nUG9ydGFsQ29tcG9uZW50IH0gZnJvbSAnLi9EaWFsb2cvRGlhbG9nUG9ydGFsQ29tcG9uZW50JztcbmV4cG9ydCB7IERJQUxPR19DT05GSUcsIERJQUxPR19SRUYsIERJQUxPR19SRUZfREFUQSB9IGZyb20gJy4vRGlhbG9nL0RpYWxvZ1Rva2Vucyc7XG5leHBvcnQgeyBEaWFsb2dSZWYgfSBmcm9tICcuL0RpYWxvZy9EaWFsb2dSZWYnO1xuZXhwb3J0IHR5cGUgeyBJRGlhbG9nUmVmIH0gZnJvbSAnLi9EaWFsb2cvSURpYWxvZ1JlZic7XG5leHBvcnQgdHlwZSB7IElEaWFsb2dDb25maWcsIE9ic2VydmFibGVMaWtlIH0gZnJvbSAnLi9EaWFsb2cvSURpYWxvZ0NvbmZpZyc7XG5leHBvcnQgeyBEaWFsb2dTZXJ2aWNlIH0gZnJvbSAnLi9EaWFsb2cvRGlhbG9nU2VydmljZSc7XG5leHBvcnQgdHlwZSB7IElEaWFsb2dCZWhhdmlvciwgSVBvcnRhbFByb3ZpZGVyQmVoYXZpb3IgfSBmcm9tICcuL0RpYWxvZy9JRGlhbG9nQmVoYXZpb3InO1xuZXhwb3J0IHsgVG9hc3RTZXJ2aWNlIH0gZnJvbSAnLi9Ub2FzdC9Ub2FzdFNlcnZpY2UnO1xuZXhwb3J0IHsgVHlwb2dyYXBoeURpcmVjdGl2ZSB9IGZyb20gJy4vVGhlbWluZy9UeXBvZ3JhcGh5RGlyZWN0aXZlJztcbmV4cG9ydCB7IEZvcm1WYWxpZGF0b3IgfSBmcm9tICcuL0Zvcm1zL0Zvcm1WYWxpZGF0b3InO1xuZXhwb3J0IHsgSWNvbkRpcmVjdGl2ZSB9IGZyb20gJy4vSWNvbi9JY29uRGlyZWN0aXZlJztcbmV4cG9ydCB7IEljb25OYW1lRGlyZWN0aXZlIH0gZnJvbSAnLi9JY29uL0ljb25OYW1lRGlyZWN0aXZlJztcbmV4cG9ydCB7IHByb3ZpZGVJY29ucyB9IGZyb20gJy4vSWNvbi9JY29uUHJvdmlkZXInO1xuZXhwb3J0IHsgSWNvblJlZ2lzdHJ5IH0gZnJvbSAnLi9JY29uL0ljb25SZWdpc3RyeSc7XG5leHBvcnQgeyBWYWxpZGF0b3JzIH0gZnJvbSAnLi9Gb3Jtcy9WYWxpZGF0b3JzL1ZhbGlkYXRvcnMnO1xuZXhwb3J0IHsgRm9ybVN0YXR1c0RpcmVjdGl2ZSwgRk9STV9TVEFUVVNfSE9TVCB9IGZyb20gJy4vRm9ybXMvRm9ybVN0YXR1c0RpcmVjdGl2ZSc7XG5leHBvcnQgeyBGbGlwVG9EaXJlY3RpdmUgfSBmcm9tICcuL0NvbnRyb2xzL1ByaW1pdGl2ZXMvRGlyZWN0aXZlcy9GbGlwVG9EaXJlY3RpdmUnO1xuZXhwb3J0IHsgUGVyc3BlY3RpdmVEaXJlY3RpdmUgfSBmcm9tICcuL0NvbnRyb2xzL0VmZmVjdHMvUGVyc3BlY3RpdmVEaXJlY3RpdmUnO1xuZXhwb3J0IHsgUmlwcGxlRGlyZWN0aXZlIH0gZnJvbSAnLi9Db250cm9scy9FZmZlY3RzL1JpcHBsZURpcmVjdGl2ZSc7XG5leHBvcnQgeyBTY2FsZURpcmVjdGl2ZSB9IGZyb20gJy4vQ29udHJvbHMvRWZmZWN0cy9TY2FsZURpcmVjdGl2ZSc7XG5leHBvcnQgeyBwcm92aWRlVHJhbnNsYXRpb25zIH0gZnJvbSAnLi9UcmFuc2xhdGUvVHJhbnNsYXRpb25Qcm92aWRlcic7XG5leHBvcnQgeyBUcmFuc2xhdGVEaXJlY3RpdmUgfSBmcm9tICcuL1RyYW5zbGF0ZS9UcmFuc2xhdGVEaXJlY3RpdmUnO1xuZXhwb3J0IHsgVHJhbnNsYXRlUGlwZSB9IGZyb20gJy4vVHJhbnNsYXRlL1RyYW5zbGF0ZVBpcGUnO1xuZXhwb3J0IHsgQnJlYWtwb2ludFJlZ2lzdHJ5IH0gZnJvbSAnLi9CcmVha3BvaW50L0JyZWFrcG9pbnRSZWdpc3RyeSc7XG5leHBvcnQgeyBCcmVha3BvaW50RGlyZWN0aXZlIH0gZnJvbSAnLi9CcmVha3BvaW50L0JyZWFrcG9pbnREaXJlY3RpdmUnO1xuZXhwb3J0IHsgcHJvdmlkZUJyZWFrcG9pbnRzIH0gZnJvbSAnLi9CcmVha3BvaW50L0JyZWFrcG9pbnRQcm92aWRlcic7XG5leHBvcnQgeyBGbGV4RGlyZWN0aXZlIH0gZnJvbSAnLi9MYXlvdXQvRmxleERpcmVjdGl2ZSc7XG5leHBvcnQgeyBUSEVNRSwgVEhFTUVfTU9ERSB9IGZyb20gJy4vVGhlbWUvVGhlbWVUb2tlbnMnO1xuZXhwb3J0IHR5cGUgeyBUaGVtZU92ZXJyaWRlIH0gZnJvbSAnLi9UaGVtZS9UaGVtZVByb3ZpZGVyJztcbmV4cG9ydCB7IHByb3ZpZGVUaGVtZSB9IGZyb20gJy4vVGhlbWUvVGhlbWVQcm92aWRlcic7XG5leHBvcnQgeyBwcm92aWRlQW5pbWF0ZSB9IGZyb20gJy4vQW5pbWF0aW9ucy9BbmltYXRlUHJvdmlkZXInO1xuZXhwb3J0IHsgQW5pbWF0ZURpcmVjdGl2ZSB9IGZyb20gJy4vQW5pbWF0aW9ucy9BbmltYXRlRGlyZWN0aXZlJztcbmV4cG9ydCB7IEFuaW1hdGlvblJlZ2lzdHJ5IH0gZnJvbSAnLi9BbmltYXRpb25zL0FuaW1hdGlvblJlZ2lzdHJ5JztcbiJdfQ==

package/esm2022/Cdk/Controls/Effects/PerspectiveDirective.mjs

@@ -0,0 +1,82 @@
+// #region Imports
+import { Directive, ElementRef, Input, inject, effect, signal, Renderer2 } from '@angular/core';
+import { PerspectiveElement } from '@breadstone/mosaik-elements-foundation';
+import * as i0 from "@angular/core";
+// #endregion
+/**
+ * Directive that attaches a `PerspectiveElement` to its host element
+ * and updates it reactively based on the configuration input.
+ *
+ * @example
+ * <div [mosaikPerspective]="{ distance: 800, rotation: '45deg' }"></div>
+ *
+ * @public
+ */
+export class PerspectiveDirective {
+    // #region Fields
+    _element;
+    _renderer;
+    _config;
+    _perspectiveElement;
+    _cleanup;
+    // #endregion
+    // #region Ctor
+    /**
+     * Constructs a new instance of the `PerspectiveDirective` class.
+     *
+     * @public
+     */
+    constructor() {
+        this._element = inject((ElementRef));
+        this._renderer = inject(Renderer2);
+        this._config = signal({});
+        this._perspectiveElement = new PerspectiveElement();
+        this._cleanup = effect(() => {
+            const config = this._config();
+            Object.assign(this._perspectiveElement, config);
+            this._perspectiveElement.attach(this._element.nativeElement);
+        });
+    }
+    // #endregion
+    // #region Properties
+    /**
+     * Configuration input for the perspective behavior.
+     *
+     * @public
+     */
+    set config(value) {
+        this._config.set(value);
+    }
+    get config() {
+        return this._config();
+    }
+    // #endregion
+    // #region Methods
+    /**
+     * @public
+     */
+    ngOnInit() {
+        this._renderer.appendChild(this._element.nativeElement, this._perspectiveElement);
+    }
+    /**
+     * @public
+     */
+    ngOnDestroy() {
+        this._cleanup.destroy();
+        this._perspectiveElement.detach();
+        this._perspectiveElement.remove();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: PerspectiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.6", type: PerspectiveDirective, isStandalone: true, selector: "[mosaikPerspective]", inputs: { config: ["mosaikPerspective", "config"] }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: PerspectiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mosaikPerspective]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input,
+                args: ['mosaikPerspective']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/Cdk/Controls/Effects/RippleDirective.mjs

@@ -0,0 +1,83 @@
+// #region Imports
+import { Directive, ElementRef, Input, inject, effect, signal, Renderer2 } from '@angular/core';
+import { RippleElement } from '@breadstone/mosaik-elements-foundation';
+import * as i0 from "@angular/core";
+// #endregion
+/**
+ * Directive that attaches a `RippleElement` to its host element
+ * and updates it when input properties change.
+ *
+ * @example
+ * <button [mosaikRipple]="{ disabled: false, centered: true }">Click me</button>
+ *
+ * @public
+ */
+export class RippleDirective {
+    // #region Fields
+    _element;
+    _renderer;
+    _config;
+    _rippleElement;
+    _cleanup;
+    // #endregion
+    // #region Ctor
+    /**
+     * Constructs a new instance of the `RippleDirective` class.
+     *
+     * @public
+     */
+    constructor() {
+        this._element = inject((ElementRef));
+        this._renderer = inject(Renderer2);
+        this._config = signal({});
+        this._rippleElement = new RippleElement();
+        this._cleanup = effect(() => {
+            const config = this._config();
+            Object.assign(this._rippleElement, config);
+            this._rippleElement.attach(this._element.nativeElement);
+        });
+    }
+    // #endregion
+    // #region Properties
+    /**
+     * Configuration for the ripple behavior.
+     *
+     * @public
+     */
+    set config(value) {
+        this._config.set(value);
+    }
+    get config() {
+        return this._config();
+    }
+    // #endregion
+    // #region Methods
+    /**
+     * @public
+     */
+    ngOnInit() {
+        const hostElement = this._element.nativeElement;
+        this._renderer.appendChild(hostElement, this._rippleElement);
+    }
+    /**
+     * @public
+     */
+    ngOnDestroy() {
+        this._cleanup.destroy();
+        this._rippleElement.detach();
+        this._rippleElement.remove();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: RippleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.6", type: RippleDirective, isStandalone: true, selector: "[mosaikRipple]", inputs: { config: ["mosaikRipple", "config"] }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: RippleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mosaikRipple]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input,
+                args: ['mosaikRipple']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/Cdk/Controls/Effects/ScaleDirective.mjs

@@ -0,0 +1,83 @@
+// #region Imports
+import { Directive, ElementRef, Input, inject, effect, signal, Renderer2 } from '@angular/core';
+import { ScaleElement } from '@breadstone/mosaik-elements-foundation';
+import * as i0 from "@angular/core";
+// #endregion
+/**
+ * Directive that attaches a `ScaleElement` to its host element
+ * and updates it when input properties change.
+ *
+ * @example
+ * <div [mosaikScale]="{ value: 1.2, origin: 'left' }"></div>
+ *
+ * @public
+ */
+export class ScaleDirective {
+    // #region Fields
+    _element;
+    _renderer;
+    _config;
+    _scaleElement;
+    _cleanup;
+    // #endregion
+    // #region Ctor
+    /**
+     * Constructs a new instance of the `ScaleDirective` class.
+     *
+     * @public
+     */
+    constructor() {
+        this._element = inject((ElementRef));
+        this._renderer = inject(Renderer2);
+        this._config = signal({});
+        this._scaleElement = new ScaleElement();
+        this._cleanup = effect(() => {
+            const config = this._config();
+            Object.assign(this._scaleElement, config);
+            this._scaleElement.attach(this._element.nativeElement);
+        });
+    }
+    // #endregion
+    // #region Properties
+    /**
+     * Configuration input for the scale behavior.
+     *
+     * @public
+     */
+    get config() {
+        return this._config();
+    }
+    set config(value) {
+        this._config.set(value);
+    }
+    // #endregion
+    // #region Methods
+    /**
+     * @public
+     */
+    ngOnInit() {
+        const hostElement = this._element.nativeElement;
+        this._renderer.appendChild(hostElement, this._scaleElement);
+    }
+    /**
+     * @public
+     */
+    ngOnDestroy() {
+        this._cleanup.destroy();
+        this._scaleElement.detach();
+        this._scaleElement.remove();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: ScaleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.6", type: ScaleDirective, isStandalone: true, selector: "[mosaikScale]", inputs: { config: ["mosaikScale", "config"] }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: ScaleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mosaikScale]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input,
+                args: ['mosaikScale']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NhbGVEaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvQ2RrL0NvbnRyb2xzL0VmZmVjdHMvU2NhbGVEaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0JBQWtCO0FBRWxCLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBcUIsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUE2QixNQUFNLGVBQWUsQ0FBQztBQUM5SSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0NBQXdDLENBQUM7O0FBRXRFLGFBQWE7QUFFYjs7Ozs7Ozs7R0FRRztBQUtILE1BQU0sT0FBTyxjQUFjO0lBRXZCLGlCQUFpQjtJQUVBLFFBQVEsQ0FBMEI7SUFDbEMsU0FBUyxDQUFZO0lBQ3JCLE9BQU8sQ0FBOEM7SUFDckQsYUFBYSxDQUFlO0lBQzVCLFFBQVEsQ0FBWTtJQUVyQyxhQUFhO0lBRWIsZUFBZTtJQUVmOzs7O09BSUc7SUFDSDtRQUNJLElBQUksQ0FBQyxRQUFRLEdBQUcsTUFBTSxDQUFDLENBQUEsVUFBdUIsQ0FBQSxDQUFDLENBQUM7UUFDaEQsSUFBSSxDQUFDLFNBQVMsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDbkMsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQThCLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZELElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUN4QyxJQUFJLENBQUMsUUFBUSxHQUFHLE1BQU0sQ0FBQyxHQUFHLEVBQUU7WUFDeEIsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQzlCLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxNQUFNLENBQUMsQ0FBQztZQUMxQyxJQUFJLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQzNELENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVELGFBQWE7SUFFYixxQkFBcUI7SUFFckI7Ozs7T0FJRztJQUNILElBQ1csTUFBTTtRQUNiLE9BQU8sSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzFCLENBQUM7SUFDRCxJQUFXLE1BQU0sQ0FBQyxLQUFrQztRQUNoRCxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM1QixDQUFDO0lBRUQsYUFBYTtJQUViLGtCQUFrQjtJQUVsQjs7T0FFRztJQUNJLFFBQVE7UUFDWCxNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBQztRQUNoRCxJQUFJLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7SUFFRDs7T0FFRztJQUNJLFdBQVc7UUFDZCxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ3hCLElBQUksQ0FBQyxhQUFhLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDNUIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztJQUNoQyxDQUFDO3VHQW5FUSxjQUFjOzJGQUFkLGNBQWM7OzJGQUFkLGNBQWM7a0JBSjFCLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLGVBQWU7b0JBQ3pCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQjt3REEwQ2MsTUFBTTtzQkFEaEIsS0FBSzt1QkFBQyxhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiLy8gI3JlZ2lvbiBJbXBvcnRzXG5cbmltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSW5wdXQsIE9uRGVzdHJveSwgT25Jbml0LCBpbmplY3QsIGVmZmVjdCwgc2lnbmFsLCBSZW5kZXJlcjIsIEVmZmVjdFJlZiwgV3JpdGFibGVTaWduYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFNjYWxlRWxlbWVudCB9IGZyb20gJ0BicmVhZHN0b25lL21vc2Fpay1lbGVtZW50cy1mb3VuZGF0aW9uJztcblxuLy8gI2VuZHJlZ2lvblxuXG4vKipcbiAqIERpcmVjdGl2ZSB0aGF0IGF0dGFjaGVzIGEgYFNjYWxlRWxlbWVudGAgdG8gaXRzIGhvc3QgZWxlbWVudFxuICogYW5kIHVwZGF0ZXMgaXQgd2hlbiBpbnB1dCBwcm9wZXJ0aWVzIGNoYW5nZS5cbiAqXG4gKiBAZXhhbXBsZVxuICogPGRpdiBbbW9zYWlrU2NhbGVdPVwieyB2YWx1ZTogMS4yLCBvcmlnaW46ICdsZWZ0JyB9XCI+PC9kaXY+XG4gKlxuICogQHB1YmxpY1xuICovXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJ1ttb3NhaWtTY2FsZV0nLFxuICAgIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgU2NhbGVEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkluaXQsIE9uRGVzdHJveSB7XG5cbiAgICAvLyAjcmVnaW9uIEZpZWxkc1xuXG4gICAgcHJpdmF0ZSByZWFkb25seSBfZWxlbWVudDogRWxlbWVudFJlZjxIVE1MRWxlbWVudD47XG4gICAgcHJpdmF0ZSByZWFkb25seSBfcmVuZGVyZXI6IFJlbmRlcmVyMjtcbiAgICBwcml2YXRlIHJlYWRvbmx5IF9jb25maWc6IFdyaXRhYmxlU2lnbmFsPFBhcnRpYWw8U2NhbGVFbGVtZW50LlByb3BzPj47XG4gICAgcHJpdmF0ZSByZWFkb25seSBfc2NhbGVFbGVtZW50OiBTY2FsZUVsZW1lbnQ7XG4gICAgcHJpdmF0ZSByZWFkb25seSBfY2xlYW51cDogRWZmZWN0UmVmO1xuXG4gICAgLy8gI2VuZHJlZ2lvblxuXG4gICAgLy8gI3JlZ2lvbiBDdG9yXG5cbiAgICAvKipcbiAgICAgKiBDb25zdHJ1Y3RzIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBgU2NhbGVEaXJlY3RpdmVgIGNsYXNzLlxuICAgICAqXG4gICAgICogQHB1YmxpY1xuICAgICAqL1xuICAgIHB1YmxpYyBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgdGhpcy5fZWxlbWVudCA9IGluamVjdChFbGVtZW50UmVmPEhUTUxFbGVtZW50Pik7XG4gICAgICAgIHRoaXMuX3JlbmRlcmVyID0gaW5qZWN0KFJlbmRlcmVyMik7XG4gICAgICAgIHRoaXMuX2NvbmZpZyA9IHNpZ25hbDxQYXJ0aWFsPFNjYWxlRWxlbWVudC5Qcm9wcz4+KHt9KTtcbiAgICAgICAgdGhpcy5fc2NhbGVFbGVtZW50ID0gbmV3IFNjYWxlRWxlbWVudCgpO1xuICAgICAgICB0aGlzLl9jbGVhbnVwID0gZWZmZWN0KCgpID0+IHtcbiAgICAgICAgICAgIGNvbnN0IGNvbmZpZyA9IHRoaXMuX2NvbmZpZygpO1xuICAgICAgICAgICAgT2JqZWN0LmFzc2lnbih0aGlzLl9zY2FsZUVsZW1lbnQsIGNvbmZpZyk7XG4gICAgICAgICAgICB0aGlzLl9zY2FsZUVsZW1lbnQuYXR0YWNoKHRoaXMuX2VsZW1lbnQubmF0aXZlRWxlbWVudCk7XG4gICAgICAgIH0pO1xuICAgIH1cblxuICAgIC8vICNlbmRyZWdpb25cblxuICAgIC8vICNyZWdpb24gUHJvcGVydGllc1xuXG4gICAgLyoqXG4gICAgICogQ29uZmlndXJhdGlvbiBpbnB1dCBmb3IgdGhlIHNjYWxlIGJlaGF2aW9yLlxuICAgICAqXG4gICAgICogQHB1YmxpY1xuICAgICAqL1xuICAgIEBJbnB1dCgnbW9zYWlrU2NhbGUnKVxuICAgIHB1YmxpYyBnZXQgY29uZmlnKCk6IFBhcnRpYWw8U2NhbGVFbGVtZW50LlByb3BzPiB7XG4gICAgICAgIHJldHVybiB0aGlzLl9jb25maWcoKTtcbiAgICB9XG4gICAgcHVibGljIHNldCBjb25maWcodmFsdWU6IFBhcnRpYWw8U2NhbGVFbGVtZW50LlByb3BzPikge1xuICAgICAgICB0aGlzLl9jb25maWcuc2V0KHZhbHVlKTtcbiAgICB9XG5cbiAgICAvLyAjZW5kcmVnaW9uXG5cbiAgICAvLyAjcmVnaW9uIE1ldGhvZHNcblxuICAgIC8qKlxuICAgICAqIEBwdWJsaWNcbiAgICAgKi9cbiAgICBwdWJsaWMgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgICAgIGNvbnN0IGhvc3RFbGVtZW50ID0gdGhpcy5fZWxlbWVudC5uYXRpdmVFbGVtZW50O1xuICAgICAgICB0aGlzLl9yZW5kZXJlci5hcHBlbmRDaGlsZChob3N0RWxlbWVudCwgdGhpcy5fc2NhbGVFbGVtZW50KTtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBAcHVibGljXG4gICAgICovXG4gICAgcHVibGljIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgICAgICB0aGlzLl9jbGVhbnVwLmRlc3Ryb3koKTtcbiAgICAgICAgdGhpcy5fc2NhbGVFbGVtZW50LmRldGFjaCgpO1xuICAgICAgICB0aGlzLl9zY2FsZUVsZW1lbnQucmVtb3ZlKCk7XG4gICAgfVxuXG4gICAgLy8gI2VuZHJlZ2lvblxuXG59XG4iXX0=

package/esm2022/Cdk/Controls/Primitives/Directives/FlipToDirective.mjs

@@ -0,0 +1,66 @@
+// #region Imports
+import { Directive, HostListener, inject, Input } from '@angular/core';
+import { FlipComponent } from '../../../../Controls/Components/Primitives/Flip/FlipComponent';
+import * as i0 from "@angular/core";
+// #endregion
+export class FlipToDirective {
+    // #region Fields
+    _flip;
+    // #endregion
+    // #region Ctor
+    /**
+     * Constructs a new instance of the `FlipToDirective` class.
+     *
+     * @public
+     */
+    constructor() {
+        this._flip = inject(FlipComponent);
+    }
+    // #endregion
+    // #region Properties
+    /**
+     * The flip side to which the component will be flipped.
+     *
+     * @public
+     */
+    to;
+    disabled;
+    // #endregion
+    // #region Methods
+    /**
+     * @protected
+     */
+    onClick(_event) {
+        if (this.disabled) {
+            return;
+        }
+        if (this.to === undefined) {
+            return;
+        }
+        this._flip.side = this.to;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: FlipToDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.6", type: FlipToDirective, isStandalone: true, selector: "[mosaikFlipTo]", inputs: { to: ["mosaikFlipTo", "to"], disabled: ["mosaikFlipToDisabled", "disabled"] }, host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: FlipToDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mosaikFlipTo]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { to: [{
+                type: Input,
+                args: [{
+                        alias: 'mosaikFlipTo',
+                        required: true
+                    }]
+            }], disabled: [{
+                type: Input,
+                args: [{
+                        alias: 'mosaikFlipToDisabled'
+                    }]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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