@ojiepermana/angular 22.1.11 → 22.1.12

package/fesm2022/ojiepermana-angular-theme-page-slots.mjs

@@ -1,7 +1,114 @@
-export * from '@ojiepermana/angular-theme/page/slots';
+import * as i0 from '@angular/core';
+import { inject, input, computed, Component } from '@angular/core';
+import { cn } from '@ojiepermana/angular/component/utils/core';
+import { PageStateService, PAGE_DEFAULT_HEIGHT, PAGE_DEFAULT_SCROLL } from '@ojiepermana/angular/theme/page/core';
 
-// Generated by scripts/gen-umbrella-entrypoints.mjs — do not edit by hand.
+function buildPageBodyClasses(scroll, customClass) {
+    return cn('block min-w-0', scroll === 'content' && 'h-full min-h-0 overflow-auto', scroll === 'page' && 'overflow-visible', customClass);
+}
+class PageHeaderComponent {
+    page = inject(PageStateService, { optional: true });
+    class = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "class" }] : /* istanbul ignore next */ []));
+    resolvedHeight = computed(() => this.page?.height() ?? PAGE_DEFAULT_HEIGHT, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedHeight" }] : /* istanbul ignore next */ []));
+    /** Saat tombol apps mengambang di atas header, sisakan ruang kanan agar isi header tidak tertimpa. */
+    reservesAppsLauncher = computed(() => this.page?.appsLauncherReserve() ?? false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "reservesAppsLauncher" }] : /* istanbul ignore next */ []));
+    /** Lebar tombol apps (h-9 w-9 = 36px) + offset kanan (right-2 = 8px) + jarak aman; `null` = tak memesan. */
+    appsLauncherReservePadding = computed(() => this.reservesAppsLauncher() ? '3.5rem' : null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "appsLauncherReservePadding" }] : /* istanbul ignore next */ []));
+    classes = computed(() => cn('block shrink-0 border-b border-[hsl(var(--border)/var(--section-border-opacity))] bg-background', this.class(), this.resolvedHeight() === 'fix' && 'h-12 overflow-hidden'), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "classes" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.4", type: PageHeaderComponent, isStandalone: true, selector: "PageHeader", inputs: { class: { classPropertyName: "class", publicName: "class", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "data-page-slot": "header" }, properties: { "class": "classes()", "style.padding-right": "appsLauncherReservePadding()" } }, ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'PageHeader',
+                    host: {
+                        '[class]': 'classes()',
+                        // Inline style menang atas utility responsif konsumen (mis. `md:px-6`), jadi ruang
+                        // untuk tombol apps yang mengambang tetap terjamin di semua breakpoint.
+                        '[style.padding-right]': 'appsLauncherReservePadding()',
+                        'data-page-slot': 'header',
+                    },
+                    template: `<ng-content />`,
+                }]
+        }], propDecorators: { class: [{ type: i0.Input, args: [{ isSignal: true, alias: "class", required: false }] }] } });
+class PageContentComponent {
+    page = inject(PageStateService, { optional: true });
+    class = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "class" }] : /* istanbul ignore next */ []));
+    resolvedScroll = computed(() => this.page?.scroll() ?? PAGE_DEFAULT_SCROLL, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedScroll" }] : /* istanbul ignore next */ []));
+    classes = computed(() => buildPageBodyClasses(this.resolvedScroll(), this.class()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "classes" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.4", type: PageContentComponent, isStandalone: true, selector: "PageContent", inputs: { class: { classPropertyName: "class", publicName: "class", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "data-page-slot": "content" }, properties: { "class": "classes()", "attr.tabindex": "resolvedScroll() === \"content\" ? \"0\" : null" } }, ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageContentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'PageContent',
+                    host: {
+                        '[class]': 'classes()',
+                        // When this region scrolls its own content, make it keyboard-focusable so it
+                        // can be scrolled without a mouse (axe scrollable-region-focusable).
+                        '[attr.tabindex]': 'resolvedScroll() === "content" ? "0" : null',
+                        'data-page-slot': 'content',
+                    },
+                    template: `<ng-content />`,
+                }]
+        }], propDecorators: { class: [{ type: i0.Input, args: [{ isSignal: true, alias: "class", required: false }] }] } });
+class PageDashboardComponent {
+    page = inject(PageStateService, { optional: true });
+    class = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "class" }] : /* istanbul ignore next */ []));
+    resolvedScroll = computed(() => this.page?.scroll() ?? PAGE_DEFAULT_SCROLL, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedScroll" }] : /* istanbul ignore next */ []));
+    classes = computed(() => buildPageBodyClasses(this.resolvedScroll(), this.class()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "classes" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageDashboardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.4", type: PageDashboardComponent, isStandalone: true, selector: "PageDashboard", inputs: { class: { classPropertyName: "class", publicName: "class", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "data-page-slot": "dashboard" }, properties: { "class": "classes()" } }, ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageDashboardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'PageDashboard',
+                    host: {
+                        '[class]': 'classes()',
+                        'data-page-slot': 'dashboard',
+                    },
+                    template: `<ng-content />`,
+                }]
+        }], propDecorators: { class: [{ type: i0.Input, args: [{ isSignal: true, alias: "class", required: false }] }] } });
+class PageFooterComponent {
+    page = inject(PageStateService, { optional: true });
+    class = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "class" }] : /* istanbul ignore next */ []));
+    resolvedHeight = computed(() => this.page?.height() ?? PAGE_DEFAULT_HEIGHT, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedHeight" }] : /* istanbul ignore next */ []));
+    classes = computed(() => cn('block shrink-0 border-t border-[hsl(var(--border)/var(--section-border-opacity))] bg-background', this.class(), this.resolvedHeight() === 'fix' && 'h-12 overflow-hidden'), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "classes" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageFooterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.4", type: PageFooterComponent, isStandalone: true, selector: "PageFooter", inputs: { class: { classPropertyName: "class", publicName: "class", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "data-page-slot": "footer" }, properties: { "class": "classes()" } }, ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: PageFooterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'PageFooter',
+                    host: {
+                        '[class]': 'classes()',
+                        'data-page-slot': 'footer',
+                    },
+                    template: `<ng-content />`,
+                }]
+        }], propDecorators: { class: [{ type: i0.Input, args: [{ isSignal: true, alias: "class", required: false }] }] } });
 
 /**
  * Generated bundle index. Do not edit.
- */
+ */
+
+export { PageContentComponent, PageDashboardComponent, PageFooterComponent, PageHeaderComponent };

