@daffodil/design 0.81.1 → 0.83.0

package/toast/examples/dismissible-toast/dismissible-toast.component.d.ts

@@ -0,0 +1,11 @@
+import { DaffToastService } from '@daffodil/design/toast';
+import * as i0 from "@angular/core";
+export declare class DismissibleToastComponent {
+    private toastService;
+    private toast;
+    constructor(toastService: DaffToastService);
+    open(): void;
+    private count;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DismissibleToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DismissibleToastComponent, "dismissible-toast", never, {}, {}, never, never, true, never>;
+}

package/toast/examples/public_api.d.ts

@@ -1,5 +1,6 @@
 import { DefaultToastComponent } from './default-toast/default-toast.component';
+import { DismissibleToastComponent } from './dismissible-toast/dismissible-toast.component';
 import { ToastPositionsComponent } from './toast-positions/toast-positions.component';
 import { ToastStatusComponent } from './toast-status/toast-status.component';
 import { ToastWithCustomDurationComponent } from './toast-with-custom-duration/toast-with-custom-duration.component';
-export declare const TOAST_EXAMPLES: (typeof DefaultToastComponent | typeof ToastPositionsComponent | typeof ToastStatusComponent | typeof ToastWithCustomDurationComponent)[];
+export declare const TOAST_EXAMPLES: (typeof DefaultToastComponent | typeof DismissibleToastComponent | typeof ToastPositionsComponent | typeof ToastStatusComponent | typeof ToastWithCustomDurationComponent)[];

package/toast/interfaces/toast-action.d.ts

@@ -1,34 +1,45 @@
 import { EventEmitter } from '@angular/core';
 import { DaffPalette, DaffStatus } from '@daffodil/design';
+import { DaffToastActionButtonSize, DaffToastActionButtonType } from './toast-action.type';
 /**
- * An interface for properties of actions, specifically the DaffButtonComponent, placed inside of the toast.
+ * The configurations for an action button rendered inside a toast
+ * displayed using the {@link DaffButtonComponent}.
  */
 export interface DaffToastAction {
     /**
-     * The types of buttons available to be used, as defined in the {@link DaffButtonComponent}.
+     * The type of button.
+     *
+     * Matches one of the predefined types supported by {@link DaffButtonComponent}.
      */
-    type?: 'raised' | 'underline' | 'stroked' | 'flat' | undefined;
+    type?: DaffToastActionButtonType;
     /**
-     * The text for the button
+     * The text displayed on the button.
      */
     content: string;
     /**
-     * The size of the button, as defined in the {@link DaffButtonComponent}.
+     * The size of the button.
+     *
+     * Matches one of the predefined sizes supported by {@link DaffButtonComponent}.
      */
-    size?: 'sm' | 'md' | 'lg' | undefined;
+    size?: DaffToastActionButtonSize;
     /**
-     * The color of the button, as defined in the {@link DaffButtonComponent}.
-     * Color and status should not be used simultaneously.
+     * The color of the button.
+     *
+     * Do not use both `color` and `status` simultaneously.
      */
     color?: DaffPalette;
     /**
-     * The status of the button, as defined in the {@link DaffButtonComponent}.
-     * Color and status should not be used simultaneously.
+     * The button status.
+     *
+     * Do not use both `color` and `status` simultaneously.
      */
     status?: DaffStatus;
+    /**
+     * Data associated with the action.
+     */
     data?: Record<string, any>;
     /**
-     * Sets an EventEmitter on a DaffToastAction
+     * An event emitter that fires when the action is triggered.
      */
     eventEmitter?: EventEmitter<DaffToastAction>;
 }

package/toast/interfaces/toast-action.type.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The available button styles that can be used in {@link DaffToastAction}.
+ * These correspond to the types supported by {@link DaffButtonComponent}.
+ */
+export type DaffToastActionButtonType = 'raised' | 'underline' | 'stroked' | 'flat' | undefined;
+/**
+ * The available button sizes that can be used in {@link DaffToastAction}.
+ * These correspond to the types supported by {@link DaffButtonComponent}.
+ */
+export type DaffToastActionButtonSize = 'sm' | 'md' | 'lg' | undefined;

