@telia-ace/widget-core 1.0.0

package/lib/component-platform/extend-component.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendComponent = void 0;
+var widget_utilities_1 = require("@telia-ace/widget-utilities");
+var component_controller_1 = require("./component-controller");
+var component_platform_1 = require("./component-platform");
+var component_query_1 = require("./component-query");
+var extendComponent = function (container, typeOrQuery, handler, ns, options) {
+    if (ns === void 0) { ns = (0, widget_utilities_1.uuid)(); }
+    if (options === void 0) { options = {}; }
+    return container.getAsync('components').then(function (components) {
+        var target;
+        if (typeof typeOrQuery === 'string') {
+            var collection = new component_query_1.ComponentQuery(components);
+            collection.ofType(typeOrQuery);
+            target = collection;
+        }
+        else {
+            target = typeOrQuery;
+        }
+        var managedInstances = {};
+        var getOrCreateController = function (node) {
+            var existing = managedInstances[node.id];
+            if (existing) {
+                return Promise.resolve(existing.controller);
+            }
+            return component_platform_1.ComponentPlatform.getInstance(container).then(function (platform) {
+                return new component_controller_1.ComponentNodeController(platform, node, ns);
+            });
+        };
+        components.events.subscribe('components:node-enter', function (event, _a) {
+            var node = _a.node;
+            if (target.match(node)) {
+                getOrCreateController(node).then(function (controller) {
+                    Promise.resolve(handler(controller)).then(function (dispose) {
+                        managedInstances[node.id] = {
+                            dispose: dispose,
+                            controller: controller,
+                        };
+                    });
+                });
+            }
+        });
+        components.events.subscribe('components:node-exit', function (event, _a) {
+            var node = _a.node;
+            var instance = managedInstances[node.id];
+            if (instance) {
+                instance.dispose && instance.dispose();
+                if (!options.reuseController) {
+                    instance.controller.dispose();
+                    delete managedInstances[node.id];
+                }
+            }
+        });
+    });
+};
+exports.extendComponent = extendComponent;

package/lib/component-platform/index.d.ts

@@ -0,0 +1,16 @@
+export { ActionsController } from './actions-controller';
+export type { WatchActionDelegate } from './actions-controller';
+export type { ChangesetProvider } from './changeset-provider';
+export { AbstractComponentController, ComponentNodeController } from './component-controller';
+export { ComponentNode } from './component-node';
+export type { ChangesetOptions, ComponentNodeAttributes, ComponentNodeContext, ComponentNodeLayout, ComponentNodeProperties, ComponentNodeSettings, Size, } from './component-node';
+export { ComponentPlatform } from './component-platform';
+export type { SwitchMap } from './component-platform';
+export { ComponentQuery } from './component-query';
+export type { ComponentQueryRule } from './component-query';
+export { createComponentModel } from './create-component-model';
+export { asDescriptor } from './descriptor';
+export type { ComponentDescriptor } from './descriptor';
+export { extendComponent } from './extend-component';
+export type { ExtendComponentHandler, ExtendComponentOptions } from './extend-component';
+export { findComponent, findVisibleComponents, traverseComponents } from './queries';

