@ojiepermana/angular 22.1.11 → 22.1.13

package/types/ojiepermana-angular-theme-shell-services.d.ts

@@ -1 +1,193 @@
-export * from '@ojiepermana/angular-theme/shell/services';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, EnvironmentProviders } from '@angular/core';
+import { ShellPlatform, ShellDevice, ShellWindowState, ShellMode, ShellColor, ShellFrame } from '@ojiepermana/angular/theme/shell/types';
+
+/** What the shell needs to know about the host window right now. */
+interface ShellWindowSnapshot {
+    readonly state: ShellWindowState;
+    readonly focused: boolean;
+}
+/**
+ * The seam between the shell and a desktop runtime.
+ *
+ * The theme package never imports a desktop SDK: Tauri, Electron, or anything
+ * else is reached through this interface, so an app that ships to the browser
+ * pays nothing and an app that ships to a native window provides one adapter.
+ * Commands may be sync or async — the shell always awaits them.
+ */
+interface ShellWindowBridge {
+    readonly platform: ShellPlatform;
+    /**
+     * Host OS, when the runtime can report it. `null` means "cannot tell" — the
+     * shell then falls back to its `device` input, storage, or the mode's default,
+     * rather than guessing.
+     */
+    device(): ShellDevice | null | Promise<ShellDevice | null>;
+    snapshot(): ShellWindowSnapshot | Promise<ShellWindowSnapshot>;
+    minimize(): void | Promise<void>;
+    toggleMaximize(): void | Promise<void>;
+    close(): void | Promise<void>;
+    /**
+     * Move the window with the pointer. Tauri and Electron both mark their drag
+     * surface declaratively (`data-tauri-drag-region` / `-webkit-app-region`, both
+     * stamped on the titlebar), so this is only needed by runtimes that require an
+     * explicit call.
+     */
+    startDragging?(): void | Promise<void>;
+    /** Observe window resize/move/focus changes; resolves to the unsubscribe. */
+    watch?(onChange: () => void): (() => void) | Promise<() => void>;
+}
+declare const SHELL_WINDOW_BRIDGE: InjectionToken<ShellWindowBridge>;
+/**
+ * Browser fallback used when no bridge is provided: a page has no window to
+ * drive, so it reports the web platform, no device opinion, and every command is
+ * a no-op. This is what keeps `<Shell>` renderable (and testable) outside a
+ * desktop runtime.
+ */
+declare const WEB_SHELL_WINDOW_BRIDGE: ShellWindowBridge;
+/**
+ * Register the bridge `ShellService` drives. Pass a factory to defer any runtime
+ * probing until the injector is created.
+ */
+declare function provideShellWindowBridge(bridge: ShellWindowBridge | (() => ShellWindowBridge)): EnvironmentProviders;
+
+/**
+ * The slice of a Tauri `Window` the shell drives, declared structurally so the
+ * theme package never has to depend on `@tauri-apps/api`. Any object with these
+ * methods works, which is also what makes the bridge testable with a fake.
+ */
+interface TauriWindowHandle {
+    minimize(): Promise<void>;
+    toggleMaximize(): Promise<void>;
+    close(): Promise<void>;
+    isMaximized(): Promise<boolean>;
+    isFullscreen(): Promise<boolean>;
+    startDragging(): Promise<void>;
+    isFocused?(): Promise<boolean>;
+    onResized?(handler: () => void): Promise<() => void>;
+    onFocusChanged?(handler: () => void): Promise<() => void>;
+}
+interface TauriShellBridgeOptions {
+    /**
+     * Resolve the window to drive. Defaults to the `withGlobalTauri` global
+     * (`window.__TAURI__.window.getCurrentWindow()`). Apps that keep the global
+     * off pass the module instead:
+     * `{ currentWindow: () => import('@tauri-apps/api/window').then((m) => m.getCurrentWindow()) }`.
+     */
+    readonly currentWindow?: () => TauriWindowHandle | null | Promise<TauriWindowHandle | null>;
+    /**
+     * Resolve the host OS, mapped onto the shell's `device` axis. Defaults to the
+     * `withGlobalTauri` os plugin, then the browser platform string. Apps without
+     * the global pass
+     * `{ platform: () => import('@tauri-apps/plugin-os').then((m) => m.platform()) }`.
+     */
+    readonly platform?: () => string | Promise<string>;
+}
+/** `true` when the page is running inside a Tauri webview. */
+declare function isTauriRuntime(): boolean;
+/**
+ * Adapter from a Tauri window onto {@link ShellWindowBridge}.
+ *
+ * Every call resolves the window lazily and tolerates its absence, so the same
+ * bridge can be registered unconditionally: run the app in a browser and the
+ * commands become no-ops rather than errors.
+ */
+declare function createTauriShellWindowBridge(options?: TauriShellBridgeOptions): ShellWindowBridge;
+/**
+ * Register the Tauri window bridge for `ShellService`. Safe to call in a build
+ * that also ships to the browser — outside a Tauri webview the bridge resolves
+ * no window and the shell falls back to inert commands.
+ */
+declare function provideTauriShellWindowBridge(options?: TauriShellBridgeOptions): EnvironmentProviders;
+
+interface ShellMutationOptions {
+    /** `false` keeps the change out of localStorage (a host-driven override, not a user choice). */
+    persist?: boolean;
+}
+/**
+ * State behind `<Shell>`: the persisted `mode` / `device` / `color` / `frame`
+ * axes, plus
+ * live window state read from whichever {@link ShellWindowBridge} the app
+ * registered.
+ *
+ * Every axis resolves through a fallback chain, so an app can declare as much or
+ * as little as it knows — and each is readable *and* writable through
+ * localStorage, so a target can be flipped without a rebuild:
+ *
+ * - `mode` — stored `shell-mode`, else `desktop` when a desktop runtime is
+ *   registered (a Tauri window *is* a desktop shell), else `web`.
+ * - `device` — stored `shell-device`, else whatever the bridge reports, else the
+ *   mode's default device.
+ * - `color` — stored `shell-color`, else `sync`.
+ * - `frame` — stored `shell-frame`, else `classic`.
+ *
+ * `<Shell>`'s own inputs sit in front of all of them, and `<Shell>` is also where
+ * the pairs are forced to stay coherent (device with mode, frame with mode) — the values here are preferences,
+ * so a stored `macos` survives a temporary switch to `mode='web'` instead of being
+ * erased.
+ *
+ * With no bridge registered this resolves to the inert web bridge, so the same
+ * component tree renders in a browser tab, in a unit test, and under SSR.
+ */
+declare class ShellService {
+    private readonly platformId;
+    private readonly storage;
+    private readonly destroyRef;
+    private readonly bridge;
+    /** Runtime hosting the shell; `web` whenever no bridge is registered. */
+    readonly platform: ShellPlatform;
+    /** `true` for any non-browser runtime — i.e. there is a real OS window to drive. */
+    readonly isDesktopRuntime: boolean;
+    private readonly modeState;
+    private readonly deviceState;
+    private readonly colorState;
+    private readonly frameState;
+    private readonly reportedDeviceState;
+    private readonly windowStateState;
+    private readonly focusedState;
+    readonly mode: _angular_core.Signal<"web" | "desktop" | "tablet" | "mobile">;
+    /**
+     * Preferred device: the stored choice, else what the runtime reports, else the
+     * current mode's default. Not forced to match `mode()` — see the class note.
+     */
+    readonly device: _angular_core.Signal<"browser" | "macos" | "windows" | "linux" | "ipad" | "android" | "ios">;
+    /** Where the shell's chrome takes its colors from: the design system, or the device's native look. */
+    readonly color: _angular_core.Signal<"sync" | "default">;
+    /** How the app sits in its window: flush (`classic`) or inset as a panel (`modern`). */
+    readonly frame: _angular_core.Signal<"classic" | "modern">;
+    readonly windowState: _angular_core.Signal<"normal" | "maximized" | "fullscreen">;
+    readonly focused: _angular_core.Signal<boolean>;
+    readonly isMaximized: _angular_core.Signal<boolean>;
+    readonly isFullscreen: _angular_core.Signal<boolean>;
+    constructor();
+    setMode(mode: ShellMode, options?: ShellMutationOptions): void;
+    setDevice(device: ShellDevice, options?: ShellMutationOptions): void;
+    setColor(color: ShellColor, options?: ShellMutationOptions): void;
+    setFrame(frame: ShellFrame, options?: ShellMutationOptions): void;
+    /** Adopt `mode` as the default, unless a choice is already stored. */
+    registerMode(mode: ShellMode): void;
+    /** Adopt `device` as the default, unless a choice is already stored. */
+    registerDevice(device: ShellDevice): void;
+    /** Adopt `color` as the default, unless a choice is already stored. */
+    registerColor(color: ShellColor): void;
+    /** Adopt `frame` as the default, unless a choice is already stored. */
+    registerFrame(frame: ShellFrame): void;
+    /** Re-read the device and window state from the bridge. */
+    sync(): Promise<void>;
+    minimize(): Promise<void>;
+    toggleMaximize(): Promise<void>;
+    close(): Promise<void>;
+    /** Start a pointer-driven window move, for runtimes that need an explicit call. */
+    startDragging(): Promise<void>;
+    private command;
+    private watchWindow;
+    private storedMode;
+    private storedDevice;
+    private storedColor;
+    private storedFrame;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShellService>;
+}
+
+export { SHELL_WINDOW_BRIDGE, ShellService, WEB_SHELL_WINDOW_BRIDGE, createTauriShellWindowBridge, isTauriRuntime, provideShellWindowBridge, provideTauriShellWindowBridge };
+export type { ShellWindowBridge, ShellWindowSnapshot, TauriShellBridgeOptions, TauriWindowHandle };