package/toast/interfaces/toast.d.ts

@@ -3,18 +3,24 @@ import { DaffStatus } from '@daffodil/design';
 import { DaffToastAction } from './toast-action';
 /** Possible data that can be shown on a toast */
 export interface DaffToastData {
-    /** A title that provides a quick oveview of the toast */
+    /** A title that provides a quick oveview of the toast. */
     title: string;
-    /** A short message used to provide additional details about the toast */
+    /** A short message used to provide additional details about the toast. */
     message?: string;
-    /** Sets a status on the toast */
+    /** Sets a status on the toast. */
     status?: DaffStatus;
-    /** Used to display actions in the toast */
+    /** Used to display actions in the toast. */
     actions?: DaffToastAction[];
-    /** Whether or not the toast is dismissible */
+    /** Whether or not the toast is dismissible. */
     dismissible?: boolean;
 }
 export interface DaffToast extends DaffToastData {
+    /**
+     * Closes the toast.
+     */
     dismiss: () => void;
+    /**
+     * The observable that emits when the toast is closed.
+     */
     dismissalStream: Observable<void | number>;
 }

package/toast/options/daff-toast-options.d.ts

@@ -10,4 +10,5 @@ export interface DaffToastOptions {
     useParent: boolean;
 }
 export declare const daffToastDefaultOptions: DaffToastOptions;
-export declare const DAFF_TOAST_OPTIONS: import("@angular/core").InjectionToken<DaffToastOptions>, provideDaffToastOptions: <R extends DaffToastOptions = DaffToastOptions>(config: Partial<R> | import("@angular/core").InjectionToken<Partial<R>>) => import("@angular/core").FactoryProvider;
+export declare const provideDaffToastOptions: <R extends DaffToastOptions = DaffToastOptions>(config: Partial<R> | import("@angular/core").InjectionToken<Partial<R>>) => import("@angular/core").FactoryProvider;
+export declare const DAFF_TOAST_OPTIONS: import("@angular/core").InjectionToken<DaffToastOptions>;

package/toast/public_api.d.ts

@@ -1,12 +1,8 @@
 export { DaffToastPositionService } from './service/position.service';
-export { DaffToastModule } from './toast.module';
 export { DaffToastService } from './service/toast.service';
 export { DaffToastConfiguration } from './toast/toast-config';
 export { DaffToast, DaffToastData, } from './interfaces/toast';
 export { DaffToastAction } from './interfaces/toast-action';
 export { DAFF_TOAST_OPTIONS, provideDaffToastOptions, } from './options/daff-toast-options';
-export * from './toast/toast.component';
-export * from './toast-actions/toast-actions.directive';
-export * from './toast-title/toast-title.directive';
-export * from './toast-message/toast-message.directive';
-export * from './toast/toast-provider';
+export { provideDaffToast } from './toast/toast-provider';
+export { DaffToastActionButtonSize, DaffToastActionButtonType, } from './interfaces/toast-action.type';

package/toast/service/position.service.d.ts