package/lib/component-platform/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseComponents = exports.findVisibleComponents = exports.findComponent = exports.extendComponent = exports.asDescriptor = exports.createComponentModel = exports.ComponentQuery = exports.ComponentPlatform = exports.ComponentNode = exports.ComponentNodeController = exports.AbstractComponentController = exports.ActionsController = void 0;
+var actions_controller_1 = require("./actions-controller");
+Object.defineProperty(exports, "ActionsController", { enumerable: true, get: function () { return actions_controller_1.ActionsController; } });
+var component_controller_1 = require("./component-controller");
+Object.defineProperty(exports, "AbstractComponentController", { enumerable: true, get: function () { return component_controller_1.AbstractComponentController; } });
+Object.defineProperty(exports, "ComponentNodeController", { enumerable: true, get: function () { return component_controller_1.ComponentNodeController; } });
+var component_node_1 = require("./component-node");
+Object.defineProperty(exports, "ComponentNode", { enumerable: true, get: function () { return component_node_1.ComponentNode; } });
+var component_platform_1 = require("./component-platform");
+Object.defineProperty(exports, "ComponentPlatform", { enumerable: true, get: function () { return component_platform_1.ComponentPlatform; } });
+var component_query_1 = require("./component-query");
+Object.defineProperty(exports, "ComponentQuery", { enumerable: true, get: function () { return component_query_1.ComponentQuery; } });
+var create_component_model_1 = require("./create-component-model");
+Object.defineProperty(exports, "createComponentModel", { enumerable: true, get: function () { return create_component_model_1.createComponentModel; } });
+var descriptor_1 = require("./descriptor");
+Object.defineProperty(exports, "asDescriptor", { enumerable: true, get: function () { return descriptor_1.asDescriptor; } });
+var extend_component_1 = require("./extend-component");
+Object.defineProperty(exports, "extendComponent", { enumerable: true, get: function () { return extend_component_1.extendComponent; } });
+var queries_1 = require("./queries");
+Object.defineProperty(exports, "findComponent", { enumerable: true, get: function () { return queries_1.findComponent; } });
+Object.defineProperty(exports, "findVisibleComponents", { enumerable: true, get: function () { return queries_1.findVisibleComponents; } });
+Object.defineProperty(exports, "traverseComponents", { enumerable: true, get: function () { return queries_1.traverseComponents; } });

package/lib/component-platform/queries.d.ts

@@ -0,0 +1,6 @@
+import { ComponentNode } from './component-node';
+import { SwitchMap } from './component-platform';
+export declare const traverseComponents: (root: ComponentNode, switches: SwitchMap, fn: (node: ComponentNode) => boolean | void) => void;
+export declare const findVisibleComponents: (root: ComponentNode, switches: SwitchMap) => ComponentNode[];
+export declare const findComponent: (root: ComponentNode, switches: SwitchMap, fn: (node: ComponentNode) => boolean) => ComponentNode | undefined;
+export declare const getAncestors: (node: ComponentNode) => ComponentNode[];

package/lib/component-platform/queries.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAncestors = exports.findComponent = exports.findVisibleComponents = exports.traverseComponents = void 0;
+var traverseComponentsRecursive = function (nodes, switches, fn) {
+    for (var i = 0, y = nodes.length; i < y; i++) {
+        if (fn(nodes[i]) === true) {
+            break;
+        }
+        var branch = switches[nodes[i].id] || 'default';
+        var children = nodes[i].getChildren(branch);
+        traverseComponentsRecursive(children, switches, fn);
+    }
+};
+var traverseComponents = function (root, switches, fn) {
+    if (fn(root) !== true) {
+        var branch = switches[root.id] || 'default';
+        var children = root.children[branch];
+        traverseComponentsRecursive(children, switches, fn);
+    }
+};
+exports.traverseComponents = traverseComponents;
+var findVisibleComponents = function (root, switches) {
+    var nodes = [];
+    (0, exports.traverseComponents)(root, switches, function (node) {
+        nodes.push(node);
+    });
+    return nodes;
+};
+exports.findVisibleComponents = findVisibleComponents;
+var findComponent = function (root, switches, fn) {
+    var matched;
+    (0, exports.traverseComponents)(root, switches, function (node) {
+        if (fn(node)) {
+            matched = node;
+            return true;
+        }
+    });
+    return matched;
+};
+exports.findComponent = findComponent;
+var getAncestors = function (node) {
+    if (!node.parent) {
+        return [];
+    }
+    var tree = [];
+    var currentNode = node.parent;
+    while (currentNode) {
+        tree.unshift(currentNode);
+        currentNode = currentNode.parent;
+    }
+    return tree;
+};
+exports.getAncestors = getAncestors;

package/lib/component-platform/state-processor.d.ts

