@hamak/ui-shell-impl 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1 @@
+$ tsc -p tsconfig.json

package/dist/core/DefaultFeatureManager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Default Feature Manager Implementation
+ */
+import type { IFeatureManager } from '@amk/ui-shell-api';
+import type { FeatureFlags } from '@amk/ui-shell-api';
+export declare class DefaultFeatureManager implements IFeatureManager {
+    private features;
+    private listeners;
+    constructor(initialFeatures?: FeatureFlags);
+    isEnabled(key: string): boolean;
+    get<T = any>(key: string, defaultValue?: T): T;
+    set(key: string, value: any): void;
+    enable(key: string): void;
+    disable(key: string): void;
+    toggle(key: string): void;
+    update(updates: FeatureFlags): void;
+    getAll(): Readonly<FeatureFlags>;
+    has(key: string): boolean;
+    subscribe(key: string, listener: (value: any) => void): () => void;
+    subscribeAll(listener: (key: string, value: any) => void): () => void;
+    destroy(): void;
+    private notifyListeners;
+}
+//# sourceMappingURL=DefaultFeatureManager.d.ts.map

package/dist/core/DefaultFeatureManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultFeatureManager.d.ts","sourceRoot":"","sources":["../../src/core/DefaultFeatureManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,qBAAa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,SAAS,CAAqD;gBAE1D,eAAe,GAAE,YAAiB;IAI9C,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAK/B,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC;IAK9C,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAQlC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI1B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAMnC,MAAM,IAAI,QAAQ,CAAC,YAAY,CAAC;IAIhC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,GAAG,MAAM,IAAI;IAiBlE,YAAY,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,GAAG,MAAM,IAAI;IAcrE,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,eAAe;CAMxB"}

package/dist/core/DefaultFeatureManager.js

@@ -0,0 +1,80 @@
+/**
+ * Default Feature Manager Implementation
+ */
+export class DefaultFeatureManager {
+    features;
+    listeners = new Map();
+    constructor(initialFeatures = {}) {
+        this.features = { ...initialFeatures };
+    }
+    isEnabled(key) {
+        const value = this.features[key];
+        return typeof value === 'boolean' ? value : Boolean(value);
+    }
+    get(key, defaultValue) {
+        const value = this.features[key];
+        return (value !== undefined ? value : defaultValue);
+    }
+    set(key, value) {
+        const oldValue = this.features[key];
+        if (oldValue === value)
+            return;
+        this.features[key] = value;
+        this.notifyListeners(key, value);
+    }
+    enable(key) {
+        this.set(key, true);
+    }
+    disable(key) {
+        this.set(key, false);
+    }
+    toggle(key) {
+        this.set(key, !this.isEnabled(key));
+    }
+    update(updates) {
+        Object.entries(updates).forEach(([key, value]) => {
+            this.set(key, value);
+        });
+    }
+    getAll() {
+        return { ...this.features };
+    }
+    has(key) {
+        return key in this.features;
+    }
+    subscribe(key, listener) {
+        if (!this.listeners.has(key)) {
+            this.listeners.set(key, new Set());
+        }
+        this.listeners.get(key).add(listener);
+        return () => {
+            const listeners = this.listeners.get(key);
+            if (listeners) {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.listeners.delete(key);
+                }
+            }
+        };
+    }
+    subscribeAll(listener) {
+        const unsubscribers = [];
+        const currentKeys = Object.keys(this.features);
+        currentKeys.forEach(key => {
+            const unsub = this.subscribe(key, value => listener(key, value));
+            unsubscribers.push(unsub);
+        });
+        return () => {
+            unsubscribers.forEach(unsub => unsub());
+        };
+    }
+    destroy() {
+        this.listeners.clear();
+    }
+    notifyListeners(key, value) {
+        const listeners = this.listeners.get(key);
+        if (listeners) {
+            listeners.forEach(listener => listener(value));
+        }
+    }
+}

