@limetech/lime-web-components 5.46.0 → 6.0.0-beta.2

package/dist/commandbus/commandbus.spec.js

@@ -1,55 +0,0 @@
-import { __decorate } from "tslib";
-/* eslint-disable max-classes-per-file */
-import { Command, getCommandIds } from './commandbus';
-var Webclient;
-(function (Webclient) {
-    let TestCommand = class TestCommand {
-    };
-    TestCommand = __decorate([
-        Command({
-            id: 'test',
-        })
-    ], TestCommand);
-    Webclient.TestCommand = TestCommand;
-    let MyTestCommand = class MyTestCommand extends TestCommand {
-    };
-    MyTestCommand = __decorate([
-        Command({
-            id: 'my-test',
-        })
-    ], MyTestCommand);
-    Webclient.MyTestCommand = MyTestCommand;
-})(Webclient || (Webclient = {}));
-var Addon;
-(function (Addon) {
-    let TestCommand = class TestCommand {
-    };
-    TestCommand = __decorate([
-        Command({
-            id: 'test',
-        })
-    ], TestCommand);
-    Addon.TestCommand = TestCommand;
-})(Addon || (Addon = {}));
-test.each([
-    [new Webclient.TestCommand(), ['test']],
-    [new Webclient.MyTestCommand(), ['my-test', 'test']],
-    ['test', ['test']],
-    [null, []],
-])('getCommandIds() with instance %s returns %j', (value, result) => {
-    expect(getCommandIds(value)).toEqual(result);
-});
-test.each([
-    [Webclient.TestCommand, ['test']],
-    [Webclient.MyTestCommand, ['my-test', 'test']],
-])('getCommandIds() with class %p returns %j', (value, result) => {
-    expect(getCommandIds(value)).toEqual(result);
-});
-test('instanceof returns true when class from another namespace has same command ID', () => {
-    const command = new Webclient.TestCommand();
-    expect(command).toBeInstanceOf(Addon.TestCommand);
-});
-test('instanceof returns true when sub-class from another namespace has same command ID', () => {
-    const command = new Webclient.MyTestCommand();
-    expect(command).toBeInstanceOf(Addon.TestCommand);
-});

package/dist/commandbus/index.js

@@ -1,2 +0,0 @@
-export * from './commandbus';
-export * from './types';

package/dist/commandbus/types.js

@@ -1,3 +0,0 @@
-import { PlatformServiceName } from '../core/platform';
-const SERVICE_NAME = 'commandBus';
-PlatformServiceName.CommandBus = SERVICE_NAME;

package/dist/conditionregistry/conditionregistry.js

@@ -1,18 +0,0 @@
-/**
- * Check if condition expects a lime object to be passed when it is evaluated
- *
- * @alpha
- * @group Conditions
- */
-export function isLimeObjectCondition(condition) {
-    return condition.type === 'limeobject';
-}
-/**
- * Check if condition expects an action to be passed when it is evaluated
- *
- * @alpha
- * @group Conditions
- */
-export function isActionCondition(condition) {
-    return condition.type === 'action';
-}

package/dist/conditionregistry/index.js

@@ -1,2 +0,0 @@
-export * from './conditionregistry';
-export * from './types';

package/dist/conditionregistry/types.js

@@ -1,3 +0,0 @@
-import { PlatformServiceName } from '../core/platform';
-const SERVICE_NAME = 'conditionRegistry';
-PlatformServiceName.ConditionRegistry = SERVICE_NAME;

package/dist/config/decorator.js

@@ -1,16 +0,0 @@
-import { PlatformServiceName, } from '../core';
-import { createStateDecorator } from '../core/decorators/factory';
-/**
- * Gets an object with all configs where key is used as key.
- *
- * @param options - state decorator options
- * @returns state decorator
- * @public
- * @group Config
- */
-export function SelectConfig(options) {
-    const config = {
-        name: PlatformServiceName.ConfigRepository,
-    };
-    return createStateDecorator(options, config);
-}

package/dist/config/index.js

@@ -1,3 +0,0 @@
-export * from './repository';
-export * from './types';
-export * from './decorator';

package/dist/config/repository.js

@@ -1 +0,0 @@
-export {};

package/dist/config/types.js

@@ -1,3 +0,0 @@
-import { PlatformServiceName } from '../core/platform';
-const SERVICE_NAME = 'state.configs';
-PlatformServiceName.ConfigRepository = SERVICE_NAME;

package/dist/core/context.js

@@ -1 +0,0 @@
-export {};

package/dist/core/decorators/factory.js

