@telia-ace/widget-core-flamingo 0.0.1

package/models/application.d.ts

@@ -0,0 +1,46 @@
+import { Trigger } from '../components/trigger.component';
+import { WidgetComponentType } from '../components/widget.component';
+import { Wrapper } from '../components/wrapper.component';
+import { ComponentPlatform } from '../services/component-platform';
+import { StorageService } from '../services/storage.service';
+import { TextsService } from '../services/texts.service';
+import { WidgetAPI } from '../services/widget-api';
+import { ApplicationOptions, PluginType, RenderStrategy, TriggerIcon, WidgetAnchor, WidgetConfig } from '../types';
+import { Container } from './container';
+export declare class Application {
+    id: string;
+    name: string;
+    container: Container;
+    settings: WidgetConfig;
+    private options;
+    platform: ComponentPlatform;
+    texts: TextsService;
+    storage: StorageService;
+    root?: Wrapper;
+    renderStrategy: RenderStrategy;
+    triggerIcon?: TriggerIcon;
+    anchor: WidgetAnchor;
+    autoActivate: boolean;
+    private plugins;
+    private componentResolver;
+    private components;
+    trigger: Trigger | null;
+    api: WidgetAPI;
+    constructor(id: string, name: string, container: Container, settings: WidgetConfig, options: ApplicationOptions);
+    activate(): Promise<void>;
+    private loadPlugins;
+    styles(): Record<string, any>;
+    branding(): Record<string, any>;
+    plugin(plugin: PluginType): this;
+    appendToDOM(): void;
+    hide(): void;
+    setZIndex(zIndex: number): void;
+    mute(): void;
+    unmute(): void;
+    registerComponent(type: string, component: any): void;
+    resolveComponent(type: string): any;
+    mountComponent(component: WidgetComponentType): void;
+    getComponent<T extends WidgetComponentType>(type: string): T | null;
+    private _getTargetElement;
+    render(): Trigger | Wrapper | undefined;
+}

package/models/container.d.ts

@@ -0,0 +1,16 @@
+import { BehaviorSubject } from 'rxjs';
+import { Environment } from './environment';
+export declare enum ContainerState {
+    Loading = "loading",
+    Ready = "ready"
+}
+export declare class Container {
+    name: string;
+    environment: Environment;
+    state: BehaviorSubject<ContainerState>;
+    private resolvers;
+    constructor(name: string, environment: Environment);
+    setState(state: ContainerState): void;
+    register(name: string, value: unknown): Promise<void>;
+    get<T>(name: string): Promise<T | undefined>;
+}

package/models/environment.d.ts

@@ -0,0 +1,25 @@
+import { Application } from './application';
+import { Container } from './container';
+import { ApplicationOptions, PluginType, WidgetConfig } from '../types';
+import { WidgetAPI } from '../services/widget-api';
+import { SiteAPI } from '../services/site-api';
+import { Site } from './site';
+export type WidgetAPIHandler = (widget?: WidgetAPI) => void;
+export type SiteConfigurationHandler = (site: SiteAPI) => void;
+export declare class Environment {
+    applications: Application[];
+    container: Container;
+    private bootstrapped;
+    private site;
+    widgetAPIHandlers: Map<string, WidgetAPIHandler[]>;
+    siteConfigurationHandlers: SiteConfigurationHandler[];
+    constructor();
+    bootstrap(): Promise<void>;
+    private activate;
+    private notifyWidgetsOfCreation;
+    configure(delegate: SiteConfigurationHandler): void;
+    widget(name: string, delegate: WidgetAPIHandler): void;
+    registerApp(id: string, name: string, config: WidgetConfig, options: ApplicationOptions): void;
+    registerSite(site: Site): void;
+    plugin(plugin: PluginType): this;
+}

package/models/site.d.ts

@@ -0,0 +1,15 @@
+import { SiteAPI } from '../services/site-api';
+import { InitConfig } from '../types';
+import { Environment } from './environment';
+export declare class Site {
+    environment?: Environment;
+    private configurations;
+    private url?;
+    private httpClient;
+    api: SiteAPI;
+    constructor(urlOrConfig: string | InitConfig);
+    load(url: string): Promise<void>;
+    loadFromConfig(config: InitConfig): void;
+    bootstrap(handler: (environment: Environment) => void): Promise<void>;
+    private addGlobal;
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@telia-ace/widget-core-flamingo",
+  "version": "0.0.1",
+  "dependencies": {
+    "lit": "^3.0.2",
+    "@teliads/icons": "^8.4.0",
+    "rxjs": "^7.8.1",
+    "lit-html": "^3.0.2",
+    "@lit-labs/motion": "^1.0.6",
+    "@lit/context": "^1.0.1"
+  },
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "typings": "./index.d.ts"
+}

package/services/component-platform.d.ts

@@ -0,0 +1,13 @@
+import { WidgetComponentType } from '../components/widget.component';
+import { Wrapper } from '../components/wrapper.component';
+import { Application } from '../models/application';
+import { WidgetConfig } from '../types';
+export declare class ComponentPlatform {
+    private root;
+    constructor();
+    createComponentModel(settings: WidgetConfig, application: Application): Wrapper;
+    createRoot(): Wrapper;
+    createNode(name: string, type: string): WidgetComponentType;
+    private resolveComponent;
+    getRoot(): Wrapper;
+}