package/types/ojiepermana-angular-theme-shell-types.d.ts

@@ -1 +1,105 @@
-export * from '@ojiepermana/angular-theme/shell/types';
+/**
+ * Delivery target the shell is rendering for. `web` is a page in a browser tab;
+ * the rest are app targets where the shell owns the whole surface. Only
+ * `desktop` has window chrome to draw, which is what gates `<ShellBar>`.
+ *
+ * Persisted under {@link SHELL_MODE_STORAGE_KEY}.
+ */
+declare const SHELL_MODES: readonly ["web", "desktop", "tablet", "mobile"];
+/**
+ * Concrete host the shell is running on. Each mode owns a set of these (see
+ * {@link SHELL_MODE_DEVICES}) — `android` deliberately belongs to both `tablet`
+ * and `mobile`, because the same OS ships on both form factors.
+ *
+ * Persisted under {@link SHELL_DEVICE_STORAGE_KEY}.
+ */
+declare const SHELL_DEVICES: readonly ["browser", "macos", "windows", "linux", "ipad", "android", "ios"];
+/**
+ * Where the shell's own chrome takes its colors from. `sync` keeps the titlebar
+ * inside the design system, so it recolors with `theme-color` / `theme-neutral`
+ * and `data-mode` like everything else. `default` paints the native look of the
+ * active `device` instead, for an app that wants to disappear into its OS.
+ *
+ * Persisted under {@link SHELL_COLOR_STORAGE_KEY}.
+ */
+declare const SHELL_COLORS: readonly ["sync", "default"];
+/**
+ * How the app sits inside its window.
+ *
+ * `classic` is the traditional desktop frame: the app is flush to the window edge
+ * and a bordered titlebar sits on top of it.
+ *
+ * `modern` insets the app instead, so it floats as a panel inside the window with
+ * the chrome showing around it. The titlebar drops its border and takes the same
+ * colour as that surround, so the two read as one continuous frame rather than a
+ * bar stacked on a body.
+ *
+ * Only a desktop window has a frame to shape, so this is coerced to `classic` on
+ * every other mode — see {@link resolveShellFrameForMode}.
+ *
+ * Persisted under {@link SHELL_FRAME_STORAGE_KEY}.
+ */
+declare const SHELL_FRAMES: readonly ["classic", "modern"];
+/**
+ * Runtime hosting the shell — distinct from `device`, which is the OS. `web`
+ * means no bridge is registered, so there is no window to drive.
+ */
+declare const SHELL_PLATFORMS: readonly ["web", "tauri", "electron", "custom"];
+declare const SHELL_WINDOW_STATES: readonly ["normal", "maximized", "fullscreen"];
+type ShellMode = (typeof SHELL_MODES)[number];
+type ShellDevice = (typeof SHELL_DEVICES)[number];
+type ShellColor = (typeof SHELL_COLORS)[number];
+type ShellFrame = (typeof SHELL_FRAMES)[number];
+type ShellPlatform = (typeof SHELL_PLATFORMS)[number];
+type ShellWindowState = (typeof SHELL_WINDOW_STATES)[number];
+declare const SHELL_DEFAULT_MODE: ShellMode;
+declare const SHELL_DEFAULT_DEVICE: ShellDevice;
+declare const SHELL_DEFAULT_COLOR: ShellColor;
+declare const SHELL_DEFAULT_FRAME: ShellFrame;
+declare const SHELL_DEFAULT_PLATFORM: ShellPlatform;
+declare const SHELL_DEFAULT_WINDOW_STATE: ShellWindowState;
+declare const SHELL_MODE_STORAGE_KEY = "shell-mode";
+declare const SHELL_DEVICE_STORAGE_KEY = "shell-device";
+declare const SHELL_COLOR_STORAGE_KEY = "shell-color";
+declare const SHELL_FRAME_STORAGE_KEY = "shell-frame";
+/**
+ * Which devices each mode can run on. The first entry is the mode's default, used
+ * when nothing else resolves — and to correct a device that cannot belong to the
+ * active mode (`mode='desktop' device='ipad'` has no meaning).
+ */
+declare const SHELL_MODE_DEVICES: Readonly<Record<ShellMode, readonly ShellDevice[]>>;
+declare function isShellMode(value: string | null | undefined): value is ShellMode;
+declare function isShellDevice(value: string | null | undefined): value is ShellDevice;
+declare function isShellColor(value: string | null | undefined): value is ShellColor;
+declare function isShellFrame(value: string | null | undefined): value is ShellFrame;
+declare function isShellPlatform(value: string | null | undefined): value is ShellPlatform;
+declare function isShellWindowState(value: string | null | undefined): value is ShellWindowState;
+declare function normalizeShellMode(value: string | null | undefined): ShellMode;
+declare function normalizeShellColor(value: string | null | undefined): ShellColor;
+declare function normalizeShellFrame(value: string | null | undefined): ShellFrame;
+/**
+ * Resolve a frame that is coherent with `mode`. Only a desktop window has a frame
+ * to shape — the other modes have no titlebar to fuse with a surround — so
+ * `modern` collapses to `classic` there rather than insetting an app for no reason.
+ */
+declare function resolveShellFrameForMode(mode: ShellMode, frame: string | null | undefined): ShellFrame;
+/** Devices the mode can run on; the first is its default. */
+declare function shellDevicesForMode(mode: ShellMode): readonly ShellDevice[];
+declare function defaultShellDeviceForMode(mode: ShellMode): ShellDevice;
+declare function isShellDeviceForMode(mode: ShellMode, device: ShellDevice): boolean;
+/**
+ * Resolve a device that is coherent with `mode`. An unknown device, or one that
+ * belongs to a different form factor, falls back to the mode's default rather
+ * than leaving the pair in a state no styling can describe.
+ */
+declare function resolveShellDeviceForMode(mode: ShellMode, device: string | null | undefined): ShellDevice;
+/**
+ * Map a raw platform identifier onto the device axis — a Tauri `platform()`
+ * result, an Electron `process.platform`, or a `navigator.platform`/user-agent
+ * string. Order matters: iPadOS reports itself as a Mac, and Android tablets and
+ * phones share a token, so the narrower match has to win first.
+ */
+declare function normalizeShellDevice(value: string | null | undefined): ShellDevice | null;
+
+export { SHELL_COLORS, SHELL_COLOR_STORAGE_KEY, SHELL_DEFAULT_COLOR, SHELL_DEFAULT_DEVICE, SHELL_DEFAULT_FRAME, SHELL_DEFAULT_MODE, SHELL_DEFAULT_PLATFORM, SHELL_DEFAULT_WINDOW_STATE, SHELL_DEVICES, SHELL_DEVICE_STORAGE_KEY, SHELL_FRAMES, SHELL_FRAME_STORAGE_KEY, SHELL_MODES, SHELL_MODE_DEVICES, SHELL_MODE_STORAGE_KEY, SHELL_PLATFORMS, SHELL_WINDOW_STATES, defaultShellDeviceForMode, isShellColor, isShellDevice, isShellDeviceForMode, isShellFrame, isShellMode, isShellPlatform, isShellWindowState, normalizeShellColor, normalizeShellDevice, normalizeShellFrame, normalizeShellMode, resolveShellDeviceForMode, resolveShellFrameForMode, shellDevicesForMode };
+export type { ShellColor, ShellDevice, ShellFrame, ShellMode, ShellPlatform, ShellWindowState };