@@ -0,0 +1,12 @@
+import { ComponentPlatform } from '.';
+import { ComponentNode } from './component-node';
+export declare type ProcessOptions = {
+    context?: boolean;
+    properties?: boolean;
+    layout?: boolean;
+    recursive?: boolean;
+};
+export declare type StateProcessor = (node: ComponentNode, options: ProcessOptions) => void;
+export declare type ProcessResult = Map<ComponentNode, ProcessOptions>;
+export declare type ProcessReportCallback = (report: ProcessResult) => void;
+export declare const createStateProcessor: (platform: ComponentPlatform, callback: ProcessReportCallback) => StateProcessor;

package/lib/component-platform/state-processor.js

@@ -0,0 +1,209 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStateProcessor = void 0;
+var calculateNodeIndex = function (node) {
+    var currentNode = node;
+    var index = 0;
+    while (currentNode.parent) {
+        index = index + 1;
+        currentNode = currentNode.parent;
+    }
+    return index;
+};
+var sortQueue = function (queue) {
+    var mapped = queue.map(function (_a) {
+        var _b = __read(_a, 2), node = _b[0], options = _b[1];
+        return [calculateNodeIndex(node), node, options];
+    });
+    return mapped
+        .sort(function (_a, _b) {
+        var _c = __read(_a, 1), a = _c[0];
+        var _d = __read(_b, 1), b = _d[0];
+        return a - b;
+    })
+        .map(function (_a) {
+        var _b = __read(_a, 3), node = _b[1], options = _b[2];
+        return [node, options];
+    });
+};
+var isObject = function (item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+};
+var mergeDeep = function (target) {
+    var _a, _b;
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    if (!sources.length)
+        return target;
+    var source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (var key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, (_a = {}, _a[key] = {}, _a));
+                mergeDeep(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, (_b = {}, _b[key] = source[key], _b));
+            }
+        }
+    }
+    return mergeDeep.apply(void 0, __spreadArray([target], __read(sources), false));
+};
+var matchesBreakpoint = function (b1, b2) {
+    if (!b1 || b1 === 'all') {
+        return true;
+    }
+    return b1.some(function (b1) { return b2.indexOf(b1) > -1; });
+};
+var createStateProcessor = function (platform, callback) {
+    var nodeQueue = [];
+    var optionsQueue = [];
+    var timeout;
+    var flush = function () {
+        if (process.env.NODE_ENV !== 'production') {
+            console.time('state-processor.flush');
+        }
+        var processHistory = new Map();
+        var sortedQueue = sortQueue(nodeQueue.map(function (node, i) { return [node, optionsQueue[i]]; }));
+        var processNode = function (node, options) {
+            var _a;
+            var history = processHistory.get(node) || {};
+            // todo: this doesnt take overrides into account
+            var processContext = options.context && !history.context;
+            var processProperties = options.properties && !history.properties;
+            var processLayout = options.layout && !history.layout;
+            processHistory.set(node, {
+                context: history.context || processContext,
+                properties: history.properties || processProperties,
+                layout: history.layout || processLayout,
+            });
+            if (processProperties) {
+                node.attributes.properties = {};
+            }
+            if (processLayout) {
+                node.attributes.layout = {};
+            }
+            if (processContext) {
+                node.attributes.context = mergeDeep({}, (_a = node.parent) === null || _a === void 0 ? void 0 : _a.attributes.context);
+            }
+            var propertyResolvers = [];
+            var layoutResolvers = [];
+            var contextResolvers = [];
+            node.changesets.forEach(function (changeset) {
+                var _a = __read(changeset, 2), change = _a[0], options = _a[1];
+                if (matchesBreakpoint(options.breakpoints, platform.breakpoints)) {
+                    if (processProperties) {
+                        if (typeof change.properties === 'function') {
+                            propertyResolvers.push(change.properties);
+                        }
+                        else {
+                            mergeDeep(node.attributes.properties, change.properties);
+                        }
+                    }
+                    if (processLayout) {
+                        if (typeof change.layout === 'function') {
+                            layoutResolvers.push(change.layout);
+                        }
+                        else {
+                            mergeDeep(node.attributes.layout, change.layout);
+                        }
+                    }
+                    if (processContext) {
+                        if (typeof change.context === 'function') {
+                            contextResolvers.push(change.context);
+                        }
+                        else {
+                            mergeDeep(node.attributes.context, change.context);
+                        }
+                    }
+                }
+            });
+            propertyResolvers.forEach(function (resolver) {
+                mergeDeep(node.attributes.properties, resolver(node.attributes.properties));
+            });
+            layoutResolvers.forEach(function (resolver) {
+                mergeDeep(node.attributes.layout, resolver(node.attributes.layout));
+            });
+            contextResolvers.forEach(function (resolver) {
+                mergeDeep(node.attributes.context, resolver(node.attributes.context));
+            });
+            if (processContext || options.recursive) {
+                var branch = platform.getBranch(node);
+                var childOptions_1 = options.recursive
+                    ? options
+                    : {
+                        context: !!processContext,
+                    };
+                node.getChildren(branch).forEach(function (child) {
+                    processNode(child, childOptions_1);
+                });
+            }
+        };
+        if (process.env.NODE_ENV !== 'production') {
+            console.timeEnd('state-processor.flush');
+        }
+        sortedQueue.forEach(function (_a) {
+            var _b = __read(_a, 2), node = _b[0], options = _b[1];
+            processNode(node, options);
+        });
+        nodeQueue = [];
+        optionsQueue = [];
+        callback(processHistory);
+    };
+    var schedule = function () {
+        clearTimeout(timeout);
+        timeout = setTimeout(flush, 0);
+    };
+    return function (node, options) {
+        var index = nodeQueue.indexOf(node);
+        if (index > -1) {
+            // if node already exist in queue, update its options
+            var summary = optionsQueue[index];
+            if (options.context) {
+                summary.context = true;
+            }
+            if (options.properties) {
+                summary.properties = true;
+            }
+            if (options.layout) {
+                summary.layout = true;
+            }
+            if (options.recursive) {
+                summary.recursive = true;
+            }
+            return schedule();
+        }
+        nodeQueue.push(node);
+        optionsQueue.push(options);
+        return schedule();
+    };
+};
+exports.createStateProcessor = createStateProcessor;