package/services/component-resolver.d.ts

@@ -0,0 +1,8 @@
+export declare class ComponentResolver {
+    components: Map<string, any>;
+    getComponent(type: string): any;
+    registerComponent(type: string, component: any): void;
+    loadComponents(): Promise<void>;
+    private defineAsWebComponent;
+    static ResolveWebComponentName: (widgetComponentName: string) => string;
+}

package/services/http-client.service.d.ts

@@ -0,0 +1,18 @@
+import { SiteConfig, WidgetConfig } from '../types';
+type GetWidgetResponse = {
+    name: string;
+    config: WidgetConfig;
+};
+export interface IHttpClient {
+    getSite(url: string): Promise<SiteConfig | null>;
+    getWidget(widgetId: string): Promise<GetWidgetResponse | null>;
+}
+export declare const createHttpClient: (endpoint?: string) => IHttpClient;
+export declare class HttpClient implements IHttpClient {
+    private _endpoint;
+    private static endpoint;
+    constructor(_endpoint?: string);
+    getSite(url: string): Promise<SiteConfig | null>;
+    getWidget(widgetId: string): Promise<GetWidgetResponse | null>;
+}
+export {};

package/services/site-api.d.ts

@@ -0,0 +1,7 @@
+import { Site } from '../models/site';
+export declare class SiteAPI {
+    private site;
+    constructor(site: Site);
+    storagePolicy(policies: string[]): void;
+    disallowStorageKey(key: string): void;
+}

package/services/storage.service.d.ts

@@ -0,0 +1,19 @@
+export declare enum StorageCategory {
+    Necessary = "necessary",
+    Functional = "functional",
+    Analytics = "analytics"
+}
+export declare class StorageService {
+    private storage;
+    private policy;
+    private widgetId;
+    private disallowedKeys;
+    constructor(widgetId: string, storageType: 'localStorage' | 'sessionStorage', policy: Record<StorageCategory, boolean>);
+    set<T>(key: string, value: T, category: StorageCategory): void;
+    get<T>(key: string): T | null;
+    removeItem(key: string): void;
+    enforcePolicy(): void;
+    updatePolicy(newPolicy: Record<StorageCategory, boolean>): void;
+    disallowKey(key: string): void;
+    private _prefixKey;
+}

package/services/texts.service.d.ts

@@ -0,0 +1,10 @@
+export interface ITextsService {
+    loadTexts(texts: Record<string, string>): void;
+    get(key: string): string | null;
+}
+export declare class TextsService implements ITextsService {
+    private texts;
+    loadTexts(texts: Record<string, string>): void;
+    get(key: string, fallback?: string): string | null;
+    getOrFallback(key: string, fallback: string): string;
+}

package/services/widget-api.d.ts

@@ -0,0 +1,9 @@
+import { Application } from '../models/application';
+export declare class WidgetAPI {
+    private widget;
+    name: string;
+    constructor(widget: Application);
+    open(): void;
+    close(): void;
+    setZIndex(zIndex: number): void;
+}

package/types.d.ts

@@ -0,0 +1,56 @@
+import { Application } from './models/application';
+import { IHttpClient } from './services/http-client.service';
+export type ComponentDefinition = {
+    name: string;
+    type: string;
+    properties?: Record<string, any>;
+    context?: Record<string, any>;
+    layout?: Record<string, any>;
+    children?: string[];
+};
+export type WidgetConfig = {
+    entry: string;
+    texts?: Record<string, string>;
+    components: Record<string, ComponentDefinition>;
+    branding: Record<string, any>;
+    styles?: Record<string, any>;
+    survey?: Record<string, any>;
+};
+export declare enum RenderStrategy {
+    Inline = "inline",
+    Trigger = "trigger"
+}
+export type ApplicationOptions = {
+    renderStrategy: RenderStrategy;
+    triggerIcon?: TriggerIcon;
+    autoActivate?: boolean;
+    anchor?: WidgetAnchor;
+};
+export type TriggerIcon = {
+    type: string;
+    content: string;
+};
+export type AppConfig = {
+    id: string;
+    widgetId: string;
+    renderStrategy: RenderStrategy;
+    triggerIcon?: TriggerIcon;
+    autoActivate?: boolean;
+    anchor?: WidgetAnchor;
+};
+export type SiteConfig = {
+    id: string;
+    apps: AppConfig[];
+};
+export type InitConfig = {
+    apps: {
+        widgetId: string;
+        renderStrategy?: 'inline' | 'trigger';
+        triggerIcon?: string;
+        autoActivate?: boolean;
+        anchor?: WidgetAnchor;
+    }[];
+    httpClient?: IHttpClient;
+};
+export type PluginType = (app: Application) => Promise<void>;
+export type WidgetAnchor = 'BottomRight' | 'BottomLeft';

package/utils/map-branding.d.ts

@@ -0,0 +1 @@
+export declare const mapBranding: (context: Record<string, any>, el: HTMLElement) => void;