@celljs/widget 3.0.0

package/src/browser/locale/locale-manager.ts

@@ -0,0 +1,54 @@
+import { LocaleManager, Locale } from './locale-protocol';
+import { Component, Value, Autowired, Optional, Prioritizeable, PostConstruct } from '@celljs/core';
+import { BehaviorSubject } from 'rxjs';
+
+@Component(LocaleManager)
+export class LocaleManagerImpl implements LocaleManager {
+
+    protected readonly langStorageKey = 'cell:lang';
+
+    @Value('cell.locales')
+    protected readonly localesForConfig: { [lang: string]: Locale };
+
+    @Autowired(Locale) @Optional()
+    protected readonly locales: Locale[];
+
+    protected prioritized: Locale[];
+
+    currentSubject = new BehaviorSubject<Locale | undefined>(undefined);
+
+    @PostConstruct()
+    init() {
+        (async () => {
+            const locales = await this.get();
+            const lang = localStorage.getItem(this.langStorageKey) || navigator.language;
+            if (locales.length) {
+                this.currentSubject.next(locales.find(l => l.lang === lang) || locales[0]);
+            }
+
+            this.currentSubject.subscribe(locale => {
+                if (locale) {
+                    localStorage.setItem(this.langStorageKey, locale.lang);
+                } else {
+                    localStorage.removeItem(this.langStorageKey);
+                }
+            });
+        })();
+    }
+
+    async get(): Promise<Locale[]> {
+        if (!this.prioritized) {
+            const config = this.localesForConfig || {};
+            const parsedLacalesForConfig = Object.keys(config).map(lang => {
+                const locale = { ...config[lang] };
+                locale.lang = lang;
+                locale.priority = locale.priority || 500;
+                return locale;
+            });
+
+            this.prioritized = Prioritizeable.prioritizeAllSync([ ...parsedLacalesForConfig, ...this.locales ]).map(p => p.value);
+        }
+        return this.prioritized;
+    }
+
+}

package/src/browser/locale/locale-protocol.ts

@@ -0,0 +1,18 @@
+import { BehaviorSubject } from 'rxjs';
+
+export const Locale = Symbol('Locale');
+export const LocaleManager = Symbol('LocaleManager');
+
+export interface Locale {
+    lang: string;
+    priority: number;
+    label?: string;
+    messages: { [key: string]: string };
+}
+
+export interface LocaleManager {
+
+    currentSubject: BehaviorSubject<Locale | undefined>;
+
+    get(): Promise<Locale[]>;
+}

package/src/browser/module.ts

@@ -0,0 +1,3 @@
+import { autoBind } from '@celljs/core';
+
+export default autoBind();

package/src/browser/theme/index.ts

@@ -0,0 +1,2 @@
+export * from './theme-protocol';
+export * from './theme-manager';

package/src/browser/theme/theme-manager.ts

@@ -0,0 +1,53 @@
+import { Theme, ThemeManager, DEFAULT_THEME } from './theme-protocol';
+import { Component, Value, Autowired, Optional, Prioritizeable, PostConstruct } from '@celljs/core';
+import { BehaviorSubject } from 'rxjs';
+
+@Component(ThemeManager)
+export class ThemeManagerImpl<T> implements ThemeManager<T> {
+
+    protected readonly themeStorageKey = 'cell:theme';
+
+    @Value('cell.themes')
+    protected readonly themesForConfig: { [id: string]: Theme<T> };
+
+    @Autowired(Theme) @Optional()
+    protected readonly themes: Theme<T>[];
+
+    protected prioritized: Theme<T>[];
+
+    currentSubject = new BehaviorSubject<Theme<T> | undefined>(undefined);
+
+    @PostConstruct()
+    init() {
+        const themeStr = localStorage.getItem(this.themeStorageKey);
+        if (themeStr) {
+            this.currentSubject.next(JSON.parse(themeStr));
+        } else {
+            if (this.themesForConfig) {
+                this.currentSubject.next(this.themesForConfig[DEFAULT_THEME]);
+            }
+        }
+        this.currentSubject.subscribe(theme => {
+            if (theme) {
+                localStorage.setItem(this.themeStorageKey, JSON.stringify(theme));
+            } else {
+                localStorage.removeItem(this.themeStorageKey);
+            }
+        });
+    }
+
+    async get(): Promise<Theme<T>[]> {
+        if (!this.prioritized) {
+            const parsedThemesForConfig = Object.keys(this.themesForConfig || {}).map(id => {
+                const theme = { ...this.themesForConfig[id] };
+                theme.id = id;
+                theme.priority = theme.priority || 500;
+                return theme;
+            });
+
+            this.prioritized = Prioritizeable.prioritizeAllSync([ ...parsedThemesForConfig, ...this.themes ]).map(p => p.value);
+        }
+        return this.prioritized;
+    }
+
+}

