@signality/core 0.0.1-alpha.2 → 0.0.1-alpha.4

package/README.md

@@ -1,58 +1,62 @@
 # @signality/core
 
-Signal-first utility collection for Angular. Comprehensive library of reactive utilities for browser APIs, DOM elements, and common patterns.
+A collection of atomic utilities for building reactive compositions in [Angular](https://angular.dev).
+
+## Key Benefits
+
+- **Signal-first design** — built on top of Angular [Signals](https://angular.dev/guide/signals), abstracting away from RxJS
+- **Automatic cleanup** — utilities manage resource lifecycles automatically
+- **SSR-compatible** — browser APIs are guarded with safe defaults on the server
+- **Reactive inputs** — seamlessly handles static and reactive values
+- **Tree-Shakable** — only the code you use ends up in your bundle
+
+## Quick Example
+
+```ts
+import { Component, effect } from '@angular/core';
+import { storage, speechSynthesis, favicon } from '@signality/core';
+
+@Component({
+  template: `
+    <input [(ngModel)]="value" />
+    <button (click)="synthesis.speak(value())">Speak</button>
+  `,
+})
+export class Demo {
+  readonly value = storage('key', ''); // Web Storage API
+  readonly synthesis = speechSynthesis(); // Web Speech API
+  readonly fav = favicon(); // Dynamic Favicon
+
+  constructor() {
+    effect(() => {
+      if (this.synthesis.isSpeaking()) {
+        this.fav.setEmoji('🔊');
+      } else {
+        this.fav.reset();
+      }
+    });
+  }
+}
+```
+
+## Framework Compatibility
+
+| Tool        | Minimum Version |
+|-------------|-----------------|
+| **Angular** | `v20.0.0`       |
 
 ## Installation
 
 ```bash
-npm install @signality/core
+pnpm add @signality/core
 ```
 
-## Features
-
-### Browser Utilities
-- **`battery()`** — Reactive battery status and charging state
-- **`clipboard()`** — Reactive clipboard read/write operations
-- **`geolocation()`** — Reactive geolocation tracking
-- **`pageVisibility()`** — Reactive page visibility state
-- **`storage()`** — Reactive localStorage/sessionStorage with sync
-- **`network()`** — Reactive network connection status
-- **`fullscreen()`** — Reactive fullscreen API
-- And [many more...](https://signality.dev/browser/battery)
-
-### Element Utilities
-- **`elementSize()`** — Reactive element dimensions
-- **`elementVisibility()`** — Reactive Intersection Observer
-- **`dropzone()`** — Reactive drag & drop zone
-- **`windowSize()`** — Reactive window dimensions
-- **`scrollPosition()`** — Reactive scroll position
-- And [many more...](https://signality.dev/elements/active-element)
-
-### Utils
-- **`debounced()`** — Debounced writable signal
-- **`throttled()`** — Throttled writable signal
-
-## Usage
-
-```typescript
-import { battery, clipboard, elementSize, debounced } from '@signality/core';
-
-// Battery status
-const batteryStatus = battery();
-// batteryStatus.level(), batteryStatus.charging()
-
-// Clipboard operations
-const clipboard = clipboard();
-await clipboard.copy('Hello');
-const text = await clipboard.paste();
-
-// Element size tracking
-const element = viewChild<ElementRef<HTMLDivElement>>('myElement');
-const size = elementSize(element);
-// size.width(), size.height()
-
-// Debounced signal
-const searchQuery = debounced('', 300);
+Or with npm/yarn:
+
+```bash
+npm install @signality/core
+# or
+yarn add @signality/core
 ```
 
 ## Documentation

package/browser/battery/index.d.ts

@@ -2,11 +2,36 @@ import { type Signal } from '@angular/core';
 import type { WithInjector } from '@signality/core/types';
 export type BatteryOptions = WithInjector;
 export interface BatteryRef {
+    /**
+     * Whether the Battery Status API is supported in the current browser.
+     *
+     * @see [Battery Status API browser compatibility on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Battery_Status_API#browser_compatibility)
+     */
+    readonly isSupported: Signal<boolean>;
+    /**
+     * Whether the battery is currently charging.
+     *
+     * @see [BatteryManager: charging on MDN](https://developer.mozilla.org/en-US/docs/Web/API/BatteryManager/charging)
+     */
     readonly charging: Signal<boolean>;
+    /**
+     * Time in seconds until the battery is fully charged. `Infinity` if not charging.
+     *
+     * @see [BatteryManager: chargingTime on MDN](https://developer.mozilla.org/en-US/docs/Web/API/BatteryManager/chargingTime)
+     */
     readonly chargingTime: Signal<number>;
+    /**
+     * Time in seconds until the battery is fully discharged. `Infinity` if charging.
+     *
+     * @see [BatteryManager: dischargingTime on MDN](https://developer.mozilla.org/en-US/docs/Web/API/BatteryManager/dischargingTime)
+     */
     readonly dischargingTime: Signal<number>;
+    /**
+     * Battery level as a value between `0.0` and `1.0`.
+     *
+     * @see [BatteryManager: level on MDN](https://developer.mozilla.org/en-US/docs/Web/API/BatteryManager/level)
+     */
     readonly level: Signal<number>;
-    readonly isSupported: Signal<boolean>;
 }
 /**
  * Signal-based wrapper around the [Battery Status API](https://developer.mozilla.org/en-US/docs/Web/API/Battery_Status_API).
@@ -26,7 +51,7 @@ export interface BatteryRef {
  *     }
  *   `
  * })
- * class BatteryComponent {
+ * export class BatteryDemo {
  *   readonly batteryStatus = battery();
  * }
  * ```

package/browser/bluetooth/index.d.ts

@@ -2,34 +2,61 @@ import { type Signal } from '@angular/core';
 import type { WithInjector } from '@signality/core/types';
 export interface BluetoothOptions extends WithInjector {
     /**
-     * Accept any Bluetooth device.
+     * Accept any Bluetooth device without filtering.
+     *
+     * @default true
+     * @see [requestDevice: acceptAllDevices on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Bluetooth/requestDevice#acceptalldevices)
      */
     readonly acceptAllDevices?: boolean;
     /**
-     * Filters for device selection.
+     * Filters for device selection. Mutually exclusive with `acceptAllDevices`.
+     *
+     * @default undefined
+     * @see [requestDevice: filters on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Bluetooth/requestDevice#filters)
      */
     readonly filters?: BluetoothLEScanFilter[];
     /**
-     * Optional services to access.
+     * Optional GATT services to access on the connected device.
+     *
+     * @default []
+     * @see [requestDevice: optionalServices on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Bluetooth/requestDevice#optionalservices)
      */
     readonly optionalServices?: BluetoothServiceUUID[];
 }
 export interface BluetoothRef {
-    /** Whether Web Bluetooth API is supported */
+    /**
+     * Whether Web Bluetooth API is supported in the current browser.
+     *
+     * @see [Web Bluetooth API browser compatibility on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Web_Bluetooth_API#browser_compatibility)
+     */
     readonly isSupported: Signal<boolean>;
-    /** Whether a device is currently connected */
+    /**
+     * Whether a device is currently connected.
+     */
     readonly isConnected: Signal<boolean>;
-    /** Whether connection is in progress */
+    /**
+     * Whether a connection is in progress.
+     */
     readonly isConnecting: Signal<boolean>;
-    /** Connected Bluetooth device */
+    /**
+     * Connected Bluetooth device.
+     */
     readonly device: Signal<BluetoothDevice | null>;
-    /** GATT server of connected device */
+    /**
+     * GATT server of a connected device.
+     */
     readonly server: Signal<BluetoothRemoteGATTServer | null>;
-    /** Last error that occurred */
+    /**
+     * The last error that occurred.
+     */
     readonly error: Signal<Error | null>;
-    /** Request device connection */
-    readonly request: (options?: RequestDeviceOptions) => Promise<void>;
-    /** Disconnect from device */
+    /**
+     * Request device connection.
+     */
+    readonly request: () => Promise<void>;
+    /**
+     * Disconnect from a device.
+     */
     readonly disconnect: () => void;
 }
 /**
@@ -48,7 +75,7 @@ export interface BluetoothRef {
  *     }
  *   `
  * })
- * class BluetoothComponent {
+ * export class BluetoothDemo {
  *   readonly bt = bluetooth();
  * }
  * ```

package/browser/breakpoints/index.d.ts

@@ -9,24 +9,37 @@ export interface BreakpointsOptions<T extends Record<string, string>> extends Wi
 export type BreakpointsRef<T extends Record<string, string>> = {
     readonly [K in keyof T]: Signal<boolean>;
 } & {
+    /**
+     * List of currently active breakpoint keys — keys whose media query matches at the moment.
+     * Updated reactively whenever any breakpoint changes.
+     */
     readonly current: Signal<(keyof T)[]>;
 };
 /**
- * Reactive breakpoint matching using matchMedia.
- * Track responsive breakpoints with Angular signals.
+ * Reactive breakpoint matching using [matchMedia](https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia).
  *
  * @param map - Object mapping breakpoint names to media queries
  * @param options - Optional configuration
- * @returns An object with signals for each breakpoint
+ * @returns An object with signals for each breakpoint and a `current` signal with active breakpoint keys
  *
  * @example
  * ```typescript
- * const bp = breakpoints({
- *   mobile: '(max-width: 767px)',
- *   desktop: '(min-width: 768px)',
- * });
- *
- * // In template: @if (bp.mobile()) { ... }
+ * @Component({
+ *   template: `
+ *     @if (bp.mobile()) {
+ *       <p>Mobile layout</p>
+ *     } @else {
+ *       <p>Desktop layout</p>
+ *     }
+ *     <p>Active: {{ bp.current() }}</p>
+ *   `
+ * })
+ * export class Layout {
+ *   readonly bp = breakpoints({
+ *     mobile: '(max-width: 767px)',
+ *     desktop: '(min-width: 768px)',
+ *   });
+ * }
  * ```
  */
 export declare function breakpoints<T extends Record<string, string>>(map: T, options?: BreakpointsOptions<T>): BreakpointsRef<T>;

package/browser/broadcast-channel/index.d.ts

@@ -30,7 +30,7 @@ export interface BroadcastChannelRef<T> {
  *     <button (click)="sendMessage()">Send Message</button>
  *   `
  * })