package/fesm2022/ojiepermana-angular-theme-page.mjs

@@ -1,6 +1,11 @@
-export * from '@ojiepermana/angular-theme/page';
+export { PAGE_APPEARANCES, PAGE_DEFAULT_APPEARANCE, PAGE_DEFAULT_FILTER_MODE, PAGE_DEFAULT_FILTER_PLACEMENT, PAGE_DEFAULT_FILTER_POSITION, PAGE_DEFAULT_FILTER_WIDTH, PAGE_DEFAULT_HEIGHT, PAGE_DEFAULT_SCROLL, PAGE_DEFAULT_SIDE_MODE, PAGE_DEFAULT_SIDE_POSITION, PAGE_DEFAULT_SIDE_WIDTH, PAGE_DEFAULT_VARIANT, PAGE_FILTER_PLACEMENTS, PAGE_HEIGHT_VALUES, PAGE_SCROLL_VALUES, PAGE_SIDE_MODES, PAGE_SIDE_POSITIONS, PAGE_VARIANTS, isUiPageAppearance, isUiPageFilterPlacement, isUiPageHeight, isUiPageScroll, isUiPageSideMode, isUiPageSidePosition, isUiPageVariant } from '@ojiepermana/angular/theme/page/core';
+export { PageFilterComponent, PageFilterToggleComponent } from '@ojiepermana/angular/theme/page/filter';
+export { PageComponent } from '@ojiepermana/angular/theme/page/root';
+export { PageSideComponent, PageSideToggleComponent } from '@ojiepermana/angular/theme/page/side';
+export { PageContentComponent, PageDashboardComponent, PageFooterComponent, PageHeaderComponent } from '@ojiepermana/angular/theme/page/slots';
 