package/lib/component-resolver.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from '@telia-ace/widget-utilities';
+import { Container, EventManager, EventSubscriptionCancellation } from '@webprovisions/platform';
+export declare type ReactComponent = any | null;
+export default class ComponentResolver {
+    aliases: Map<string, string>;
+    components: Map<string, any>;
+    events: EventManager;
+    logger: Logger;
+    constructor(container: Container);
+    getComponent(key: string): ReactComponent;
+    registerComponent(key: string, component: ReactComponent): EventSubscriptionCancellation;
+    registerResolver(key: string, fn: (component: ReactComponent) => void): EventSubscriptionCancellation;
+    registerAlias(alias: string, key: string): EventSubscriptionCancellation;
+}

package/lib/component-resolver.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var widget_utilities_1 = require("@telia-ace/widget-utilities");
+var ComponentResolver = /** @class */ (function () {
+    function ComponentResolver(container) {
+        this.aliases = new Map();
+        this.components = new Map();
+        this.logger = new widget_utilities_1.Logger();
+        var events = container.get('$widget').events;
+        this.events = events;
+    }
+    ComponentResolver.prototype.getComponent = function (key) {
+        var alias = this.aliases.get(key);
+        var component = this.components.get(alias || key) || null;
+        if (process.env.NODE_ENV !== 'production') {
+            if (!component) {
+                this.logger.warn(alias || key, "Unable to resolve component: \"".concat(alias || key, "\". You most likely forgot to register the required plugin for: ").concat(alias || key, "."));
+            }
+        }
+        return component;
+    };
+    ComponentResolver.prototype.registerComponent = function (key, component) {
+        var _this = this;
+        this.components.set(key, component);
+        this.events.dispatch('component-resolver:resolve', key);
+        return function () {
+            _this.components.delete(key);
+        };
+    };
+    ComponentResolver.prototype.registerResolver = function (key, fn) {
+        var _this = this;
+        return this.events.subscribe('component-resolver:resolve', function (e, data) {
+            if (data === key) {
+                var component = _this.getComponent(key);
+                fn(component);
+            }
+        });
+    };
+    ComponentResolver.prototype.registerAlias = function (alias, key) {
+        var _this = this;
+        this.aliases.set(alias, key);
+        this.events.dispatch('component-resolver:resolve', alias);
+        return function () {
+            _this.aliases.delete(alias);
+        };
+    };
+    return ComponentResolver;
+}());
+exports.default = ComponentResolver;