- * class ChatComponent {
+ * export class ChatDemo {
  *   readonly channel = broadcastChannel<string>('my-channel');
  *
  *   sendMessage() {

package/browser/browser-language/index.d.ts

@@ -25,7 +25,7 @@ export interface BrowserLanguageOptions extends CreateSignalOptions<string>, Wit
  *     }
  *   `
  * })
- * class LanguageComponent {
+ * export class LanguageDemo {
  *   readonly language = browserLanguage();
  * }
  * ```

package/browser/clipboard/index.d.ts

@@ -8,15 +8,31 @@ export interface ClipboardOptions extends WithInjector {
     readonly copiedDuration?: MaybeSignal<number>;
 }
 export interface ClipboardRef {
-    /** Whether Clipboard API is supported */
+    /**
+     * Whether the Clipboard API is supported in the current browser.
+     *
+     * @see [Clipboard API browser compatibility on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API#browser_compatibility)
+     */
     readonly isSupported: Signal<boolean>;
-    /** Current clipboard text content */
+    /**
+     * The most recently copied or pasted text.
+     */
     readonly text: Signal<string>;
-    /** Whether content was recently copied (resets after timeout) */
+    /**
+     * Whether the text was recently copied. Resets to `false` after `copiedDuration` ms.
+     */
     readonly copied: Signal<boolean>;
-    /** Copy text to clipboard */
+    /**
+     * Write text to the clipboard.
+     *
+     * @see [Clipboard: writeText() on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/writeText)
+     */
     readonly copy: (text: string) => Promise<void>;
-    /** Read text from clipboard */
+    /**
+     * Read text from the clipboard.
+     *
+     * @see [Clipboard: readText() on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/readText)
+     */
     readonly paste: () => Promise<string>;
 }
 /**
@@ -36,7 +52,7 @@ export interface ClipboardRef {
  *     }
  *   `
  * })
- * class ClipboardComponent {
+ * export class ClipboardDemo {
  *   readonly cb = clipboard();
  *
  *   async copyText(text: string) {

package/browser/device-posture/index.d.ts

@@ -2,9 +2,17 @@ import { type Signal } from '@angular/core';
 import type { WithInjector } from '@signality/core/types';
 export type DevicePostureType = 'continuous' | 'folded';
 export interface DevicePostureRef {
-    /** Whether Device Posture API is supported */
+    /**
+     * Whether the Device Posture API is supported in the current browser.
+     *
+     * @see [Device Posture API browser compatibility on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Device_Posture_API#browser_compatibility)
+     */
     readonly isSupported: Signal<boolean>;
-    /** Current device posture */
+    /**
+     * Current posture of the device. `'continuous'` for flat screens, `'folded'` for foldable devices.
+     *
+     * @see [DevicePosture: type on MDN](https://developer.mozilla.org/en-US/docs/Web/API/DevicePosture/type)
+     */
     readonly type: Signal<DevicePostureType>;
 }
 /**
@@ -14,5 +22,18 @@ export interface DevicePostureRef {
  * @param options - Optional configuration including injector
  * @returns A DevicePostureRef with type signal
  *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (posture.isSupported()) {
+ *       <p>Device posture: {{ posture.type() }}</p>
+ *     }
+ *   `
+ * })
+ * export class PostureDemo {
+ *   readonly posture = devicePosture();
+ * }
+ * ```
  */
 export declare function devicePosture(options?: WithInjector): DevicePostureRef;

package/browser/display-media/index.d.ts

@@ -2,28 +2,52 @@ import { type Signal } from '@angular/core';
 import type { WithInjector } from '@signality/core/types';
 export interface DisplayMediaOptions extends WithInjector {
     /**
-     * Video constraints.
+     * Video track constraints for the captured stream.
+     *
      * @default true
+     * @see [MediaTrackConstraints on MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints)
      */
     readonly video?: boolean | MediaTrackConstraints;
     /**
-     * Audio constraints.
+     * Audio track constraints for the captured stream.
+     *
      * @default false
+     * @see [MediaTrackConstraints on MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints)
      */
     readonly audio?: boolean | MediaTrackConstraints;
 }
 export interface DisplayMediaRef {
-    /** Whether Screen Capture API is supported */
+    /**
+     * Whether the Screen Capture API is supported in the current browser.
+     *
+     * @see [Screen Capture API browser compatibility on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Screen_Capture_API#browser_compatibility)
+     */
     readonly isSupported: Signal<boolean>;
-    /** Whether currently capturing */
+    /**
+     * Whether screen capture is currently active.
+     */
     readonly isActive: Signal<boolean>;
-    /** Current media stream */
+    /**
+     * The active media stream, or `null` if capture is not active.
+     *
+     * @see [MediaStream on MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream)
+     */
     readonly stream: Signal<MediaStream | null>;
-    /** Last error */
+    /**
+     * The last error that occurred, or `null` if no error.
+     */
     readonly error: Signal<Error | null>;
-    /** Start screen capture */
-    readonly start: (options?: DisplayMediaOptions) => Promise<MediaStream | null>;
-    /** Stop screen capture */
+    /**
+     * Start screen capture. Opens the browser's display picker.
+     *
+     * @see [MediaDevices: getDisplayMedia() on MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia)
+     */
+    readonly start: () => Promise<MediaStream | null>;
+    /**
+     * Stop all active capture tracks and clear the stream.
+     *
+     * @see [MediaStreamTrack: stop() on MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/stop)
+     */
     readonly stop: () => void;
 }
 /**
@@ -52,7 +76,7 @@ export interface DisplayMediaRef {
  *     }
  *   `
  * })
- * class ScreenCaptureComponent {
+ * export class ScreenCaptureDemo {
  *   readonly screen = displayMedia();
  *
  *   async toggleCapture() {
@@ -64,17 +88,5 @@ export interface DisplayMediaRef {
  *   }
  * }
  * ```
- *
- * @example
- * ```typescript
- * // With custom constraints
- * const screen = displayMedia({
- *   video: {
- *     width: { ideal: 1920 },
- *     height: { ideal: 1080 },
- *   },
- *   audio: true,
- * });
- * ```
  */
 export declare function displayMedia(options?: DisplayMediaOptions): DisplayMediaRef;

package/browser/eye-dropper/index.d.ts

@@ -8,13 +8,29 @@ export interface EyeDropperOptions extends WithInjector {
     readonly initialValue?: string;
 }
 export interface EyeDropperRef {
-    /** Current selected color in sRGB hex format */
-    readonly sRGBHex: Signal<string>;
-    /** Whether EyeDropper API is supported */
+    /**
+     * Whether the EyeDropper API is supported in the current browser.
+     *
+     * @see [EyeDropper browser compatibility on MDN](https://developer.mozilla.org/en-US/docs/Web/API/EyeDropper#browser_compatibility)
+     */
     readonly isSupported: Signal<boolean>;
-    /** Open the eyedropper tool to select a color */
+    /**
+     * The most recently selected color in sRGB hex format (e.g. `#ff0000`).
+     *
+     * @see [EyeDropper: open() return value on MDN](https://developer.mozilla.org/en-US/docs/Web/API/EyeDropper/open#return_value)
+     */
+    readonly sRGBHex: Signal<string>;
+    /**
+     * Open the eyedropper tool and wait for the user to select a color.
+     *
+     * @see [EyeDropper: open() on MDN](https://developer.mozilla.org/en-US/docs/Web/API/EyeDropper/open)
+     */
     readonly open: () => Promise<void>;
-    /** Cancel the active eyedropper operation */
+    /**
+     * Cancel the active eyedropper operation via `AbortController`.
+     *
+     * @see [AbortController: abort() on MDN](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort)
+     */
     readonly close: () => void;
 }
 /**
@@ -35,7 +51,7 @@ export interface EyeDropperRef {
  *     }
  *   `
  * })
- * class ColorPickerComponent {
+ * export class ColorPicker {
  *   readonly eyeDropper = eyeDropper();
  *
  *   async pickColor() {

package/browser/favicon/index.d.ts

@@ -1,17 +1,44 @@
 import { type Signal } from '@angular/core';
 import type { WithInjector } from '@signality/core/types';
 export interface FaviconOptions extends WithInjector {
+    /**
+     * Base URL prepended to all favicon paths passed to `set()`.
+     *
+     * Resolution priority:
+     * 1. Explicit `baseUrl` value
+     * 2. [`APP_BASE_HREF`](https://angular.dev/api/common/APP_BASE_HREF) token value (if configured)
+     * 3. Empty string `''`
+     */
     readonly baseUrl?: string;
 }
 export interface FaviconRef {
+    /**
+     * URL of the currently active favicon.
+     */
     readonly current: Signal<string>;
+    /**
+     * URL of the favicon at the time the utility was initialized.
+     */
     readonly original: Signal<string>;
+    /**
+     * Set the favicon to the given URL.
+     *
+     * @see [HTMLLinkElement on MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement)
+     */
     readonly set: (url: string) => void;
+    /**
+     * Render an emoji onto a canvas and use it as the favicon.
+     *
+     * @see [Canvas API on MDN](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API)
+     */
     readonly setEmoji: (emoji: string) => void;
+    /**
+     * Reset the favicon to the original URL captured on initialization.
+     */
     readonly reset: () => void;
 }
 /**
- * Reactive favicon manipulation.
+ * Reactive favicon manipulation using the [HTMLLinkElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement).
  * Dynamically change the page favicon based on application state.
  *
  * @param options - Optional configuration
@@ -26,7 +53,7 @@ export interface FaviconRef {
  *     <p>Current: {{ fav.current() }}</p>
  *   `
  * })
- * class FaviconComponent {
+ * export class FaviconDemo {
  *   readonly fav = favicon();
  *
  *   setNotification() {

package/browser/file-dialog/index.d.ts

@@ -0,0 +1,97 @@
+import { type WritableSignal } from '@angular/core';
+import type { MaybeSignal, WithInjector } from '@signality/core/types';
+export interface FileDialogOptions extends WithInjector {
+    /**
+     * Whether to allow selecting multiple files.
+     * When changed reactively, the current file list is re-filtered.
+     * @default true
+     */
+    readonly multiple?: MaybeSignal<boolean>;
+    /**
+     * Comma-separated list of accepted file types, matching the native HTML
+     * [`accept`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/accept) attribute format.
+     * Supports MIME types (`'image/png'`), wildcards (`'image/*'`), and file extensions (`'.pdf'`).
+     * When changed reactively, the current file list is re-filtered.
+     *
+     * @default '*'
+     * @see [accept attribute on MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/accept)
+     */
+    readonly accept?: MaybeSignal<string>;
+    /**
+     * Capture source for mobile devices: `'user'` (front camera) or `'environment'` (rear camera).
+     * @see [capture attribute on MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/capture)
+     */
+    readonly capture?: MaybeSignal<string>;
+    /**
+     * Whether to select directories instead of files.
+     * Uses the non-standard `webkitdirectory` attribute.
+     * @default false
+     */
+    readonly directory?: MaybeSignal<boolean>;
+    /**
+     * Custom validation predicate called for each selected file.
+     * Return `true` to keep the file, `false` to reject it.
+     *
+     * When provided, the `accept` option is ignored — the validator
+     * takes full responsibility for deciding which files are valid.
+     *
+     * @example
+     * ```typescript
+     * fileDialog({
+     *   validator: (file) => file.size <= 5 * 1024 * 1024, // max 5 MB
+     * });
+     * ```
+     */
+    readonly validator?: (file: File) => boolean;
+    /**
+     * Callback invoked with files that were rejected during selection.
+     * Useful for showing toast notifications or validation errors.
+     *
+     * @example
+     * ```typescript
+     * fileDialog({
+     *   accept: 'image/*',
+     *   onReject: (rejected) => {
+     *     rejected.forEach(f => toast.error(`${f.name} is not valid`));
+     *   },
+     * });
+     * ```
+     */
+    readonly onReject?: (files: File[]) => void;
+}
+export interface FileDialogRef {
+    /**
+     * List of files selected via the file dialog.
+     * A `WritableSignal` — can be reset externally (e.g. `files.set([])`).
+     * Re-filtered automatically when `accept` or `multiple` options change reactively.
+     *
+     * @see [File API on MDN](https://developer.mozilla.org/en-US/docs/Web/API/File)
+     */
+    readonly files: WritableSignal<File[]>;
+    /**
+     * Open the native file picker dialog.
+     */
+    readonly open: () => void;
+}
+/**
+ * Signal-based utility for programmatically opening the native file picker dialog.
+ *
+ * @param options - Optional configuration
+ * @returns A {@link FileDialogRef} with `files` signal and `open` method
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <button (click)="fd.open()">Select Files</button>
+ *     @for (file of fd.files(); track file.name) {
+ *       <p>{{ file.name }} ({{ file.size }} bytes)</p>
+ *     }
+ *   `
+ * })
+ * export class FileUpload {
+ *   readonly fd = fileDialog({ accept: 'image/*' });
+ * }
+ * ```
+ */
+export declare function fileDialog(options?: FileDialogOptions): FileDialogRef;