@@ -1,243 +0,0 @@
-import { getElement } from '@stencil/core';
-import { BehaviorSubject } from 'rxjs';
-function defaultOptionFactory(options) {
-    return options;
-}
-/**
- * Create a new state decorator
- *
- * @param options - decorator options
- * @param config - decorator configuration
- * @returns state decorator
- * @public
- */
-export function createStateDecorator(options, config) {
-    return (target, property) => {
-        const properties = getComponentProperties(target, property, options, config);
-        if (properties.length === 1) {
-            extendLifecycleMethods(target, properties);
-        }
-    };
-}
-const componentProperties = new WeakMap();
-const componentSubscriptions = new WeakMap();
-const connectedComponents = new WeakMap();
-/**
- * Get properties data for a component
- *
- * @param component - the component class containing the decorator
- * @param property - name of the property
- * @param options - decorator options
- * @param config - decorator configuration
- * @returns properties data for the component
- */
-function getComponentProperties(component, property, options, config) {
-    let properties = componentProperties.get(component);
-    if (!properties) {
-        properties = [];
-        componentProperties.set(component, properties);
-    }
-    properties.push({
-        options: options,
-        name: property,
-        optionFactory: config.optionFactory || defaultOptionFactory,
-        service: {
-            name: config.name,
-            method: config.method || 'subscribe',
-        },
-    });
-    return properties;
-}
-/**
- * Extend the lifecycle methods on the component
- *
- * @param component - the component to extend
- * @param properties - the properties with which to extend the component
- * @returns
- */
-function extendLifecycleMethods(component, properties) {
-    // `componentWillLoad` and `componentDidUnload` is included for backwards
-    // compatibility reasons. The correct way to setup the subscriptions is in
-    // `connectedCallback` and `disconnectedCallback`, but since not all
-    // plugins might implement those methods yet we still have include them
-    // until we make `connectedCallback` and `disconnectedCallback` required
-    // on the interface.
-    component.connectedCallback = createConnectedCallback(component.connectedCallback, properties);
-    component.componentWillLoad = createComponentWillLoad(component.componentWillLoad, properties);
-    component.componentDidUnload = createDisconnectedCallback(component.componentDidUnload);
-    component.disconnectedCallback = createDisconnectedCallback(component.disconnectedCallback);
-}
-function createConnectedCallback(original, properties) {
-    return async function (...args) {
-        connectedComponents.set(this, true);
-        componentSubscriptions.set(this, []);
-        await ensureLimeProps(this);
-        const observable = new BehaviorSubject(this.context);
-        watchProp(this, 'context', observable);
-        properties.forEach((property) => {
-            property.options = property.optionFactory(property.options, this);
-            if (isContextAware(property.options)) {
-                property.options.context = observable;
-            }
-            subscribe(this, property);
-        });
-        if (original) {
-            return original.apply(this, args);
-        }
-    };
-}
-function createComponentWillLoad(original, properties) {
-    return async function (...args) {
-        if (connectedComponents.get(this) === true) {
-            await ensureLimeProps(this);
-            if (original) {
-                return original.apply(this, args);
-            }
-            return;
-        }
-        const connectedCallback = createConnectedCallback(original, properties);
-        return connectedCallback.apply(this, args);
-    };
-}
-function createDisconnectedCallback(original) {
-    return async function (...args) {
-        let result;
-        if (original) {
-            result = original.apply(this, args);
-        }
-        unsubscribeAll(this);
-        return result;
-    };
-}
-/**
- * Check if the options are context aware
- *
- * @param options - state decorator options
- * @returns true if the options are context aware
- */
-function isContextAware(options) {
-    return 'context' in options;
-}
-/**
- * Make sure that all required lime properties are set on the web component
- *
- * @param target - the web component
- * @returns a promise that resolves when all properties are defined
- */
-function ensureLimeProps(target) {
-    const promises = [];
-    if (!target.platform) {
-        promises.push(waitForProp(target, 'platform'));
-    }
-    if (!target.context) {
-        promises.push(waitForProp(target, 'context'));
-    }
-    if (!promises.length) {
-        return Promise.resolve();
-    }
-    return Promise.all(promises);
-}
-/**
- * Wait for a property to be defined on an object
- *
- * @param target - the web component
- * @param property - the name of the property to watch
- * @returns a promise that will resolve when the property is set on the object
- */
-function waitForProp(target, property) {
-    const element = getElement(target);
-    return new Promise((resolve) => {
-        Object.defineProperty(element, property, {
-            configurable: true,
-            set: (value) => {
-                delete element[property];
-                element[property] = value;
-                resolve();
-            },
-        });
-    });
-}
-function watchProp(target, property, observer) {
-    const element = getElement(target);
-    const { get, set } = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(element), property);
-    Object.defineProperty(element, property, {
-        configurable: true,
-        get: get,
-        set: function (value) {
-            set.call(this, value);
-            observer.next(value);
-        },
-    });
-}
-/**
- * Subscribe to changes from the state
- *
- * @param component - the component instance
- * @param property - property to update when subscription triggers
- * @returns
- */
-function subscribe(component, property) {
-    const subscription = createSubscription(component, property);
-    if (typeof subscription !== 'function') {
-        return;
-    }
-    const subscriptions = componentSubscriptions.get(component);
-    subscriptions.push(subscription);
-}
-/**
- * Unsubscribe to changes from the state
- *
- * @param component - the instance of the component
- * @returns
- */
-function unsubscribeAll(component) {
-    const subscriptions = componentSubscriptions.get(component);
-    subscriptions.forEach((unsubscribe) => unsubscribe());
-    componentSubscriptions.set(component, []);
-}
-/**
- * Get a function that accepts a state, and updates the given property
- * on the given component with that state
- *
- * @param instance - the component to augment
- * @param property - name of the property on the component
- * @returns updates the state
- */
-function mapState(instance, property) {
-    return (state) => {
-        instance[property] = state;
-    };
-}
-/**
- * Create a state subscription
- *
- * @param component - the component instance
- * @param property - the property on the component
- * @returns unsubscribe function
- */
-function createSubscription(component, property) {
-    const myOptions = Object.assign({}, property.options);
-    bindFunctions(myOptions, component);
-    const name = property.service.name;
-    const platform = component.platform;
-    if (!platform.has(name)) {
-        throw new Error(`Service ${name} does not exist`);
-    }
-    const service = platform.get(name);
-    return service[property.service.method](mapState(component, property.name), myOptions);
-}
-/**
- * Bind connect functions to the current scope
- *
- * @param options - options for the selector
- * @param scope - the current scope to bind to
- * @returns
- */
-function bindFunctions(options, scope) {
-    if (options.filter) {
-        options.filter = options.filter.map((func) => func.bind(scope));
-    }
-    if (options.map) {
-        options.map = options.map.map((func) => func.bind(scope));
-    }
-}