package/src/browser/theme/theme-protocol.ts

@@ -0,0 +1,22 @@
+import { BehaviorSubject } from 'rxjs';
+
+export const Theme = Symbol('Theme');
+export const ThemeManager = Symbol('ThemeManager');
+
+export const DEFAULT_THEME = 'default';
+
+export interface Theme<T> {
+    id: string
+    label: string;
+    color: string;
+    priority: number;
+    props: T;
+    metadata: { [key: string]: any }
+}
+
+export interface ThemeManager<T> {
+
+    currentSubject: BehaviorSubject<Theme<T> | undefined>;
+
+    get(): Promise<Theme<T>[]>;
+}

package/src/browser/widget/index.ts

@@ -0,0 +1,4 @@
+export { WidgetFactory, WidgetModel, WidgetManager, WidgetType } from './widget-protocol';
+export * from './widget-manager';
+export * from './widget-factory';
+export * from './widget-util';

package/src/browser/widget/widget-factory.ts

@@ -0,0 +1,36 @@
+import { WidgetModel, WidgetFactory, Widget } from './widget-protocol';
+import { WidgetUtil } from './widget-util';
+import { Autowired, ExpressionHandler, Injectable } from '@celljs/core';
+
+@Injectable()
+export abstract class AbstractWidgetFactory<T> implements WidgetFactory<T> {
+
+    @Autowired(ExpressionHandler)
+    protected readonly expressionHandler: ExpressionHandler;
+
+    priority: number = 500;
+
+    async create(widgetModel: WidgetModel): Promise<Widget<T>> {
+        const { children = [] } = widgetModel;
+
+        return {
+            id: widgetModel.id,
+            visible: widgetModel.visible,
+            area: widgetModel.area,
+            priority: widgetModel.priority,
+            render: async () => {
+                if (widgetModel.props) {
+                    this.expressionHandler.handle(widgetModel.props);
+                }
+                return this.doRender(widgetModel, await Promise.all(children.map(c => WidgetUtil.create<T>(c))));
+            }
+        };
+    }
+
+    async support(widgetModel: WidgetModel): Promise<boolean> {
+        return this.constructor.name.startsWith(widgetModel.type);
+    }
+
+    protected abstract doRender(widgetModel: WidgetModel, children: Widget<T>[]): Promise<T>;
+
+}

package/src/browser/widget/widget-manager.ts