package/lib/event-subscriber.d.ts

@@ -0,0 +1,7 @@
+import { EventListener, EventManager, EventSubscriptionCancellation } from '@webprovisions/platform';
+export declare type SubscribeDelegate = (type: string, listener: EventListener) => void;
+/**
+ * Creates s subscriber for the specified `EventManager` and provides a single cancellation
+ * function for all registered subscriptions.
+ */
+export declare const createEventSubscriber: (events: EventManager) => [SubscribeDelegate, EventSubscriptionCancellation];

package/lib/event-subscriber.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventSubscriber = void 0;
+/**
+ * Creates s subscriber for the specified `EventManager` and provides a single cancellation
+ * function for all registered subscriptions.
+ */
+var createEventSubscriber = function (events) {
+    var subs = [];
+    var subscribe = function (type, listener) {
+        subs.push(events.subscribe(type, listener));
+    };
+    return [
+        subscribe,
+        function () {
+            subs.forEach(function (sub) {
+                sub();
+            });
+        },
+    ];
+};
+exports.createEventSubscriber = createEventSubscriber;

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export { default as ActionResolver } from './action-resolver';
+export { ActionsController, asDescriptor, ComponentNode, ComponentNodeController, ComponentPlatform, ComponentQuery, createComponentModel, extendComponent, findComponent, findVisibleComponents, traverseComponents, } from './component-platform';
+export type { ChangesetOptions, ChangesetProvider, ComponentDescriptor, ComponentNodeAttributes, ComponentNodeContext, ComponentNodeLayout, ComponentNodeProperties, ComponentNodeSettings, ComponentQueryRule, ExtendComponentHandler, ExtendComponentOptions, Size, SwitchMap, WatchActionDelegate, } from './component-platform';
+export { default as ComponentResolver } from './component-resolver';
+export type { ReactComponent } from './component-resolver';
+export { createEventSubscriber } from './event-subscriber';
+export type { SubscribeDelegate } from './event-subscriber';
+export * from './types';

package/lib/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventSubscriber = exports.ComponentResolver = exports.traverseComponents = exports.findVisibleComponents = exports.findComponent = exports.extendComponent = exports.createComponentModel = exports.ComponentQuery = exports.ComponentPlatform = exports.ComponentNodeController = exports.ComponentNode = exports.asDescriptor = exports.ActionsController = exports.ActionResolver = void 0;
+var action_resolver_1 = require("./action-resolver");
+Object.defineProperty(exports, "ActionResolver", { enumerable: true, get: function () { return __importDefault(action_resolver_1).default; } });
+var component_platform_1 = require("./component-platform");
+Object.defineProperty(exports, "ActionsController", { enumerable: true, get: function () { return component_platform_1.ActionsController; } });
+Object.defineProperty(exports, "asDescriptor", { enumerable: true, get: function () { return component_platform_1.asDescriptor; } });
+Object.defineProperty(exports, "ComponentNode", { enumerable: true, get: function () { return component_platform_1.ComponentNode; } });
+Object.defineProperty(exports, "ComponentNodeController", { enumerable: true, get: function () { return component_platform_1.ComponentNodeController; } });
+Object.defineProperty(exports, "ComponentPlatform", { enumerable: true, get: function () { return component_platform_1.ComponentPlatform; } });
+Object.defineProperty(exports, "ComponentQuery", { enumerable: true, get: function () { return component_platform_1.ComponentQuery; } });
+Object.defineProperty(exports, "createComponentModel", { enumerable: true, get: function () { return component_platform_1.createComponentModel; } });
+Object.defineProperty(exports, "extendComponent", { enumerable: true, get: function () { return component_platform_1.extendComponent; } });
+Object.defineProperty(exports, "findComponent", { enumerable: true, get: function () { return component_platform_1.findComponent; } });
+Object.defineProperty(exports, "findVisibleComponents", { enumerable: true, get: function () { return component_platform_1.findVisibleComponents; } });
+Object.defineProperty(exports, "traverseComponents", { enumerable: true, get: function () { return component_platform_1.traverseComponents; } });
+var component_resolver_1 = require("./component-resolver");
+Object.defineProperty(exports, "ComponentResolver", { enumerable: true, get: function () { return __importDefault(component_resolver_1).default; } });
+var event_subscriber_1 = require("./event-subscriber");
+Object.defineProperty(exports, "createEventSubscriber", { enumerable: true, get: function () { return event_subscriber_1.createEventSubscriber; } });
+__exportStar(require("./types"), exports);