package/types/ojiepermana-angular-theme-shell.d.ts

@@ -1 +1,100 @@
-export * from '@ojiepermana/angular-theme/shell';
+import * as _angular_core from '@angular/core';
+import { ShellService } from '@ojiepermana/angular/theme/shell/services';
+export { SHELL_WINDOW_BRIDGE, ShellService, ShellWindowBridge, ShellWindowSnapshot, TauriShellBridgeOptions, TauriWindowHandle, WEB_SHELL_WINDOW_BRIDGE, createTauriShellWindowBridge, isTauriRuntime, provideShellWindowBridge, provideTauriShellWindowBridge } from '@ojiepermana/angular/theme/shell/services';
+export { SHELL_COLORS, SHELL_COLOR_STORAGE_KEY, SHELL_DEFAULT_COLOR, SHELL_DEFAULT_DEVICE, SHELL_DEFAULT_FRAME, SHELL_DEFAULT_MODE, SHELL_DEFAULT_PLATFORM, SHELL_DEFAULT_WINDOW_STATE, SHELL_DEVICES, SHELL_DEVICE_STORAGE_KEY, SHELL_FRAMES, SHELL_FRAME_STORAGE_KEY, SHELL_MODES, SHELL_MODE_DEVICES, SHELL_MODE_STORAGE_KEY, SHELL_PLATFORMS, SHELL_WINDOW_STATES, ShellColor, ShellDevice, ShellFrame, ShellMode, ShellPlatform, ShellWindowState, defaultShellDeviceForMode, isShellColor, isShellDevice, isShellDeviceForMode, isShellFrame, isShellMode, isShellPlatform, isShellWindowState, normalizeShellColor, normalizeShellDevice, normalizeShellFrame, normalizeShellMode, resolveShellDeviceForMode, resolveShellFrameForMode, shellDevicesForMode } from '@ojiepermana/angular/theme/shell/types';
+
+/**
+ * Root of an application shell: the element that owns the whole surface, whether
+ * that is a browser tab, an OS window, a tablet, or a phone.
+ *
+ * A `<Shell>` holds the app directly — normally a `<Layout>` — plus, on
+ * `mode='desktop'`, a titlebar it renders itself:
+ *
+ * ```html
+ * <Shell mode="desktop" device="macos">
+ *   <span shellBarTitle>Acme Studio</span>
+ *
+ *   <Layout>
+ *     <LayoutVertical>…</LayoutVertical>
+ *   </Layout>
+ * </Shell>
+ * ```
+ *
+ * ## Fallback chain
+ *
+ * Every axis is optional, and each falls back rather than demanding a value:
+ *
+ * - `mode` — this input, else the stored `shell-mode`, else `desktop` when a
+ *   desktop runtime is registered, else `web`.
+ * - `device` — this input, else the stored `shell-device`, else whatever the
+ *   window bridge reports, else the mode's default device.
+ * - `color` — this input, else the stored `shell-color`, else `sync`.
+ * - `frame` — this input, else the stored `shell-frame`, else `classic`; only
+ *   `desktop` can be `modern`.
+ *
+ * `mode` and `device` are always resolved as a coherent pair: a device that
+ * belongs to another form factor (`mode='desktop' device='ipad'`) is corrected to
+ * the mode's default, so `data-shell-device` never describes something the mode
+ * cannot be.
+ *
+ * Inputs are host declarations, not user preferences, so setting them never
+ * writes to storage — use `ShellService.setMode()` / `setDevice()` for a choice
+ * that should persist.
+ */
+declare class ShellComponent {
+    protected readonly shell: ShellService;
+    /** Delivery target. `null` follows the stored/derived mode — see the class note. */
+    readonly mode: _angular_core.InputSignal<"web" | "desktop" | "tablet" | "mobile" | null>;
+    /** Host OS. `null` follows the stored/reported device, corrected to fit `mode`. */
+    readonly device: _angular_core.InputSignal<"browser" | "macos" | "windows" | "linux" | "ipad" | "android" | "ios" | null>;
+    /**
+     * Where the shell's own chrome takes its colors from. `sync` keeps the titlebar
+     * inside the design system; `default` paints the native look of the active
+     * device.
+     */
+    readonly color: _angular_core.InputSignal<"sync" | "default" | null>;
+    /**
+     * How the app sits in its window. `classic` keeps it flush to the window edge
+     * under a bordered titlebar; `modern` insets it as a panel and fuses the titlebar
+     * with the surround into one continuous frame. Only meaningful on
+     * `mode='desktop'` — anything else resolves to `classic`.
+     */
+    readonly frame: _angular_core.InputSignal<"classic" | "modern" | null>;
+    /**
+     * `true` when the runtime still draws its own window buttons, so the shell must
+     * not draw them: on macOS the titlebar reserves the leading run for the OS
+     * traffic lights (Tauri's `titleBarStyle: 'Overlay'`), and Windows / Linux draw
+     * nothing. Leave `false` for a `decorations: false` window, where the app owns
+     * the buttons — otherwise there would be no way to close it.
+     */
+    readonly nativeWindowControls: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Mark the exposed desktop frame and titlebar as drag surfaces below interactive content. */
+    readonly drag: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Expose the titlebar as the `banner` landmark. Turn off for a nested preview. */
+    readonly landmark: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly barAriaLabel: _angular_core.InputSignal<string>;
+    readonly minimizeLabel: _angular_core.InputSignal<string>;
+    readonly maximizeLabel: _angular_core.InputSignal<string>;
+    readonly restoreLabel: _angular_core.InputSignal<string>;
+    readonly closeLabel: _angular_core.InputSignal<string>;
+    /**
+     * Automatically surface the desktop layout's primary navigation as an icon
+     * flyout in the titlebar. macOS places it at the trailing edge; Windows and
+     * Linux place it at the leading edge.
+     */
+    readonly navigationFlyout: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly navigationFlyoutIcon: _angular_core.InputSignal<string>;
+    readonly navigationFlyoutLabel: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly resolvedMode: _angular_core.Signal<"web" | "desktop" | "tablet" | "mobile">;
+    readonly resolvedDevice: _angular_core.Signal<"browser" | "macos" | "windows" | "linux" | "ipad" | "android" | "ios">;
+    readonly resolvedColor: _angular_core.Signal<"sync" | "default">;
+    readonly resolvedFrame: _angular_core.Signal<"classic" | "modern">;
+    /** Only a desktop window has chrome of its own to draw. */
+    protected readonly showsBar: _angular_core.Signal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShellComponent, "Shell", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "device": { "alias": "device"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "frame": { "alias": "frame"; "required": false; "isSignal": true; }; "nativeWindowControls": { "alias": "nativeWindowControls"; "required": false; "isSignal": true; }; "drag": { "alias": "drag"; "required": false; "isSignal": true; }; "landmark": { "alias": "landmark"; "required": false; "isSignal": true; }; "barAriaLabel": { "alias": "barAriaLabel"; "required": false; "isSignal": true; }; "minimizeLabel": { "alias": "minimizeLabel"; "required": false; "isSignal": true; }; "maximizeLabel": { "alias": "maximizeLabel"; "required": false; "isSignal": true; }; "restoreLabel": { "alias": "restoreLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "navigationFlyout": { "alias": "navigationFlyout"; "required": false; "isSignal": true; }; "navigationFlyoutIcon": { "alias": "navigationFlyoutIcon"; "required": false; "isSignal": true; }; "navigationFlyoutLabel": { "alias": "navigationFlyoutLabel"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["[shellBarStart]", "[shellBarTitle]", "[shellBarEnd]", "*"], true, never>;
+}
+
+export { ShellComponent };