@@ -0,0 +1,64 @@
+import { Component, Autowired, Prioritizeable, Value, Optional } from '@celljs/core';
+import { WidgetManager, WidgetModel, Widget } from './widget-protocol';
+import { WidgetUtil } from './widget-util';
+
+@Component(WidgetManager)
+export class WidgetManagerImpl<T> implements WidgetManager<T> {
+
+    protected prioritized: Map<string, Widget<T>[]>;
+
+    constructor(
+        @Autowired(Widget) @Optional() protected readonly widgets: Widget<T>[],
+        @Autowired(WidgetModel) @Optional() protected readonly widgetModels: WidgetModel[],
+        @Value('cell.widget.widgets') protected readonly widgetModelsForConfig: { [id: string]: WidgetModel }
+    ) {}
+
+    async render(area: string): Promise<T[]> {
+        const widgets = await this.get(area);
+        return Promise.all(widgets.map(w => w.render()));
+    }
+
+    async get(area: string): Promise<Widget<T>[]> {
+        if (!this.prioritized) {
+            const result = new Map<string, Widget<T>[]>();
+            const config = { ...this.widgetModelsForConfig };
+            this.widgets.forEach(w => {
+                const c = config[w.id];
+                if (config) {
+                    w.area = c.area;
+                    w.priority = c.priority === undefined ? w.priority : c.priority;
+                    w.visible = c.visible === undefined ? w.visible : c.visible;
+                    delete config[w.id];
+                }
+            });
+            const parsedWdigets = await Promise.all(this.widgetModels.map(w => {
+                const c = config[w.id];
+                delete config[w.id];
+                return WidgetUtil.create<T>({ ...w, ...c});
+            }));
+            const parsedWidgetsForConfig = await Promise.all((Object.keys(config).map(id => {
+                const widgetModel = { ...config[id] };
+                widgetModel.id = id;
+                widgetModel.priority = widgetModel.priority || 500;
+                widgetModel.visible = widgetModel.visible === false ? false : true;
+                return WidgetUtil.create<T>(widgetModel);
+            })));
+
+            for (const widget of [ ...this.widgets, ...parsedWdigets, ...parsedWidgetsForConfig ]) {
+                if (!result.has(widget.area!)) {
+                    result.set(widget.area!, []);
+                }
+                if (widget.visible) {
+                    result.get(widget!.area!)!.push(widget);
+                }
+            }
+
+            for (const [ a, ws ] of result.entries()) {
+                result.set(a, Prioritizeable.prioritizeAllSync(ws).map(c => c.value));
+            }
+            this.prioritized = result;
+        }
+        return this.prioritized.get(area) || [];
+    }
+
+}

package/src/browser/widget/widget-protocol.ts

@@ -0,0 +1,38 @@
+export const Widget = Symbol('Widget');
+export const WidgetModel = Symbol('WidgetModel');
+export const WidgetFactory = Symbol('WidgetFactory');
+export const WidgetManager = Symbol('WidgetManager');
+
+export enum WidgetType {
+    Decorator = 'Decorator'
+}
+
+export interface Widget<T> {
+    id: string;
+    priority: number;
+    area?: string;
+    visible: boolean;
+    render(): Promise<T>;
+}
+
+export interface WidgetModel {
+    id: string;
+    type: string;
+    priority: number;
+    visible: boolean;
+    area?: string;
+    props?: { [key: string]: any };
+    matedata?: { [key: string]: any };
+    children?: WidgetModel[]
+}
+
+export interface WidgetFactory<T> {
+    priority: number;
+    create(widgetModel: WidgetModel): Promise<Widget<T>>;
+    support(widgetModel: WidgetModel): Promise<boolean>;
+}
+
+export interface WidgetManager<T> {
+    get(area: string): Promise<Widget<T>[]>;
+    render(area: string): Promise<T[]>;
+}

package/src/browser/widget/widget-util.ts

@@ -0,0 +1,26 @@
+import { ContainerUtil, Prioritizeable } from '@celljs/core';
+import { WidgetModel, WidgetFactory, Widget } from './widget-protocol';
+
+let widgetFactories: WidgetFactory<any>[];
+
+export namespace WidgetUtil {
+    export async function create<T>(widgetModel: WidgetModel): Promise<Widget<T>> {
+        if (!widgetFactories) {
+            widgetFactories = Prioritizeable.prioritizeAllSync(ContainerUtil.getAll<WidgetFactory<T>>(WidgetFactory)).map(p => p.value);
+        }
+
+        for (const factory of widgetFactories) {
+            if (await factory.support(widgetModel)) {
+                const widget = await factory.create(widgetModel);
+                return widget;
+            }
+        }
+        throw new Error(`WidgetModel {id: ${widgetModel.id}, type: ${widgetModel.type}} there is no matching widget factory.`);
+    }
+
+    export async function render<T>(widgetModel: WidgetModel): Promise<T> {
+        const widget = await WidgetUtil.create<T>(widgetModel);
+        return widget.render();
+    }
+
+}

package/src/package.spec.ts

@@ -0,0 +1,4 @@
+describe('widget package', () => {
+
+    it('support code coverage statistics', () => {});
+});