@@ -7,8 +7,16 @@ export declare class DaffToastPositionService {
     constructor(options: DaffToastOptions, mediaQuery: BreakpointObserver);
     private _config;
     private _position;
+    /**
+     * Reads the current position of the toast. Defaults to bottom center on mobile devices.
+     */
     get config(): DaffToastPosition;
-    set config(val: DaffToastPosition);
+    private set config(value);
+    /**
+     * Changes the position of the toast.
+     *
+     * @param position The position of the toast.
+     */
     setPosition(position: DaffToastPosition): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastPositionService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DaffToastPositionService>;

package/toast/service/toast.service.d.ts

@@ -7,6 +7,55 @@ import { DaffToast, DaffToastData } from '../interfaces/toast';
 import { DaffToastOptions } from '../options/daff-toast-options';
 import { DaffToastConfiguration } from '../toast/toast-config';
 import * as i0 from "@angular/core";
+/**
+ * Service to display toasts.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   ChangeDetectionStrategy,
+ *   Component,
+ *   EventEmitter,
+ *   OnInit,
+ * } from '@angular/core';
+ *
+ * import {
+ *   DaffToast,
+ *   DaffToastAction,
+ *   DaffToastService,
+ * } from '@daffodil/design/toast';
+ *
+ * @Component({
+ *   selector: 'default-toast',
+ *   templateUrl: './default-toast.component.html',
+ *   styles: [],
+ *   changeDetection: ChangeDetectionStrategy.OnPush,
+ * })
+ * export class DefaultToastComponent implements OnInit {
+ *   private toast: DaffToast;
+ *
+ *   constructor(private toastService: DaffToastService) {}
+ *
+ *   closeToast = new EventEmitter<DaffToastAction>();
+ *
+ *   open() {
+ *     this.toast = this.toastService.open({
+ *       title: 'Update Available',
+ *       message: 'A new version of this page is available.',
+ *       actions: [
+ *         { content: 'Remind me later', type: 'flat', size: 'sm', eventEmitter: this.closeToast },
+ *       ],
+ *     });
+ *   }
+ *
+ *   ngOnInit() {
+ *     this.closeToast.subscribe(() => {
+ *       this.toastService.close(this.toast);
+ *     });
+ *   }
+ * }
+ * ```
+ */
 export declare class DaffToastService implements OnDestroy {
     private overlay;
     private options;
@@ -20,10 +69,24 @@ export declare class DaffToastService implements OnDestroy {
     private _overlayRef?;
     private _template?;
     constructor(overlay: Overlay, options: DaffToastOptions, _parentToast: DaffToastService, mediaQuery: BreakpointObserver, toastPosition: DaffToastPositionService, focusStack: DaffFocusStackService, injector: Injector);
+    /**
+     * @docs-private
+     */
     ngOnDestroy(): void;
     private _attachToastTemplate;
     private _createOverlayRef;
+    /**
+     * Opens the toast.
+     *
+     * @param toast Data that can be shown on a toast.
+     * @param configuration Additional configuration options such as duration. The default duration is set to 5000ms.
+     */
     open(toast: DaffToastData, configuration?: Partial<DaffToastConfiguration>): DaffToast;
+    /**
+     * Closes the toast.
+     *
+     * @param toast The instance of toast that you wish to close.
+     */
     close(toast: DaffToast): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastService, [null, null, { optional: true; skipSelf: true; }, null, null, null, null]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DaffToastService>;

package/toast/src/toast-theme.scss

@@ -3,64 +3,111 @@
 @use '../../scss/theming';
 
 @mixin daff-toast-theme($theme) {
-	$primary: core.daff-map-get($theme, primary);
-	$secondary: core.daff-map-get($theme, secondary);
-	$tertiary: core.daff-map-get($theme, tertiary);
 	$info: core.daff-map-get($theme, informational);
 	$warn: core.daff-map-get($theme, warn);
 	$critical: core.daff-map-get($theme, critical);
 	$success: core.daff-map-get($theme, success);
 	$neutral: core.daff-map-get($theme, 'core', 'neutral');
 	$base: core.daff-map-get($theme, 'core', 'base');
-	$base-contrast: core.daff-map-get($theme, 'core', 'base-contrast');
-	$white: core.daff-map-get($theme, 'core', 'white');
 	$black: core.daff-map-get($theme, 'core', 'black');
+	$white: core.daff-map-get($theme, 'core', 'white');
+	$type: core.daff-map-get($theme, 'core', 'type');
 
 	.daff-toast {
-		background: theming.daff-illuminate($base, $neutral, 1);
-		box-shadow: 0 -16px 24px -4px rgba($black, 0.04), 0 8px 24px -4px rgba($black, 0.1);
-		color: theming.daff-text-contrast($base);
+		@include theming.light($type) {
+			background: theming.daff-color($neutral, 10);
+			box-shadow: 0 -16px 24px -4px rgba($black, 0.04),
+				0 8px 24px -4px rgba($black, 0.1);
+			color: theming.daff-text-contrast($base);
 
-		&::before {
-			background: theming.daff-illuminate($base, $neutral, 4);
-		}
+			&::before {
+				background: theming.daff-color($neutral, 40);
+			}
+
+			&.daff-success {
+				background: theming.daff-color($success, 10);
+				color: $black;
 
-		&.daff-success {
-			background: theming.daff-color($success, 10);
-			color: $black;
+				.daff-prefix {
+					color: theming.daff-color($success);
+				}
 
-			.daff-prefix {
-				color: theming.daff-color($success);
+				&::before {
+					background: theming.daff-color($success);
+				}
 			}
 
-			&::before {
-				background: theming.daff-color($success);
+			&.daff-warn {
+				background: theming.daff-color($warn, 10);
+				color: $black;
+
+				.daff-prefix {
+					color: theming.daff-color($warn);
+				}
+
+				&::before {
+					background: theming.daff-color($warn);
+				}
 			}
-		}
 
-		&.daff-warn {
-			background: theming.daff-color($warn, 10);
-			color: $black;
+			&.daff-critical {
+				background: theming.daff-color($critical, 10);
+				color: $black;
+
+				.daff-prefix {
+					color: theming.daff-color($critical);
+				}
 
-			.daff-prefix {
-				color: theming.daff-color($warn);
+				&::before {
+					background: theming.daff-color($critical);
+				}
 			}
+		}
+
+		@include theming.dark($type) {
+			background: theming.daff-color($neutral, 90);
+			box-shadow: 0 -16px 24px -4px rgba($black, 0.04),
+				0 8px 24px -4px rgba($black, 0.1);
+			color: theming.daff-text-contrast($base);
 
 			&::before {
-				background: theming.daff-color($warn);
+				background: theming.daff-color($neutral, 30);
 			}
-		}
 
-		&.daff-critical {
-			background: theming.daff-color($critical, 10);
-			color: $black;
+			&.daff-success {
+				background: theming.daff-color($success, 90);
 
-			.daff-prefix {
-				color: theming.daff-color($critical);
+				.daff-prefix {
+					color: theming.daff-color($success, 30);
+				}
+
+				&::before {
+					background: theming.daff-color($success, 30);
+				}
 			}
 
-			&::before {
-				background: theming.daff-color($critical);
+			&.daff-warn {
+				background: theming.daff-color($warn, 90);
+
+				.daff-prefix {
+					color: theming.daff-color($warn, 30);
+				}
+
+				&::before {
+					background: theming.daff-color($warn, 30);
+				}
+			}
+
+			&.daff-critical {
+				background: theming.daff-color($critical, 90);
+
+				.daff-prefix {
+					color: theming.daff-color($critical, 30);
+				}
+
+				&::before {
+					background: theming.daff-color($critical, 30);
+				}
 			}
 		}
 	}

package/toast/toast/toast-config.d.ts

@@ -1,6 +1,29 @@
 export interface DaffToastConfiguration {
     /**
-     * The duration (in milliseconds) that a toast is visible before it's dismissed.
+     * The duration (in milliseconds) for which a toast remains visible before dismissal.
+     *
+     * While you can set a duration for toasts with actions, it's generally not recommended,
+     * as users should have ample time to interact with them.
+     *
+     * @usage
+     * ```
+     * export class CustomComponent {
+     *   private toast: DaffToast;
+     *
+     *   constructor(private toastService: DaffToastService) {}
+     *
+     *   open() {
+     *     this.toast = this.toastService.open({
+     *       title: 'Update Complete',
+     *       message: 'This page has been updated to the newest version.',
+     *       status: 'success',
+     *     },
+     *     {
+     *       duration: 7000,
+     *     });
+     *   }
+     * }
+     * ```
      */
     duration?: number;
 }

package/toast/toast/toast-provider.d.ts

@@ -1,2 +1,18 @@
 import { Provider } from '@angular/core';
+/**
+ * Registers the `DaffToastService` and `DaffToastPositionService` for displaying a toast. This provider ensures
+ * toasts function correctly within your application.
+ *
+ * ```ts
+ * import { provideDaffToast } from '@daffodil/design/toast';
+ *
+ * @NgModule({
+ * 	providers: [
+ * 		provideDaffToast(),
+ * 	]
+ * )}
+ *
+ * export class AppModule {}
+ * ```
+ */
 export declare const provideDaffToast: () => Provider[];

package/toast/toast/toast.component.d.ts

@@ -6,6 +6,8 @@ import { DaffToastActionsDirective } from '../toast-actions/toast-actions.direct
 import * as i0 from "@angular/core";
 import * as i1 from "@daffodil/design";
 /**
+ * @docs-private
+ *
  * DaffToastComponent provides a way to display and
  * communicate information for user actions or system updates.
  */
@@ -13,9 +15,17 @@ export declare class DaffToastComponent implements DaffPrefixable, AfterContentI
     private _elementRef;
     private _focusTrapFactory;
     private _focusStack;
-    /** @docs-private */
+    /**
+     * @docs-private
+     */
     class: boolean;
+    /**
+     * @docs-private
+     */
     _actions: DaffToastActionsDirective;
+    /**
+     * @docs-private
+     */
     _prefix: DaffPrefixDirective;
     toast: DaffToast;
     /**
@@ -24,8 +34,17 @@ export declare class DaffToastComponent implements DaffPrefixable, AfterContentI
     onEscape(): void;
     private _focusTrap;
     constructor(_elementRef: ElementRef, _focusTrapFactory: ConfigurableFocusTrapFactory, _focusStack: DaffFocusStackService);
+    /**
+     * @docs-private
+     */
     ngAfterContentInit(): void;
+    /**
+     * @docs-private
+     */
     ngAfterViewInit(): void;
+    /**
+     * @docs-private
+     */
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DaffToastComponent, "daff-toast", never, { "toast": { "alias": "toast"; "required": false; }; }, {}, ["_actions", "_prefix"], ["[daffPrefix]", "[daffToastTitle]", "[daffToastMessage]", "[daffToastActions]", "*"], true, [{ directive: typeof i1.DaffArticleEncapsulatedDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.DaffStatusableDirective; inputs: { "status": "status"; }; outputs: {}; }]>;

package/toast/toast-actions/toast-actions.directive.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class DaffToastActionsDirective {
+    /**
+     * @docs-private
+     */
     class: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastActionsDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DaffToastActionsDirective, "[daffToastActions]", never, {}, {}, never, never, true, never>;

package/toast/toast-message/toast-message.directive.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class DaffToastMessageDirective {
+    /**
+     * @docs-private
+     */
     class: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastMessageDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DaffToastMessageDirective, "[daffToastMessage]", never, {}, {}, never, never, true, never>;

package/toast/toast-title/toast-title.directive.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class DaffToastTitleDirective {
+    /**
+     * @docs-private
+     */
     class: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastTitleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DaffToastTitleDirective, "[daffToastTitle]", never, {}, {}, never, never, true, never>;

package/tree/README.md

@@ -2,23 +2,26 @@
 Trees are used to visualize hierarchial information. They are often used to display navigational structures like nested lists of links.
 
 ## Overview
-
 The `DaffTreeComponent` renders a tree structure. Typically, this is a structure of `<a>` and `<button>` elements that allow users to either navigate to a page, or explore the tree to find an item inside the tree that they want to navigate to.
 
 Instead of defining a recursive tree structure of components, which is often prohibitively slow when rendering large trees, the `DaffTreeComponent` renders a flattened tree, using padding to indicate the nesting level of the tree elements.
 
 Generally, tree usage consists of taking existing tree data, converting it to the `DaffTreeData` format, setting the `tree` input on the `DaffTreeComponent`, and providing templates for the cases where the tree element has children or not.
 
+<design-land-example-viewer-container example="basic-tree">
+</design-land-example-viewer-container>
+
 ## Usage
 
 ### Within a standalone component
 To use sidebar in a standalone component, import `DAFF_TREE_COMPONENTS` directly into your custom component:
 
 ```ts
+import { DAFF_TREE_COMPONENTS } from '@daffodil/design/tree';
+
 @Component({
   selector: 'custom-component',
   templateUrl: './custom-component.component.html',
-  standalone: true,
   imports: [
     DAFF_TREE_COMPONENTS,
   ],
@@ -31,8 +34,8 @@ To use sidebar in a module, import `DaffTreeModule` into your custom module:
 
 ```ts
 import { NgModule } from '@angular/core';
-
 import { DaffTreeModule } from '@daffodil/design/tree';
+import { CustomComponent } from './custom.component';
 
 @NgModule({
 	declarations: [
@@ -65,13 +68,6 @@ Currently, we support two kind of templates: `daffTreeItemWithChildrenTpl` and `
 </ng-template>
 ```
 
-## Usage
-
-### Basic Tree
-
-<design-land-example-viewer-container example="basic-tree">
-</design-land-example-viewer-container>
-
 ## Accessibility
 
 The `DaffTreeComponent` follows the specification for a [disclosure navigation menu](https://www.w3.org/WAI/ARIA/apg/patterns/disclosure/examples/disclosure-navigation/) instead of a [tree view](https://www.w3.org/WAI/ARIA/apg/patterns/treeview/).

package/tree/src/tree-theme.scss

@@ -11,27 +11,53 @@
 	$white: core.daff-map-get($theme, 'core', 'white');
 	$black: core.daff-map-get($theme, 'core', 'black');
 	$neutral: core.daff-map-get($theme, 'core', 'neutral');
+	$type: core.daff-map-get($theme, 'core', 'type');
 
+	// stylelint-disable selector-class-pattern
 	.daff-tree-item {
 		$root: &;
-		background-color: $base;
-		color: theming.daff-illuminate($base-contrast, $neutral, 2);
 
-		&:hover {
-			background-color: theming.daff-illuminate($base, $neutral, 2);
-		}
+		@include theming.light($type) {
+			background-color: $base;
+			color: theming.daff-color($neutral, 90);
+
+			&:hover {
+				background-color: theming.daff-color($neutral, 20);
+			}
+
+			&::after {
+				border-color: $base;
+			}
+
+			&.selected {
+				background-color: theming.daff-color($neutral, 20);
+				color: $base-contrast;
 
-		&::after {
-			border-color: currentColor;
+				&::before {
+					background-color: theming.daff-color($primary);
+				}
+			}
 		}
 
-		// stylelint-disable selector-class-pattern
-		&.selected {
-			background-color: theming.daff-illuminate($base, $neutral, 2);
-			color: $base-contrast;
+		@include theming.dark($type) {
+			background-color: $base;
+			color: theming.daff-color($neutral, 20);
+
+			&:hover {
+				background-color: theming.daff-color($neutral, 90);
+			}
+
+			&::after {
+				border-color: $base;
+			}
+
+			&.selected {
+				background-color: theming.daff-color($neutral, 90);
+				color: $base-contrast;
 
-			&::before {
-				background-color: theming.daff-color($primary);
+				&::before {
+					background-color: theming.daff-color($primary);
+				}
 			}
 		}
 	}

package/tree/tree.d.ts

@@ -1,3 +1,6 @@
 import { DaffTreeComponent } from './tree/tree.component';
 import { DaffTreeItemDirective } from './tree-item/tree-item.directive';
+/**
+ * @docs-private
+ */
 export declare const DAFF_TREE_COMPONENTS: readonly [typeof DaffTreeComponent, typeof DaffTreeItemDirective];

package/youtube-player/index.d.ts

@@ -0,0 +1 @@
+export * from './public_api';

package/youtube-player/public_api.d.ts

@@ -0,0 +1,3 @@
+export { DaffYoutubePlayerComponent } from './youtube-player.component';
+export { DaffYoutubeSafePipe } from './safe-url.pipe';
+export { DAFF_YOUTUBE_PLAYER_COMPONENTS } from './youtube-player';

package/youtube-player/safe-url.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class DaffYoutubeSafePipe implements PipeTransform {
+    private domSanitizer;
+    constructor(domSanitizer: DomSanitizer);
+    transform(url: string): SafeUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffYoutubeSafePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DaffYoutubeSafePipe, "daffYoutubeSafe", true>;
+}