package/lib/types/configuration.d.ts

@@ -0,0 +1,86 @@
+import { ComponentNodeLayout } from '../component-platform';
+export declare type ComponentSettings = {
+    type: string;
+    context?: Context;
+    properties?: Properties;
+    layout?: ComponentNodeLayout;
+    tags?: string[];
+    children?: ComponentReference[];
+};
+declare enum HistoryMode {
+    scopedHash = "scopedHash",
+    hash = "hash",
+    browser = "browser",
+    memory = "memory"
+}
+export declare type RoutingSettings = {
+    initialPath: string;
+    mode: HistoryMode;
+    basePath?: string;
+};
+export declare type ComponentReference = string | [string, ...ComponentReferenceOverride[]];
+export declare type Properties = {
+    [key: string]: any;
+};
+export declare type Context = {
+    [key: string]: any;
+};
+export declare type ViewDefinition = {
+    path: string | string[];
+    entry: ComponentReference;
+};
+export declare type Breakpoints = 'all' | string[];
+export declare type ComponentReferenceOverride = {
+    breakpoints?: Breakpoints;
+    size?: number | 'full' | 'none';
+    indent?: number;
+    tags?: string[];
+    context?: Context;
+    properties?: Properties;
+};
+export declare type ComponentDefinitionMap = {
+    [name: string]: ComponentSettings;
+};
+export declare type WidgetSettings = {
+    data: {
+        projection: string;
+        site?: 'current' | 'referrer';
+        forceHttps?: boolean;
+    };
+    components: ComponentDefinitionMap;
+    entry: ComponentReference;
+    breakpoints: {
+        [name: string]: string;
+    };
+    routing: RoutingSettings;
+    views: {
+        [name: string]: ViewDefinition;
+    };
+    integrationResources: {
+        path: string;
+        mediaQueriesSupported: boolean;
+    }[];
+    trigger?: {
+        symbol?: Symbol;
+        label?: string;
+        action?: string;
+    };
+    activate?: boolean | null;
+    plugins?: {
+        [key: string]: any;
+    };
+};
+export declare type MinMax = {
+    min: string;
+    max: string;
+};
+declare type Symbol = {
+    type: 'Uri' | 'Svg' | 'FontAwesome' | 'Text' | string;
+    content: string;
+};
+export declare enum WidgetRenderState {
+    open = "open",
+    closed = "closed",
+    hidden = "hidden"
+}
+export {};

package/lib/types/configuration.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetRenderState = void 0;
+var HistoryMode;
+(function (HistoryMode) {
+    HistoryMode["scopedHash"] = "scopedHash";
+    HistoryMode["hash"] = "hash";
+    HistoryMode["browser"] = "browser";
+    HistoryMode["memory"] = "memory";
+})(HistoryMode || (HistoryMode = {}));
+var WidgetRenderState;
+(function (WidgetRenderState) {
+    WidgetRenderState["open"] = "open";
+    WidgetRenderState["closed"] = "closed";
+    WidgetRenderState["hidden"] = "hidden";
+})(WidgetRenderState = exports.WidgetRenderState || (exports.WidgetRenderState = {}));

package/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './configuration';
+export * from './ui';

package/lib/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./configuration"), exports);
+__exportStar(require("./ui"), exports);