package/dist/core/DefaultLayoutManager.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Default Layout Manager Implementation
+ */
+import type { ILayoutManager } from '@amk/ui-shell-api';
+import type { LayoutSlot, LayoutArea } from '@amk/ui-shell-api';
+export declare class DefaultLayoutManager implements ILayoutManager {
+    private slots;
+    private listeners;
+    registerSlot(slot: LayoutSlot): () => void;
+    unregisterSlot(slot: LayoutSlot): void;
+    getSlots(area: LayoutArea): LayoutSlot[];
+    getAreas(): LayoutArea[];
+    hasSlots(area: LayoutArea): boolean;
+    subscribe(listener: () => void): () => void;
+    clear(): void;
+    destroy(): void;
+    private notifyListeners;
+}
+//# sourceMappingURL=DefaultLayoutManager.d.ts.map

package/dist/core/DefaultLayoutManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultLayoutManager.d.ts","sourceRoot":"","sources":["../../src/core/DefaultLayoutManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEhE,qBAAa,oBAAqB,YAAW,cAAc;IACzD,OAAO,CAAC,KAAK,CAA2C;IACxD,OAAO,CAAC,SAAS,CAA8B;IAE/C,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,IAAI;IAY1C,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAYtC,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE;IAWxC,QAAQ,IAAI,UAAU,EAAE;IAIxB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAKnC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAK3C,KAAK,IAAI,IAAI;IAKb,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,eAAe;CAGxB"}

package/dist/core/DefaultLayoutManager.js