-// Generated by scripts/gen-umbrella-entrypoints.mjs — do not edit by hand.
+// Explicit named forwarding keeps the compatibility barrel inspectable by declaration/API tools
+// while each implementation remains owned by its focused secondary entry point.
 
 /**
  * Generated bundle index. Do not edit.

package/fesm2022/ojiepermana-angular-theme-shell-services.mjs

@@ -1,7 +1,342 @@
-export * from '@ojiepermana/angular-theme/shell/services';
+import * as i0 from '@angular/core';
+import { InjectionToken, makeEnvironmentProviders, inject, PLATFORM_ID, DestroyRef, signal, computed, Service } from '@angular/core';
+import { SHELL_DEFAULT_WINDOW_STATE, normalizeShellDevice, defaultShellDeviceForMode, SHELL_MODE_STORAGE_KEY, SHELL_DEVICE_STORAGE_KEY, SHELL_COLOR_STORAGE_KEY, SHELL_FRAME_STORAGE_KEY, isShellMode, isShellDevice, isShellColor, isShellFrame, SHELL_DEFAULT_MODE, SHELL_DEFAULT_COLOR, SHELL_DEFAULT_FRAME } from '@ojiepermana/angular/theme/shell/types';
+import { isPlatformBrowser } from '@angular/common';
+import { globalLocalStorage } from '@ojiepermana/angular/component/utils/core';
 
-// Generated by scripts/gen-umbrella-entrypoints.mjs — do not edit by hand.
+const SHELL_WINDOW_BRIDGE = new InjectionToken('SHELL_WINDOW_BRIDGE');
+/**
+ * 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.
+ */
+const WEB_SHELL_WINDOW_BRIDGE = {
+    platform: 'web',
+    device: () => null,
+    snapshot: () => ({ state: SHELL_DEFAULT_WINDOW_STATE, focused: true }),
+    minimize: () => undefined,
+    toggleMaximize: () => undefined,
+    close: () => undefined,
+};
+/**
+ * Register the bridge `ShellService` drives. Pass a factory to defer any runtime
+ * probing until the injector is created.
+ */
+function provideShellWindowBridge(bridge) {
+    return makeEnvironmentProviders([
+        typeof bridge === 'function'
+            ? { provide: SHELL_WINDOW_BRIDGE, useFactory: bridge }
+            : { provide: SHELL_WINDOW_BRIDGE, useValue: bridge },
+    ]);
+}
+
+/** `true` when the page is running inside a Tauri webview. */
+function isTauriRuntime() {
+    const scope = globalThis;
+    return scope.__TAURI__ !== undefined || scope.__TAURI_INTERNALS__ !== undefined;
+}
+/**
+ * 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.
+ */
+function createTauriShellWindowBridge(options = {}) {
+    const resolveWindow = options.currentWindow ?? defaultCurrentWindow;
+    const resolvePlatform = options.platform ?? defaultPlatform;
+    const withWindow = async (command) => {
+        const handle = await resolveWindow();
+        if (handle) {
+            await command(handle);
+        }
+    };
+    return {
+        platform: 'tauri',
+        async device() {
+            try {
+                return normalizeShellDevice(await resolvePlatform());
+            }
+            catch {
+                return null;
+            }
+        },
+        async snapshot() {
+            const handle = await resolveWindow();
+            if (!handle) {
+                return { state: 'normal', focused: true };
+            }
+            // Fullscreen wins: a fullscreen window also reports itself maximized on
+            // some platforms, and the shell chrome differs for the two.
+            const [fullscreen, maximized, focused] = await Promise.all([
+                handle.isFullscreen(),
+                handle.isMaximized(),
+                handle.isFocused?.() ?? Promise.resolve(true),
+            ]);
+            return {
+                state: fullscreen ? 'fullscreen' : maximized ? 'maximized' : 'normal',
+                focused,
+            };
+        },
+        minimize: () => withWindow((handle) => handle.minimize()),
+        toggleMaximize: () => withWindow((handle) => handle.toggleMaximize()),
+        close: () => withWindow((handle) => handle.close()),
+        startDragging: () => withWindow((handle) => handle.startDragging()),
+        async watch(onChange) {
+            const handle = await resolveWindow();
+            if (!handle) {
+                return () => undefined;
+            }
+            const unsubscribes = await Promise.all([
+                handle.onResized?.(onChange) ?? Promise.resolve(undefined),
+                handle.onFocusChanged?.(onChange) ?? Promise.resolve(undefined),
+            ]);
+            return () => {
+                for (const unsubscribe of unsubscribes) {
+                    unsubscribe?.();
+                }
+            };
+        },
+    };
+}
+/**
+ * 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.
+ */
+function provideTauriShellWindowBridge(options = {}) {
+    return provideShellWindowBridge(() => createTauriShellWindowBridge(options));
+}
+function tauriGlobal() {
+    return globalThis.__TAURI__ ?? null;
+}
+function defaultCurrentWindow() {
+    return tauriGlobal()?.window?.getCurrentWindow?.() ?? null;
+}
+function defaultPlatform() {
+    const fromPlugin = tauriGlobal()?.os?.platform?.();
+    if (fromPlugin !== undefined) {
+        return fromPlugin;
+    }
+    const navigatorRef = globalThis
+        .navigator;
+    return navigatorRef?.userAgent ?? navigatorRef?.platform ?? '';
+}
+
+/**
+ * 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.
+ */
+class ShellService {
+    platformId = inject(PLATFORM_ID);
+    storage = globalLocalStorage(isPlatformBrowser(this.platformId));
+    destroyRef = inject(DestroyRef);
+    bridge = inject(SHELL_WINDOW_BRIDGE, { optional: true }) ?? WEB_SHELL_WINDOW_BRIDGE;
+    /** Runtime hosting the shell; `web` whenever no bridge is registered. */
+    platform = this.bridge.platform;
+    /** `true` for any non-browser runtime — i.e. there is a real OS window to drive. */
+    isDesktopRuntime = this.bridge.platform !== 'web';
+    modeState = signal(this.storedMode(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "modeState" }] : /* istanbul ignore next */ []));
+    deviceState = signal(this.storedDevice(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "deviceState" }] : /* istanbul ignore next */ []));
+    colorState = signal(this.storedColor(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "colorState" }] : /* istanbul ignore next */ []));
+    frameState = signal(this.storedFrame(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "frameState" }] : /* istanbul ignore next */ []));
+    reportedDeviceState = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "reportedDeviceState" }] : /* istanbul ignore next */ []));
+    windowStateState = signal(SHELL_DEFAULT_WINDOW_STATE, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "windowStateState" }] : /* istanbul ignore next */ []));
+    focusedState = signal(true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "focusedState" }] : /* istanbul ignore next */ []));
+    mode = this.modeState.asReadonly();
+    /**
+     * 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.
+     */
+    device = computed(() => this.deviceState() ??
+        this.reportedDeviceState() ??
+        defaultShellDeviceForMode(this.modeState()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "device" }] : /* istanbul ignore next */ []));
+    /** Where the shell's chrome takes its colors from: the design system, or the device's native look. */
+    color = this.colorState.asReadonly();
+    /** How the app sits in its window: flush (`classic`) or inset as a panel (`modern`). */
+    frame = this.frameState.asReadonly();
+    windowState = this.windowStateState.asReadonly();
+    focused = this.focusedState.asReadonly();
+    isMaximized = computed(() => this.windowStateState() === 'maximized', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isMaximized" }] : /* istanbul ignore next */ []));
+    isFullscreen = computed(() => this.windowStateState() === 'fullscreen', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isFullscreen" }] : /* istanbul ignore next */ []));
+    constructor() {
+        // Nothing to probe on the server, and the bridge would have no window yet.
+        if (!isPlatformBrowser(this.platformId)) {
+            return;
+        }
+        void this.sync();
+        void this.watchWindow();
+    }
+    setMode(mode, options = {}) {
+        this.modeState.set(mode);
+        if (options.persist !== false) {
+            this.storage.write(SHELL_MODE_STORAGE_KEY, mode);
+        }
+    }
+    setDevice(device, options = {}) {
+        this.deviceState.set(device);
+        if (options.persist !== false) {
+            this.storage.write(SHELL_DEVICE_STORAGE_KEY, device);
+        }
+    }
+    setColor(color, options = {}) {
+        this.colorState.set(color);
+        if (options.persist !== false) {
+            this.storage.write(SHELL_COLOR_STORAGE_KEY, color);
+        }
+    }
+    setFrame(frame, options = {}) {
+        this.frameState.set(frame);
+        if (options.persist !== false) {
+            this.storage.write(SHELL_FRAME_STORAGE_KEY, frame);
+        }
+    }
+    /** Adopt `mode` as the default, unless a choice is already stored. */
+    registerMode(mode) {
+        if (!isShellMode(this.storage.read(SHELL_MODE_STORAGE_KEY))) {
+            this.setMode(mode, { persist: false });
+        }
+    }
+    /** Adopt `device` as the default, unless a choice is already stored. */
+    registerDevice(device) {
+        if (!isShellDevice(this.storage.read(SHELL_DEVICE_STORAGE_KEY))) {
+            this.setDevice(device, { persist: false });
+        }
+    }
+    /** Adopt `color` as the default, unless a choice is already stored. */
+    registerColor(color) {
+        if (!isShellColor(this.storage.read(SHELL_COLOR_STORAGE_KEY))) {
+            this.setColor(color, { persist: false });
+        }
+    }
+    /** Adopt `frame` as the default, unless a choice is already stored. */
+    registerFrame(frame) {
+        if (!isShellFrame(this.storage.read(SHELL_FRAME_STORAGE_KEY))) {
+            this.setFrame(frame, { persist: false });
+        }
+    }
+    /** Re-read the device and window state from the bridge. */
+    async sync() {
+        try {
+            const [device, snapshot] = await Promise.all([this.bridge.device(), this.bridge.snapshot()]);
+            this.reportedDeviceState.set(device);
+            this.windowStateState.set(snapshot.state);
+            this.focusedState.set(snapshot.focused);
+        }
+        catch {
+            // A runtime can vanish mid-session (a window closing tears down its IPC).
+            // Keep the last known state rather than failing the render.
+        }
+    }
+    async minimize() {
+        await this.command(() => this.bridge.minimize());
+    }
+    async toggleMaximize() {
+        await this.command(() => this.bridge.toggleMaximize());
+    }
+    async close() {
+        // No resync: the window is going away, and the bridge's IPC with it.
+        await this.command(() => this.bridge.close(), { resync: false });
+    }
+    /** Start a pointer-driven window move, for runtimes that need an explicit call. */
+    async startDragging() {
+        await this.command(() => this.bridge.startDragging?.(), { resync: false });
+    }
+    async command(run, options = {}) {
+        try {
+            await run();
+        }
+        catch {
+            return;
+        }
+        if (options.resync !== false) {
+            await this.sync();
+        }
+    }
+    async watchWindow() {
+        const watch = this.bridge.watch;
+        if (!watch) {
+            return;
+        }
+        let unsubscribe;
+        let destroyed = false;
+        this.destroyRef.onDestroy(() => {
+            destroyed = true;
+            unsubscribe?.();
+        });
+        try {
+            unsubscribe = await watch.call(this.bridge, () => void this.sync());
+        }
+        catch {
+            return;
+        }
+        // The service may have been torn down while the subscription was in flight.
+        if (destroyed) {
+            unsubscribe();
+        }
+    }
+    storedMode() {
+        const stored = this.storage.read(SHELL_MODE_STORAGE_KEY);
+        if (isShellMode(stored)) {
+            return stored;
+        }
+        // A registered desktop runtime is itself the declaration: a Tauri or Electron
+        // window is a desktop shell whether or not the app spelled it out.
+        return this.isDesktopRuntime ? 'desktop' : SHELL_DEFAULT_MODE;
+    }
+    storedDevice() {
+        const stored = this.storage.read(SHELL_DEVICE_STORAGE_KEY);
+        return isShellDevice(stored) ? stored : null;
+    }
+    storedColor() {
+        const stored = this.storage.read(SHELL_COLOR_STORAGE_KEY);
+        return isShellColor(stored) ? stored : SHELL_DEFAULT_COLOR;
+    }
+    storedFrame() {
+        const stored = this.storage.read(SHELL_FRAME_STORAGE_KEY);
+        return isShellFrame(stored) ? stored : SHELL_DEFAULT_FRAME;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: ShellService, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.4", ngImport: i0, type: ShellService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: ShellService, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
 
 /**
  * Generated bundle index. Do not edit.
- */
+ */
+
+export { SHELL_WINDOW_BRIDGE, ShellService, WEB_SHELL_WINDOW_BRIDGE, createTauriShellWindowBridge, isTauriRuntime, provideShellWindowBridge, provideTauriShellWindowBridge };

package/fesm2022/ojiepermana-angular-theme-shell-types.mjs

@@ -1,7 +1,163 @@
-export * from '@ojiepermana/angular-theme/shell/types';
-
-// Generated by scripts/gen-umbrella-entrypoints.mjs — do not edit by hand.
+/**
+ * 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}.
+ */
+const SHELL_MODES = ['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}.
+ */
+const SHELL_DEVICES = [
+    '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}.
+ */
+const SHELL_COLORS = ['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}.
+ */
+const SHELL_FRAMES = ['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.
+ */
+const SHELL_PLATFORMS = ['web', 'tauri', 'electron', 'custom'];
+const SHELL_WINDOW_STATES = ['normal', 'maximized', 'fullscreen'];
+const SHELL_DEFAULT_MODE = 'web';
+const SHELL_DEFAULT_DEVICE = 'browser';
+const SHELL_DEFAULT_COLOR = 'sync';
+const SHELL_DEFAULT_FRAME = 'classic';
+const SHELL_DEFAULT_PLATFORM = 'web';
+const SHELL_DEFAULT_WINDOW_STATE = 'normal';
+const SHELL_MODE_STORAGE_KEY = 'shell-mode';
+const SHELL_DEVICE_STORAGE_KEY = 'shell-device';
+const SHELL_COLOR_STORAGE_KEY = 'shell-color';
+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).
+ */
+const SHELL_MODE_DEVICES = {
+    web: ['browser'],
+    desktop: ['macos', 'windows', 'linux'],
+    tablet: ['ipad', 'android'],
+    mobile: ['ios', 'android'],
+};
+function isShellMode(value) {
+    return typeof value === 'string' && SHELL_MODES.includes(value);
+}
+function isShellDevice(value) {
+    return typeof value === 'string' && SHELL_DEVICES.includes(value);
+}
+function isShellColor(value) {
+    return typeof value === 'string' && SHELL_COLORS.includes(value);
+}
+function isShellFrame(value) {
+    return typeof value === 'string' && SHELL_FRAMES.includes(value);
+}
+function isShellPlatform(value) {
+    return typeof value === 'string' && SHELL_PLATFORMS.includes(value);
+}
+function isShellWindowState(value) {
+    return typeof value === 'string' && SHELL_WINDOW_STATES.includes(value);
+}
+function normalizeShellMode(value) {
+    return isShellMode(value) ? value : SHELL_DEFAULT_MODE;
+}
+function normalizeShellColor(value) {
+    return isShellColor(value) ? value : SHELL_DEFAULT_COLOR;
+}
+function normalizeShellFrame(value) {
+    return isShellFrame(value) ? value : SHELL_DEFAULT_FRAME;
+}
+/**
+ * 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.
+ */
+function resolveShellFrameForMode(mode, frame) {
+    return mode === 'desktop' ? normalizeShellFrame(frame) : SHELL_DEFAULT_FRAME;
+}
+/** Devices the mode can run on; the first is its default. */
+function shellDevicesForMode(mode) {
+    return SHELL_MODE_DEVICES[mode];
+}
+function defaultShellDeviceForMode(mode) {
+    return SHELL_MODE_DEVICES[mode][0];
+}
+function isShellDeviceForMode(mode, device) {
+    return SHELL_MODE_DEVICES[mode].includes(device);
+}
+/**
+ * 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.
+ */
+function resolveShellDeviceForMode(mode, device) {
+    return isShellDevice(device) && isShellDeviceForMode(mode, device)
+        ? device
+        : defaultShellDeviceForMode(mode);
+}
+/**
+ * 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.
+ */
+function normalizeShellDevice(value) {
+    if (!value) {
+        return null;
+    }
+    const token = value.toLowerCase();
+    if (token.includes('ipad'))
+        return 'ipad';
+    if (token.includes('iphone') || token.includes('ipod') || token === 'ios')
+        return 'ios';
+    if (token.includes('android'))
+        return 'android';
+    if (token.includes('mac') || token === 'darwin')
+        return 'macos';
+    if (token.includes('win'))
+        return 'windows';
+    if (token.includes('linux') || token.includes('x11'))
+        return 'linux';
+    return null;
+}
 
 /**
  * Generated bundle index. Do not edit.
- */
+ */
+
+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 };