@@ -0,0 +1,59 @@
+/**
+ * Default Layout Manager Implementation
+ */
+export class DefaultLayoutManager {
+    slots = new Map();
+    listeners = new Set();
+    registerSlot(slot) {
+        const area = slot.area;
+        if (!this.slots.has(area)) {
+            this.slots.set(area, new Set());
+        }
+        this.slots.get(area).add(slot);
+        this.notifyListeners();
+        return () => this.unregisterSlot(slot);
+    }
+    unregisterSlot(slot) {
+        const area = slot.area;
+        const slots = this.slots.get(area);
+        if (slots) {
+            slots.delete(slot);
+            if (slots.size === 0) {
+                this.slots.delete(area);
+            }
+            this.notifyListeners();
+        }
+    }
+    getSlots(area) {
+        const slots = this.slots.get(area);
+        if (!slots)
+            return [];
+        return Array.from(slots).sort((a, b) => {
+            const priorityA = a.priority || 0;
+            const priorityB = b.priority || 0;
+            return priorityB - priorityA; // Higher priority first
+        });
+    }
+    getAreas() {
+        return Array.from(this.slots.keys());
+    }
+    hasSlots(area) {
+        const slots = this.slots.get(area);
+        return Boolean(slots && slots.size > 0);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    clear() {
+        this.slots.clear();
+        this.notifyListeners();
+    }
+    destroy() {
+        this.slots.clear();
+        this.listeners.clear();
+    }
+    notifyListeners() {
+        this.listeners.forEach(listener => listener());
+    }
+}

package/dist/core/DefaultRouter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Default Router Implementation
+ */
+import type { IRouter } from '@amk/ui-shell-api';
+import type { RouteConfig, RouterOptions } from '@amk/ui-shell-api';
+import type { IRouterStrategy } from '@amk/ui-shell-spi';
+import type { NavigationGuard } from '@amk/ui-shell-spi';
+export declare class DefaultRouter implements IRouter {
+    private routes;
+    private currentRoute;
+    private guards;
+    private listeners;
+    private strategy;
+    constructor(options: RouterOptions, strategy: IRouterStrategy);
+    private registerRoutes;
+    push(path: string): Promise<boolean>;
+    replace(path: string): Promise<boolean>;
+    back(): void;
+    forward(): void;
+    getCurrentRoute(): RouteConfig | null;
+    subscribe(listener: (route: RouteConfig) => void): () => void;
+    loadRouteComponent(route: RouteConfig): Promise<any>;
+    addGuard(guard: NavigationGuard): () => void;
+    destroy(): void;
+    private matchRoute;
+    private runGuards;
+    private setupNavigationListener;
+    private notifyListeners;
+}
+//# sourceMappingURL=DefaultRouter.d.ts.map

package/dist/core/DefaultRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultRouter.d.ts","sourceRoot":"","sources":["../../src/core/DefaultRouter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,qBAAa,aAAc,YAAW,OAAO;IAC3C,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,SAAS,CAAgD;IACjE,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe;IAO7D,OAAO,CAAC,cAAc;IAShB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBpC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB7C,IAAI,IAAI,IAAI;IAIZ,OAAO,IAAI,IAAI;IAIf,eAAe,IAAI,WAAW,GAAG,IAAI;IAIrC,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,MAAM,IAAI;IAKvD,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;IAU1D,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,IAAI;IAU5C,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,UAAU;YAIJ,SAAS;IAQvB,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,eAAe;CAGxB"}

package/dist/core/DefaultRouter.js

@@ -0,0 +1,111 @@
+/**
+ * Default Router Implementation
+ */
+export class DefaultRouter {
+    routes = new Map();
+    currentRoute = null;
+    guards = [];
+    listeners = new Set();
+    strategy;
+    constructor(options, strategy) {
+        this.strategy = strategy;
+        this.guards = [];
+        this.registerRoutes(options.routes);
+        this.setupNavigationListener();
+    }
+    registerRoutes(routes) {
+        routes.forEach(route => {
+            this.routes.set(route.path, route);
+            if (route.children) {
+                this.registerRoutes(route.children);
+            }
+        });
+    }
+    async push(path) {
+        const route = this.matchRoute(path);
+        if (!route) {
+            console.error(`Route not found: ${path}`);
+            return false;
+        }
+        if (!(await this.runGuards(route))) {
+            return false;
+        }
+        if (route.beforeEnter && !(await route.beforeEnter(route, this.currentRoute))) {
+            return false;
+        }
+        this.currentRoute = route;
+        this.strategy.push(path);
+        this.notifyListeners(route);
+        return true;
+    }
+    async replace(path) {
+        const route = this.matchRoute(path);
+        if (!route) {
+            console.error(`Route not found: ${path}`);
+            return false;
+        }
+        if (!(await this.runGuards(route))) {
+            return false;
+        }
+        this.currentRoute = route;
+        this.strategy.replace(path);
+        this.notifyListeners(route);
+        return true;
+    }
+    back() {
+        this.strategy.back();
+    }
+    forward() {
+        this.strategy.forward();
+    }
+    getCurrentRoute() {
+        return this.currentRoute;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async loadRouteComponent(route) {
+        try {
+            const component = await route.component();
+            return component;
+        }
+        catch (error) {
+            console.error(`Failed to load route component for ${route.path}:`, error);
+            throw error;
+        }
+    }
+    addGuard(guard) {
+        this.guards.push(guard);
+        return () => {
+            const index = this.guards.indexOf(guard);
+            if (index > -1) {
+                this.guards.splice(index, 1);
+            }
+        };
+    }
+    destroy() {
+        this.strategy.destroy();
+        this.listeners.clear();
+        this.guards = [];
+    }
+    matchRoute(path) {
+        return this.routes.get(path) || null;
+    }
+    async runGuards(to) {
+        for (const guard of this.guards) {
+            const result = await guard(to, this.currentRoute);
+            if (!result)
+                return false;
+        }
+        return true;
+    }
+    setupNavigationListener() {
+        this.strategy.listen((path) => {
+            this.push(path);
+        });
+    }
+    notifyListeners(route) {
+        this.listeners.forEach(listener => listener(route));
+    }
+}

package/dist/core/DefaultShell.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Default Shell Implementation
+ */
+import type { IShell, IThemeManager, IFeatureManager, IRouter } from '@amk/ui-shell-api';
+import type { ShellConfig, ShellContext, ShellEventListener, ShellEventType } from '@amk/ui-shell-api';
+export declare class DefaultShell implements IShell {
+    private themeManager;
+    private featureManager;
+    private router;
+    private eventListeners;
+    private viewportState;
+    private config;
+    private isReady;
+    constructor(config?: ShellConfig);
+    initialize(): Promise<void>;
+    getContext(): ShellContext;
+    getThemeManager(): IThemeManager;
+    getFeatureManager(): IFeatureManager;
+    getRouter(): IRouter | null;
+    setRouter(router: IRouter): void;
+    emit(type: ShellEventType, payload?: any): void;
+    on(type: ShellEventType | '*', listener: ShellEventListener): () => void;
+    off(type: ShellEventType | '*', listener: ShellEventListener): void;
+    ready(): boolean;
+    getConfig(): Readonly<ShellConfig>;
+    destroy(): void;
+    private setupViewportListener;
+    private handleResize;
+}
+//# sourceMappingURL=DefaultShell.d.ts.map

package/dist/core/DefaultShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultShell.d.ts","sourceRoot":"","sources":["../../src/core/DefaultShell.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACzF,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAc,kBAAkB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAMnH,qBAAa,YAAa,YAAW,MAAM;IACzC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,cAAc,CAAmD;IACzE,OAAO,CAAC,aAAa,CAGnB;IACF,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,GAAE,WAAgB;IAc9B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBjC,UAAU,IAAI,YAAY;IAiB1B,eAAe,IAAI,aAAa;IAIhC,iBAAiB,IAAI,eAAe;IAIpC,SAAS,IAAI,OAAO,GAAG,IAAI;IAI3B,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAOhC,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAkB/C,EAAE,CAAC,IAAI,EAAE,cAAc,GAAG,GAAG,EAAE,QAAQ,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAiBxE,GAAG,CAAC,IAAI,EAAE,cAAc,GAAG,GAAG,EAAE,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAOnE,KAAK,IAAI,OAAO;IAIhB,SAAS,IAAI,QAAQ,CAAC,WAAW,CAAC;IAIlC,OAAO,IAAI,IAAI;IAaf,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,YAAY,CAUlB;CACH"}

package/dist/core/DefaultShell.js

@@ -0,0 +1,147 @@
+/**
+ * Default Shell Implementation
+ */
+import { DefaultThemeManager } from './DefaultThemeManager';
+import { DefaultFeatureManager } from './DefaultFeatureManager';
+import { LocalStorageProvider } from '../providers/LocalStorageProvider';
+import { CSSVariablesThemeProvider } from '../providers/CSSVariablesThemeProvider';
+export class DefaultShell {
+    themeManager;
+    featureManager;
+    router = null;
+    eventListeners = new Map();
+    viewportState = {
+        width: typeof window !== 'undefined' ? window.innerWidth : 0,
+        height: typeof window !== 'undefined' ? window.innerHeight : 0,
+    };
+    config;
+    isReady = false;
+    constructor(config = {}) {
+        this.config = config;
+        // Create theme manager with providers
+        const storageProvider = new LocalStorageProvider();
+        const themeProvider = new CSSVariablesThemeProvider();
+        this.themeManager = new DefaultThemeManager(config.theme, storageProvider, themeProvider);
+        // Create feature manager
+        this.featureManager = new DefaultFeatureManager(config.features);
+        this.setupViewportListener();
+    }
+    async initialize() {
+        if (this.isReady) {
+            console.warn('Shell is already initialized');
+            return;
+        }
+        // Apply initial theme
+        this.themeManager.setTheme(this.themeManager.getTheme());
+        // Subscribe to theme changes
+        this.themeManager.subscribe(theme => {
+            this.emit('theme:changed', { theme });
+        });
+        // Subscribe to feature changes
+        this.featureManager.subscribeAll((key, value) => {
+            this.emit('feature:toggled', { key, value });
+        });
+        this.isReady = true;
+        this.emit('shell:ready', {});
+    }
+    getContext() {
+        return {
+            theme: this.themeManager.getTheme(),
+            setTheme: (mode) => this.themeManager.setTheme(mode),
+            features: this.featureManager.getAll(),
+            isFeatureEnabled: (key) => this.featureManager.isEnabled(key),
+            getFeature: (key, defaultValue) => this.featureManager.get(key, defaultValue),
+            viewport: {
+                width: this.viewportState.width,
+                height: this.viewportState.height,
+                isMobile: this.viewportState.width < 768,
+                isTablet: this.viewportState.width >= 768 && this.viewportState.width < 1024,
+                isDesktop: this.viewportState.width >= 1024,
+            },
+        };
+    }
+    getThemeManager() {
+        return this.themeManager;
+    }
+    getFeatureManager() {
+        return this.featureManager;
+    }
+    getRouter() {
+        return this.router;
+    }
+    setRouter(router) {
+        this.router = router;
+        this.router.subscribe(route => {
+            this.emit('route:changed', { route });
+        });
+    }
+    emit(type, payload) {
+        const event = {
+            type,
+            payload,
+            timestamp: Date.now(),
+        };
+        const listeners = this.eventListeners.get(type);
+        if (listeners) {
+            listeners.forEach(listener => listener(event));
+        }
+        const wildcardListeners = this.eventListeners.get('*');
+        if (wildcardListeners) {
+            wildcardListeners.forEach(listener => listener(event));
+        }
+    }
+    on(type, listener) {
+        if (!this.eventListeners.has(type)) {
+            this.eventListeners.set(type, new Set());
+        }
+        this.eventListeners.get(type).add(listener);
+        return () => {
+            const listeners = this.eventListeners.get(type);
+            if (listeners) {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.eventListeners.delete(type);
+                }
+            }
+        };
+    }
+    off(type, listener) {
+        const listeners = this.eventListeners.get(type);
+        if (listeners) {
+            listeners.delete(listener);
+        }
+    }
+    ready() {
+        return this.isReady;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    destroy() {
+        this.themeManager.destroy();
+        this.featureManager.destroy();
+        if (this.router) {
+            this.router.destroy();
+        }
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('resize', this.handleResize);
+        }
+        this.eventListeners.clear();
+        this.isReady = false;
+    }
+    setupViewportListener() {
+        if (typeof window === 'undefined')
+            return;
+        window.addEventListener('resize', this.handleResize);
+    }
+    handleResize = () => {
+        if (typeof window === 'undefined')
+            return;
+        this.viewportState.width = window.innerWidth;
+        this.viewportState.height = window.innerHeight;
+        this.emit('viewport:resized', {
+            width: this.viewportState.width,
+            height: this.viewportState.height,
+        });
+    };
+}

package/dist/core/DefaultThemeManager.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Default Theme Manager Implementation
+ */
+import type { IThemeManager } from '@amk/ui-shell-api';
+import type { ThemeMode, ThemeConfig } from '@amk/ui-shell-api';
+import type { IStorageProvider, IThemeProvider } from '@amk/ui-shell-spi';
+export declare class DefaultThemeManager implements IThemeManager {
+    private currentTheme;
+    private config;
+    private listeners;
+    private storageProvider;
+    private themeProvider;
+    constructor(config: ThemeConfig | undefined, storageProvider: IStorageProvider, themeProvider: IThemeProvider);
+    getTheme(): ThemeMode;
+    getResolvedTheme(): 'light' | 'dark';
+    setTheme(mode: ThemeMode): void;
+    toggleTheme(): void;
+    subscribe(listener: (theme: ThemeMode) => void): () => void;
+    setCSSVariables(variables: Record<string, string>): void;
+    destroy(): void;
+    private setupSystemThemeListener;
+    private applyTheme;
+    private loadPersistedTheme;
+    private persistTheme;
+    private notifyListeners;
+}
+//# sourceMappingURL=DefaultThemeManager.d.ts.map

package/dist/core/DefaultThemeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultThemeManager.d.ts","sourceRoot":"","sources":["../../src/core/DefaultThemeManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAI1E,qBAAa,mBAAoB,YAAW,aAAa;IACvD,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,aAAa,CAAiB;gBAGpC,MAAM,yBAAkC,EACxC,eAAe,EAAE,gBAAgB,EACjC,aAAa,EAAE,cAAc;IAU/B,QAAQ,IAAI,SAAS;IAIrB,gBAAgB,IAAI,OAAO,GAAG,MAAM;IAOpC,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAS/B,WAAW,IAAI,IAAI;IAKnB,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI;IAK3D,eAAe,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAKxD,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,wBAAwB;IAShC,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,eAAe;CAGxB"}

package/dist/core/DefaultThemeManager.js

@@ -0,0 +1,76 @@
+/**
+ * Default Theme Manager Implementation
+ */
+const THEME_STORAGE_KEY = 'ui-shell-theme';
+export class DefaultThemeManager {
+    currentTheme = 'system';
+    config;
+    listeners = new Set();
+    storageProvider;
+    themeProvider;
+    constructor(config = { mode: 'system' }, storageProvider, themeProvider) {
+        this.config = config;
+        this.storageProvider = storageProvider;
+        this.themeProvider = themeProvider;
+        this.currentTheme = config.mode || this.loadPersistedTheme();
+        this.setupSystemThemeListener();
+        this.applyTheme();
+    }
+    getTheme() {
+        return this.currentTheme;
+    }
+    getResolvedTheme() {
+        if (this.currentTheme === 'system') {
+            return this.themeProvider.getSystemPreference();
+        }
+        return this.currentTheme;
+    }
+    setTheme(mode) {
+        if (this.currentTheme === mode)
+            return;
+        this.currentTheme = mode;
+        this.persistTheme(mode);
+        this.applyTheme();
+        this.notifyListeners();
+    }
+    toggleTheme() {
+        const resolved = this.getResolvedTheme();
+        this.setTheme(resolved === 'light' ? 'dark' : 'light');
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    setCSSVariables(variables) {
+        this.config.cssVariables = { ...this.config.cssVariables, ...variables };
+        this.applyTheme();
+    }
+    destroy() {
+        this.themeProvider.destroy();
+        this.listeners.clear();
+    }
+    setupSystemThemeListener() {
+        this.themeProvider.onSystemThemeChange(() => {
+            if (this.currentTheme === 'system') {
+                this.applyTheme();
+                this.notifyListeners();
+            }
+        });
+    }
+    applyTheme() {
+        this.themeProvider.applyTheme(this.currentTheme, this.config);
+    }
+    loadPersistedTheme() {
+        const stored = this.storageProvider.getItem(THEME_STORAGE_KEY);
+        if (stored === 'light' || stored === 'dark' || stored === 'system') {
+            return stored;
+        }
+        return 'system';
+    }
+    persistTheme(mode) {
+        this.storageProvider.setItem(THEME_STORAGE_KEY, mode);
+    }
+    notifyListeners() {
+        this.listeners.forEach(listener => listener(this.currentTheme));
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Core Implementations
+ * Export all core implementation classes
+ */
+export * from './DefaultShell';
+export * from './DefaultThemeManager';
+export * from './DefaultFeatureManager';
+export * from './DefaultLayoutManager';
+export * from './DefaultRouter';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,9 @@
+/**
+ * Core Implementations
+ * Export all core implementation classes
+ */
+export * from './DefaultShell';
+export * from './DefaultThemeManager';
+export * from './DefaultFeatureManager';
+export * from './DefaultLayoutManager';
+export * from './DefaultRouter';

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * UI Shell Implementation
+ * Concrete implementations of UI Shell interfaces
+ *
+ * This package provides default implementations that can be used directly
+ * or extended for custom behavior.
+ */
+export declare const version = "0.1.0";
+export * from './core';
+export * from './providers';
+export * from './utils';
+export * from './plugin';
+import { DefaultShell } from './core/DefaultShell';
+import { DefaultLayoutManager } from './core/DefaultLayoutManager';
+import type { ShellConfig } from '@amk/ui-shell-api';
+export declare function createShell(config?: ShellConfig): DefaultShell;
+export declare function createLayoutManager(): DefaultLayoutManager;
+export declare function getShell(config?: ShellConfig): DefaultShell;
+export declare function resetShell(): void;
+//# sourceMappingURL=index.d.ts.map