@startinblox/core 0.17.21-beta.1 → 0.17.21-beta.10

package/dist/components/solid-widget.js

@@ -0,0 +1,94 @@
+function _templateObject() {
+  const data = _taggedTemplateLiteral(["", ""]);
+
+  _templateObject = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+import { Sib } from '../libs/Sib.js';
+import { StoreMixin } from '../mixins/storeMixin.js';
+import { BaseWidgetMixin } from '../new-widgets/baseWidgetMixin.js';
+import { FormMixin } from '../new-widgets/templatesDependencies/formMixin.js';
+import { ActionMixin } from '../new-widgets/attributeMixins/actionMixin.js';
+import { evalTemplateString } from '../libs/helpers.js';
+import { html, render } from '../_snowpack/pkg/lit-html.js';
+import { unsafeHTML } from '../_snowpack/pkg/lit-html/directives/unsafe-html.js';
+export const SolidWidget = {
+  name: 'solid-widget',
+  use: [],
+  attributes: {
+    name: {
+      type: String,
+      default: "",
+      required: true
+    }
+  },
+
+  attached() {
+    if (!this.name) return;
+    const template = this.template;
+    const newWidget = {
+      name: this.name,
+      use: [BaseWidgetMixin, StoreMixin, FormMixin, ActionMixin],
+      attributes: {
+        label: {
+          type: String,
+          default: '',
+          callback: function (newValue) {
+            this.addToAttributes(newValue, 'label');
+          }
+        }
+      },
+
+      get template() {
+        return () => this.evalTemplate(template).then(tpl => html(_templateObject(), unsafeHTML(tpl)));
+      },
+
+      evalTemplate(template) {
+        const tpl = evalTemplateString(template, {
+          name: this.name,
+          value: this.value || this.resource || '',
+          src: this.src,
+          label: this.label
+        });
+        return tpl;
+      },
+
+      async templateToDOM(template) {
+        render(await template, this.element);
+      },
+
+      // For form widgets, handle nested solid-form
+      getValueFromElement(element) {
+        if (element.tagName === "SOLID-FORM") return element.component.value; // nested solid-form
+        else if (element.component) return element.component.getValue(); // form widget
+
+        return element.value; // input
+      },
+
+      updateDOM() {
+        // override StoreMixin method to launch render when resource fetched
+        this.planRender();
+      }
+
+    };
+    Sib.register(newWidget); // and register component
+  },
+
+  get template() {
+    return this.element.querySelector('template:not([data-range])').innerHTML;
+  },
+
+  get childTemplate() {
+    const child = this.element.querySelector('template[data-range]');
+    return child ? child.innerHTML : null;
+  }
+
+};
+Sib.register(SolidWidget);
+//# sourceMappingURL=solid-widget.js.map

package/dist/components/solid-widget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["solid-widget.ts"],"names":["Sib","StoreMixin","BaseWidgetMixin","FormMixin","ActionMixin","evalTemplateString","html","render","unsafeHTML","SolidWidget","name","use","attributes","type","String","default","required","attached","template","newWidget","label","callback","newValue","addToAttributes","evalTemplate","then","tpl","value","resource","src","templateToDOM","element","getValueFromElement","tagName","component","getValue","updateDOM","planRender","register","querySelector","innerHTML","childTemplate","child"],"mappings":"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","sourcesContent":["import { Sib } from '../libs/Sib';\nimport { StoreMixin } from '../mixins/storeMixin';\nimport { BaseWidgetMixin } from '../new-widgets/baseWidgetMixin';\nimport { FormMixin } from '../new-widgets/templatesDependencies/formMixin';\nimport { ActionMixin } from '../new-widgets/attributeMixins/actionMixin';\nimport { evalTemplateString } from '../libs/helpers';\nimport { html, render } from 'lit-html';\nimport { unsafeHTML } from 'lit-html/directives/unsafe-html';\n\nexport const SolidWidget = {\n  name: 'solid-widget',\n  use: [],\n  attributes: {\n    name: {\n      type: String,\n      default: \"\",\n      required: true\n    }\n  },\n  attached(): void {\n    if (!this.name) return;\n    const template = this.template;\n    const newWidget = {\n      name: this.name,\n      use: [\n        BaseWidgetMixin,\n        StoreMixin,\n        FormMixin,\n        ActionMixin\n      ],\n      attributes: {\n        label: {\n          type: String,\n          default: '',\n          callback: function (newValue: string) {\n            this.addToAttributes(newValue, 'label');\n          }\n        },\n      },\n      get template() {\n        return () => this.evalTemplate(template).then((tpl: string) => html`${unsafeHTML(tpl)}`)\n      },\n      evalTemplate(template: string) {\n        const tpl =  evalTemplateString(template, {\n          name: this.name,\n          value: this.value || this.resource || '',\n          src: this.src,\n          label: this.label,\n        });\n        return tpl;\n      },\n      async templateToDOM(template) {\n        render(await template, this.element);\n      },\n      // For form widgets, handle nested solid-form\n      getValueFromElement(element: any) {\n        if (element.tagName === \"SOLID-FORM\") return element.component.value; // nested solid-form\n        else if (element.component) return element.component.getValue(); // form widget\n        return element.value; // input\n      },\n      updateDOM() { // override StoreMixin method to launch render when resource fetched\n        this.planRender();\n      }\n    };\n\n    Sib.register(newWidget); // and register component\n  },\n  get template() {\n    return this.element.querySelector('template:not([data-range])').innerHTML;\n  },\n  get childTemplate(): string | null {\n    const child = this.element.querySelector('template[data-range]');\n    return child ? child.innerHTML : null;\n  }\n};\n\nSib.register(SolidWidget);"]}

package/dist/import.css

@@ -0,0 +1,4 @@
+/* @ import 'slim-select/dist/slimselect.css'; */
+@import "./_snowpack/pkg/leaflet/dist/leaflet.css";
+@import "./_snowpack/pkg/quill/dist/quill.snow.css";
+@import "./_snowpack/pkg/tui-calendar/dist/tui-calendar.css";

package/dist/index.js

@@ -0,0 +1,43 @@
+import "./libs/polyfills.js"; // Components
+
+import { SolidDisplay } from './components/solid-display.js';
+import { SolidForm } from './components/solid-form.js';
+import { SolidFormSearch } from './components/solid-form-search.js';
+import { SolidWidget } from './components/solid-widget.js';
+import { SolidAcChecker } from './components/solid-ac-checker.js';
+import { SolidDelete } from './components/solid-delete.js';
+import { SolidLang } from './components/solid-lang.js';
+import { SolidTable } from './components/solid-table.js';
+import { SolidMap } from './components/solid-map.js'; // Mixins
+
+import { CounterMixin } from './mixins/counterMixin.js';
+import { FederationMixin } from './mixins/federationMixin.js';
+import { FilterMixin } from './mixins/filterMixin.js';
+import { GrouperMixin } from './mixins/grouperMixin.js';
+import { HighlighterMixin } from './mixins/highlighterMixin.js';
+import { ListMixin } from './mixins/listMixin.js';
+import { NextMixin } from './mixins/nextMixin.js';
+import { PaginateMixin } from './mixins/paginateMixin.js';
+import { RequiredMixin } from './mixins/requiredMixin.js';
+import { SorterMixin } from './mixins/sorterMixin.js';
+import { StoreMixin } from './mixins/storeMixin.js';
+import { TranslationMixin } from './mixins/translationMixin.js';
+import { ValidationMixin } from './mixins/validationMixin.js';
+import { WidgetMixin } from './mixins/widgetMixin.js'; // Libs
+
+import { store } from './libs/store/store.js';
+import { Sib } from './libs/Sib.js';
+import SolidTemplateElement from './solid-template-element.js';
+import { widgetFactory } from './widgets/widget-factory.js';
+import * as Helpers from './libs/helpers.js'; // lit-html
+
+import { html, render } from './_snowpack/pkg/lit-html.js';
+import { ifDefined } from './_snowpack/pkg/lit-html/directives/if-defined.js';
+import { until } from './_snowpack/pkg/lit-html/directives/until.js';
+import { unsafeHTML } from './_snowpack/pkg/lit-html/directives/unsafe-html.js';
+export { // Components
+SolidDisplay, SolidForm, SolidFormSearch, SolidWidget, SolidAcChecker, SolidDelete, SolidLang, SolidTable, SolidMap // Mixins
+, CounterMixin, FederationMixin, FilterMixin, GrouperMixin, HighlighterMixin, ListMixin, NextMixin, PaginateMixin, RequiredMixin, SorterMixin, StoreMixin, TranslationMixin, ValidationMixin, WidgetMixin // Libs
+, store, Sib, SolidTemplateElement, widgetFactory, Helpers // lit-html
+, html, render, ifDefined, until, unsafeHTML };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"names":["SolidDisplay","SolidForm","SolidFormSearch","SolidWidget","SolidAcChecker","SolidDelete","SolidLang","SolidTable","SolidMap","CounterMixin","FederationMixin","FilterMixin","GrouperMixin","HighlighterMixin","ListMixin","NextMixin","PaginateMixin","RequiredMixin","SorterMixin","StoreMixin","TranslationMixin","ValidationMixin","WidgetMixin","store","Sib","SolidTemplateElement","widgetFactory","Helpers","html","render","ifDefined","until","unsafeHTML"],"mappings":"AAAA,OAAO,qBAAP,C,CACA;;AACA,SAASA,YAAT,QAA6B,4BAA7B;AACA,SAASC,SAAT,QAA0B,yBAA1B;AACA,SAASC,eAAT,QAAgC,gCAAhC;AACA,SAASC,WAAT,QAA4B,2BAA5B;AACA,SAASC,cAAT,QAA+B,+BAA/B;AACA,SAASC,WAAT,QAA4B,2BAA5B;AACA,SAASC,SAAT,QAA0B,yBAA1B;AACA,SAASC,UAAT,QAA2B,0BAA3B;AACA,SAASC,QAAT,QAAyB,wBAAzB,C,CAEA;;AACA,SAASC,YAAT,QAA6B,uBAA7B;AACA,SAASC,eAAT,QAAgC,0BAAhC;AACA,SAASC,WAAT,QAA4B,sBAA5B;AACA,SAASC,YAAT,QAA6B,uBAA7B;AACA,SAASC,gBAAT,QAAiC,2BAAjC;AACA,SAASC,SAAT,QAA0B,oBAA1B;AACA,SAASC,SAAT,QAA0B,oBAA1B;AACA,SAASC,aAAT,QAA8B,wBAA9B;AACA,SAASC,aAAT,QAA8B,wBAA9B;AACA,SAASC,WAAT,QAA4B,sBAA5B;AACA,SAASC,UAAT,QAA2B,qBAA3B;AACA,SAASC,gBAAT,QAAiC,2BAAjC;AACA,SAASC,eAAT,QAAgC,0BAAhC;AACA,SAASC,WAAT,QAA4B,sBAA5B,C,CAEA;;AACA,SAASC,KAAT,QAAsB,oBAAtB;AACA,SAASC,GAAT,QAAoB,YAApB;AACA,OAAOC,oBAAP,MAAiC,0BAAjC;AACA,SAASC,aAAT,QAA8B,0BAA9B;AACA,OAAO,KAAKC,OAAZ,MAAyB,gBAAzB,C,CAEA;;AACA,SAASC,IAAT,EAAeC,MAAf,QAA6B,UAA7B;AACA,SAASC,SAAT,QAA0B,gCAA1B;AACA,SAASC,KAAT,QAAsB,2BAAtB;AACA,SAASC,UAAT,QAA2B,iCAA3B;AAEA,SACE;AACAhC,YAFF,EAGEC,SAHF,EAIEC,eAJF,EAKEC,WALF,EAMEC,cANF,EAOEC,WAPF,EAQEC,SARF,EASEC,UATF,EAUEC,QAVF,CAYE;AAZF,EAaEC,YAbF,EAcEC,eAdF,EAeEC,WAfF,EAgBEC,YAhBF,EAiBEC,gBAjBF,EAkBEC,SAlBF,EAmBEC,SAnBF,EAoBEC,aApBF,EAqBEC,aArBF,EAsBEC,WAtBF,EAuBEC,UAvBF,EAwBEC,gBAxBF,EAyBEC,eAzBF,EA0BEC,WA1BF,CA4BE;AA5BF,EA6BEC,KA7BF,EA8BEC,GA9BF,EA+BEC,oBA/BF,EAgCEC,aAhCF,EAiCEC,OAjCF,CAmCE;AAnCF,EAoCEC,IApCF,EAqCEC,MArCF,EAsCEC,SAtCF,EAuCEC,KAvCF,EAwCEC,UAxCF","sourcesContent":["import \"./libs/polyfills.js\";\n// Components\nimport { SolidDisplay } from './components/solid-display';\nimport { SolidForm } from './components/solid-form';\nimport { SolidFormSearch } from './components/solid-form-search';\nimport { SolidWidget } from './components/solid-widget';\nimport { SolidAcChecker } from './components/solid-ac-checker';\nimport { SolidDelete } from './components/solid-delete';\nimport { SolidLang } from './components/solid-lang';\nimport { SolidTable } from './components/solid-table';\nimport { SolidMap } from './components/solid-map';\n\n// Mixins\nimport { CounterMixin } from './mixins/counterMixin';\nimport { FederationMixin } from './mixins/federationMixin';\nimport { FilterMixin } from './mixins/filterMixin';\nimport { GrouperMixin } from './mixins/grouperMixin';\nimport { HighlighterMixin } from './mixins/highlighterMixin';\nimport { ListMixin } from './mixins/listMixin';\nimport { NextMixin } from './mixins/nextMixin';\nimport { PaginateMixin } from './mixins/paginateMixin';\nimport { RequiredMixin } from './mixins/requiredMixin';\nimport { SorterMixin } from './mixins/sorterMixin';\nimport { StoreMixin } from './mixins/storeMixin';\nimport { TranslationMixin } from './mixins/translationMixin';\nimport { ValidationMixin } from './mixins/validationMixin';\nimport { WidgetMixin } from './mixins/widgetMixin';\n\n// Libs\nimport { store } from './libs/store/store';\nimport { Sib } from './libs/Sib';\nimport SolidTemplateElement from './solid-template-element';\nimport { widgetFactory } from './widgets/widget-factory';\nimport * as Helpers from './libs/helpers';\n\n// lit-html\nimport { html, render } from 'lit-html';\nimport { ifDefined } from 'lit-html/directives/if-defined';\nimport { until } from 'lit-html/directives/until';\nimport { unsafeHTML } from 'lit-html/directives/unsafe-html';\n\nexport {\n  // Components\n  SolidDisplay,\n  SolidForm,\n  SolidFormSearch,\n  SolidWidget,\n  SolidAcChecker,\n  SolidDelete,\n  SolidLang,\n  SolidTable,\n  SolidMap,\n\n  // Mixins\n  CounterMixin,\n  FederationMixin,\n  FilterMixin,\n  GrouperMixin,\n  HighlighterMixin,\n  ListMixin,\n  NextMixin,\n  PaginateMixin,\n  RequiredMixin,\n  SorterMixin,\n  StoreMixin,\n  TranslationMixin,\n  ValidationMixin,\n  WidgetMixin,\n\n  // Libs\n  store,\n  Sib,\n  SolidTemplateElement,\n  widgetFactory,\n  Helpers,\n\n  // lit-html\n  html,\n  render,\n  ifDefined,\n  until,\n  unsafeHTML\n}"]}

package/dist/libs/Component.js

@@ -0,0 +1,19 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+export class Component {
+  constructor(element) {
+    _defineProperty(this, "element", void 0);
+
+    this.element = element;
+  }
+
+  created() {}
+
+  attached() {}
+
+  detached() {}
+
+  attributesCallback(_key, _value, _oldValue) {}
+
+}
+//# sourceMappingURL=Component.js.map

package/dist/libs/Component.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Component.ts"],"names":["Component","constructor","element","created","attached","detached","attributesCallback","_key","_value","_oldValue"],"mappings":";;AAEA,OAAO,MAAeA,SAAf,CAAuD;AAG5DC,EAAAA,WAAW,CAACC,OAAD,EAAuB;AAAA;;AAChC,SAAKA,OAAL,GAAeA,OAAf;AACD;;AAEDC,EAAAA,OAAO,GAAG,CAAE;;AACZC,EAAAA,QAAQ,GAAG,CAAE;;AACbC,EAAAA,QAAQ,GAAG,CAAE;;AAEbC,EAAAA,kBAAkB,CAACC,IAAD,EAAeC,MAAf,EAA4BC,SAA5B,EAAiD,CAAE;;AAXT","sourcesContent":["import type { ComponentInterface } from \"./interfaces.js\";\n\nexport abstract class Component implements ComponentInterface {\n  public element: HTMLElement;\n\n  constructor(element: HTMLElement) {\n    this.element = element;\n  }\n\n  created() {}\n  attached() {}\n  detached() {}\n\n  attributesCallback(_key: string, _value: any, _oldValue: any):void {}\n}\n"]}

package/dist/libs/ComponentFactory.js

@@ -0,0 +1,196 @@
+import { Compositor } from './Compositor.js';
+import { Component } from './Component.js';
+export class ComponentFactory {
+  static build(component) {
+    const {
+      initialState,
+      attributes,
+      methods,
+      hooks,
+      accessors,
+      name
+    } = Compositor.merge(component, Compositor.mergeMixin(component));
+    let componentConstructor = class extends Component {};
+    componentConstructor = ComponentFactory.bindInitialState(componentConstructor, initialState);
+    componentConstructor = ComponentFactory.bindAttributes(componentConstructor, attributes);
+    componentConstructor = ComponentFactory.bindMethods(componentConstructor, methods);
+    componentConstructor = ComponentFactory.bindAccessors(componentConstructor, accessors);
+    componentConstructor = ComponentFactory.bindHooks(componentConstructor, hooks);
+    Reflect.defineProperty(componentConstructor, 'name', {
+      value: name
+    });
+    return componentConstructor;
+  }
+
+  static bindInitialState(componentConstructor, initialState) {
+    if (initialState) {
+      Reflect.ownKeys(initialState).forEach(key => {
+        Reflect.defineProperty(componentConstructor.prototype, key, {
+          enumerable: true,
+          writable: true,
+          value: initialState[key]
+        });
+      });
+    }
+
+    return componentConstructor;
+  }
+
+  static bindAttributes(componentConstructor, attributes) {
+    if (attributes) {
+      const attributesList = Reflect.ownKeys(attributes).map(key => String(key));
+      const attributesCallback = {};
+      attributesList.forEach(key => {
+        const {
+          default: def,
+          type,
+          required,
+          callback
+        } = attributes[key];
+        let fromType;
+        let toType;
+
+        switch (type) {
+          case String:
+            fromType = value => String(value);
+
+            toType = value => value;
+
+            break;
+
+          case Object:
+            fromType = value => JSON.parse(value);
+
+            toType = value => JSON.stringify(value);
+
+            break;
+
+          case Number:
+            fromType = value => Number(value);
+
+            toType = value => Number(value).toString();
+
+            break;
+
+          case Boolean:
+            fromType = value => Boolean(value);
+
+            toType = value => value;
+
+            break;
+
+          default:
+            fromType = value => value;
+
+            toType = value => value;
+
+            break;
+        }
+
+        const attribute = key.replace(/([a-z0-9])([A-Z0-9])/g, '$1-$2').toLowerCase();
+        Reflect.defineProperty(componentConstructor.prototype, key, {
+          enumerable: true,
+          configurable: false,
+          get: function () {
+            const element = this.element;
+
+            if (!element.hasAttribute(attribute)) {
+              if (required && type !== Boolean) {
+                throw new Error("Attribute ".concat(key, " is required"));
+              }
+
+              return def;
+            }
+
+            return fromType(element.getAttribute(attribute));
+          },
+          set: function (value) {
+            const element = this.element;
+
+            if (type === Boolean) {
+              if (!value) {
+                element.removeAttribute(attribute);
+              } else {
+                element.setAttribute(attribute, '');
+              }
+            } else {
+              element.setAttribute(attribute, toType(value));
+            }
+          }
+        });
+
+        if (callback && typeof callback === 'function') {
+          attributesCallback[key] = callback;
+        }
+      });
+      Reflect.defineProperty(componentConstructor, 'observedAttributes', {
+        get: () => attributesList.map(attr => attr.replace(/([a-z0-9])([A-Z0-9])/g, '$1-$2').toLowerCase())
+      });
+      Reflect.defineProperty(componentConstructor.prototype, 'attributesCallback', {
+        value: function (key, newValue, oldValue) {
+          if (key in attributesCallback) {
+            Reflect.apply(attributesCallback[key], this, [newValue, oldValue]);
+          }
+        }
+      });
+      Reflect.defineProperty(componentConstructor.prototype, 'attributesCallback', attributesCallback);
+    }
+
+    return componentConstructor;
+  }
+
+  static bindAccessors(componentConstructor, accessors) {
+    if (accessors) {
+      Object.keys(accessors).forEach(property => {
+        Reflect.defineProperty(componentConstructor.prototype, property, {
+          get: function () {
+            return Reflect.apply(accessors[property].get, this, []);
+          },
+          set: function (value) {
+            return Reflect.apply(accessors[property].set, this, [value]);
+          }
+        });
+      });
+    }
+
+    return componentConstructor;
+  }
+
+  static bindMethods(componentConstructor, methods) {
+    methods.forEach((method, methodName) => {
+      Reflect.defineProperty(componentConstructor.prototype, methodName, {
+        value: function (...args) {
+          return Reflect.apply(method, this, args);
+        }
+      });
+    });
+    return componentConstructor;
+  }
+
+  static bindHooks(componentConstructor, hooks) {
+    Reflect.defineProperty(componentConstructor.prototype, 'created', {
+      value: function () {
+        hooks.created.forEach(hook => {
+          Reflect.apply(hook, this, []);
+        });
+      }
+    });
+    Reflect.defineProperty(componentConstructor.prototype, 'attached', {
+      value: function () {
+        hooks.attached.forEach(hook => {
+          Reflect.apply(hook, this, []);
+        });
+      }
+    });
+    Reflect.defineProperty(componentConstructor.prototype, 'detached', {
+      value: function () {
+        hooks.detached.forEach(hook => {
+          Reflect.apply(hook, this, []);
+        });
+      }
+    });
+    return componentConstructor;
+  }
+
+}
+//# sourceMappingURL=ComponentFactory.js.map

package/dist/libs/ComponentFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ComponentFactory.ts"],"names":["Compositor","Component","ComponentFactory","build","component","initialState","attributes","methods","hooks","accessors","name","merge","mergeMixin","componentConstructor","bindInitialState","bindAttributes","bindMethods","bindAccessors","bindHooks","Reflect","defineProperty","value","ownKeys","forEach","key","prototype","enumerable","writable","attributesList","map","String","attributesCallback","default","def","type","required","callback","fromType","toType","Object","JSON","parse","stringify","Number","toString","Boolean","attribute","replace","toLowerCase","configurable","get","element","hasAttribute","Error","getAttribute","set","removeAttribute","setAttribute","attr","newValue","oldValue","apply","keys","property","method","methodName","args","created","hook","attached","detached"],"mappings":"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","sourcesContent":["import { Compositor } from './Compositor';\nimport { Component } from './Component';\nimport type {\n  MixinStaticInterface,\n  AttributesDefinitionInterface,\n  ComponentConstructorInterface,\n  ArrayOfHooksInterface,\n  AccessorStaticInterface\n} from './interfaces';\n\nexport class ComponentFactory {\n  public static build(component: MixinStaticInterface): ComponentConstructorInterface {\n    const { initialState, attributes, methods, hooks, accessors, name } = Compositor.merge(component, Compositor.mergeMixin(component));\n\n    let componentConstructor = class extends Component {};\n\n    componentConstructor = ComponentFactory.bindInitialState(componentConstructor, initialState);\n    componentConstructor = ComponentFactory.bindAttributes(componentConstructor, attributes);\n    componentConstructor = ComponentFactory.bindMethods(componentConstructor, methods);\n    componentConstructor = ComponentFactory.bindAccessors(componentConstructor, accessors);\n    componentConstructor = ComponentFactory.bindHooks(componentConstructor, hooks);\n\n    Reflect.defineProperty(componentConstructor, 'name', {\n      value: name,\n    });\n\n    return componentConstructor;\n  }\n\n  protected static bindInitialState(componentConstructor: ComponentConstructorInterface, initialState: object | undefined):any {\n    if (initialState) {\n      Reflect.ownKeys(initialState).forEach(key => {\n        Reflect.defineProperty(componentConstructor.prototype, key, {\n          enumerable: true,\n          writable: true,\n          value: initialState[key],\n        });\n      });\n    }\n\n    return componentConstructor;\n  }\n\n  protected static bindAttributes(componentConstructor: ComponentConstructorInterface, attributes: AttributesDefinitionInterface | undefined): ComponentConstructorInterface {\n    if (attributes) {\n      const attributesList = Reflect.ownKeys(attributes).map(key => String(key));\n      const attributesCallback = {};\n\n      attributesList.forEach(key => {\n        const { default: def, type, required, callback } = attributes[key];\n\n        let fromType;\n        let toType;\n\n        switch (type) {\n          case String:\n            fromType = value => String(value);\n            toType = value => value;\n            break;\n          case Object:\n            fromType = value => JSON.parse(value);\n            toType = value => JSON.stringify(value);\n            break;\n          case Number:\n            fromType = value => Number(value);\n            toType = value => Number(value).toString();\n            break;\n          case Boolean:\n            fromType = value => Boolean(value);\n            toType = value => value;\n            break;\n          default:\n            fromType = value => value;\n            toType = value => value;\n            break;\n        }\n\n        const attribute = key.replace(/([a-z0-9])([A-Z0-9])/g, '$1-$2').toLowerCase();\n\n        Reflect.defineProperty(componentConstructor.prototype, key, {\n          enumerable: true,\n          configurable: false,\n          get: function () {\n            const element = this.element;\n            if (!element.hasAttribute(attribute)) {\n              if (required && type !== Boolean) {\n                throw new Error(`Attribute ${key} is required`);\n              }\n              return def;\n            }\n            return fromType(element.getAttribute(attribute));\n          },\n          set: function (value) {\n            const element = this.element;\n            if (type === Boolean) {\n              if (!value) {\n                element.removeAttribute(attribute);\n              } else {\n                element.setAttribute(attribute, '');\n              }\n            } else {\n              element.setAttribute(attribute, toType(value));\n            }\n          },\n        });\n\n        if (callback && typeof callback === 'function') {\n          attributesCallback[key] = callback;\n        }\n      });\n\n      Reflect.defineProperty(componentConstructor, 'observedAttributes', {\n        get: () => attributesList.map(attr => attr.replace(/([a-z0-9])([A-Z0-9])/g, '$1-$2').toLowerCase()),\n      });\n\n      Reflect.defineProperty(componentConstructor.prototype, 'attributesCallback', {\n        value: function(key, newValue, oldValue) {\n          if (key in attributesCallback) {\n            Reflect.apply(attributesCallback[key], this, [newValue, oldValue]);\n          }\n        }\n      });\n\n      Reflect.defineProperty(componentConstructor.prototype, 'attributesCallback', attributesCallback);\n    }\n    return componentConstructor;\n  }\n\n  protected static bindAccessors(componentConstructor: ComponentConstructorInterface, accessors: AccessorStaticInterface): ComponentConstructorInterface {\n    if (accessors) {\n      Object.keys(accessors).forEach(property => {\n        Reflect.defineProperty(componentConstructor.prototype, property, {\n          get: function () {\n            return Reflect.apply(accessors[property].get, this, [])\n          },\n          set: function (value) {\n            return Reflect.apply(accessors[property].set, this, [value])\n          }\n        });\n      });\n    }\n    return componentConstructor;\n  }\n\n  protected static bindMethods(componentConstructor: ComponentConstructorInterface, methods: Map<string, Function>): ComponentConstructorInterface {\n    methods.forEach((method, methodName: string) => {\n      Reflect.defineProperty(componentConstructor.prototype, methodName, {\n        value: function (...args) {\n          return Reflect.apply(method, this, args);\n        },\n      });\n    });\n    return componentConstructor;\n  }\n\n  protected static bindHooks(componentConstructor: ComponentConstructorInterface, hooks: ArrayOfHooksInterface): ComponentConstructorInterface {\n    Reflect.defineProperty(componentConstructor.prototype, 'created', {\n      value: function() {\n        hooks.created.forEach(hook => {\n          Reflect.apply(hook, this, []);\n        });\n      },\n    });\n\n    Reflect.defineProperty(componentConstructor.prototype, 'attached', {\n      value: function() {\n        hooks.attached.forEach(hook => {\n          Reflect.apply(hook, this, []);\n        });\n      },\n    });\n\n    Reflect.defineProperty(componentConstructor.prototype, 'detached', {\n      value: function() {\n        hooks.detached.forEach(hook => {\n          Reflect.apply(hook, this, []);\n        });\n      },\n    });\n    return componentConstructor;\n  }\n}\n"]}

package/dist/libs/Compositor.js

@@ -0,0 +1,103 @@
+const HOOKS = ['created', 'attached', 'detached'];
+const API = ['name', 'use', 'attributes', 'initialState', ...HOOKS];
+export class Compositor {
+  static merge(component, mixins) {
+    return {
+      name: component.name,
+      attributes: Compositor.mergeAttributes([component, ...mixins]),
+      initialState: Compositor.mergeInitialState([component, ...mixins]),
+      methods: Compositor.mergeMethods([component, ...mixins]),
+      accessors: Compositor.mergeAccessors([component, ...mixins]),
+      hooks: Compositor.mergeHooks([component, ...mixins])
+    };
+  }
+
+  static mergeMixin(component) {
+    function deepMergeMixin(mixinAccumulator, currentMixin) {
+      const {
+        use: currentMixins
+      } = currentMixin;
+
+      if (currentMixins) {
+        currentMixins.forEach(mix => {
+          if (!mixinAccumulator.has(mix)) {
+            mixinAccumulator.set(mix, mix);
+            deepMergeMixin(mixinAccumulator, mix);
+          } else {
+            console.warn("Duplicate mixin import (".concat(mix.name, ")"));
+          }
+        });
+      }
+    }
+
+    const mixins = new Map();
+    deepMergeMixin(mixins, component);
+    return Array.from(mixins.values());
+  }
+
+  static mergeAttributes(mixins) {
+    let attributes = {};
+    mixins.forEach(mixin => {
+      if (!!mixin.attributes) {
+        attributes = { ...mixin.attributes,
+          ...attributes
+        };
+      }
+    });
+    return attributes;
+  }
+
+  static mergeInitialState(mixins) {
+    let initialState = {};
+    mixins.forEach(mixin => {
+      if (!!mixin.initialState) {
+        initialState = { ...mixin.initialState,
+          ...initialState
+        };
+      }
+    });
+    return initialState;
+  }
+
+  static mergeHooks(mixins) {
+    const hooks = {
+      created: [],
+      attached: [],
+      detached: []
+    };
+    mixins.reverse().forEach(mixin => {
+      HOOKS.forEach(hookName => {
+        if (!!mixin[hookName] && typeof mixin[hookName] === 'function') {
+          hooks[hookName].push(mixin[hookName]);
+        }
+      });
+    });
+    return hooks;
+  }
+
+  static mergeMethods(mixins) {
+    const methods = new Map();
+    mixins.reverse().forEach(mixin => {
+      const keys = Reflect.ownKeys(mixin).filter(key => typeof key === 'string' && API.indexOf(key) < 0 && !Object.getOwnPropertyDescriptor(mixin, key).get && !Object.getOwnPropertyDescriptor(mixin, key).set && typeof mixin[key] === 'function');
+      keys.forEach(key => {
+        methods.set(key, mixin[key]);
+      });
+    });
+    return methods;
+  }
+
+  static mergeAccessors(mixins) {
+    const accessors = {};
+    mixins.reverse().forEach(mixin => {
+      Reflect.ownKeys(mixin).filter(key => typeof key === 'string' && API.indexOf(key) < 0 && (Object.getOwnPropertyDescriptor(mixin, key).get || Object.getOwnPropertyDescriptor(mixin, key).set)).forEach(prop => {
+        accessors[prop] = { ...accessors[prop]
+        };
+        if (Reflect.getOwnPropertyDescriptor(mixin, prop).get) accessors[prop].get = Reflect.getOwnPropertyDescriptor(mixin, prop).get;
+        if (Reflect.getOwnPropertyDescriptor(mixin, prop).set) accessors[prop].set = Reflect.getOwnPropertyDescriptor(mixin, prop).set;
+      });
+    });
+    return accessors;
+  }
+
+}
+//# sourceMappingURL=Compositor.js.map

package/dist/libs/Compositor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Compositor.ts"],"names":["HOOKS","API","Compositor","merge","component","mixins","name","attributes","mergeAttributes","initialState","mergeInitialState","methods","mergeMethods","accessors","mergeAccessors","hooks","mergeHooks","mergeMixin","deepMergeMixin","mixinAccumulator","currentMixin","use","currentMixins","forEach","mix","has","set","console","warn","Map","Array","from","values","mixin","created","attached","detached","reverse","hookName","push","keys","Reflect","ownKeys","filter","key","indexOf","Object","getOwnPropertyDescriptor","get","prop"],"mappings":"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","sourcesContent":["import type {\n  MixinStaticInterface,\n  ComponentStaticInterface,\n  AttributesDefinitionInterface,\n  ArrayOfHooksInterface,\n  AccessorStaticInterface\n} from './interfaces';\n\nconst HOOKS = ['created', 'attached', 'detached'];\nconst API = [\n  'name',\n  'use',\n  'attributes',\n  'initialState',\n  ...HOOKS,\n];\n\nexport class Compositor {\n  public static merge(component: MixinStaticInterface, mixins: MixinStaticInterface[]): ComponentStaticInterface {\n    return {\n      name: component.name,\n      attributes: Compositor.mergeAttributes([ component, ...mixins ]),\n      initialState: Compositor.mergeInitialState([ component, ...mixins ]),\n      methods: Compositor.mergeMethods([ component, ...mixins]),\n      accessors: Compositor.mergeAccessors([ component, ...mixins]),\n      hooks: Compositor.mergeHooks([ component, ...mixins ]),\n    };\n  }\n\n  public static mergeMixin(component: MixinStaticInterface): MixinStaticInterface[] {\n    function deepMergeMixin(mixinAccumulator: Map<MixinStaticInterface, MixinStaticInterface>, currentMixin: MixinStaticInterface) {\n      const { use: currentMixins } = currentMixin;\n      if (currentMixins) {\n        currentMixins.forEach(mix => {\n          if (!mixinAccumulator.has(mix)) {\n            mixinAccumulator.set(mix, mix);\n            deepMergeMixin(mixinAccumulator, mix);\n          } else {\n            console.warn(`Duplicate mixin import (${mix.name})`);\n          }\n        });\n      }\n    }\n\n    const mixins = new Map();\n    deepMergeMixin(mixins, component);\n\n    return Array.from(mixins.values());\n  }\n\n  public static mergeAttributes(mixins: MixinStaticInterface[]): AttributesDefinitionInterface {\n    let attributes = {};\n\n    mixins.forEach(mixin => {\n      if (!!mixin.attributes) {\n        attributes = {...mixin.attributes, ...attributes };\n      }\n    });\n\n    return attributes;\n  }\n\n  public static mergeInitialState(mixins: MixinStaticInterface[]): any {\n    let initialState = {};\n\n    mixins.forEach(mixin => {\n      if (!!mixin.initialState) {\n        initialState = {...mixin.initialState, ...initialState };\n      }\n    });\n\n    return initialState;\n  }\n\n  public static mergeHooks(mixins: MixinStaticInterface[]): ArrayOfHooksInterface {\n    const hooks = {\n      created: [],\n      attached: [],\n      detached: [],\n    };\n    mixins\n      .reverse()\n      .forEach(mixin => {\n        HOOKS.forEach(hookName => {\n          if(!!mixin[hookName] && typeof mixin[hookName] === 'function') {\n            hooks[hookName].push(mixin[hookName]);\n          }\n        });\n      });\n    \n\n    return hooks;\n  }\n\n  public static mergeMethods(mixins: MixinStaticInterface[]): Map<any, any> {\n    const methods = new Map();\n\n    mixins.reverse().forEach(mixin => {\n      const keys = Reflect\n        .ownKeys(mixin)\n        .filter(key => (\n          typeof key === 'string' &&\n          API.indexOf(key) < 0 &&\n          !Object.getOwnPropertyDescriptor(mixin, key)!.get &&\n          !Object.getOwnPropertyDescriptor(mixin, key)!.set &&\n          typeof mixin[key] === 'function'));\n\n      keys.forEach(key => {\n        methods.set(key, mixin[key]);\n      });\n    });\n    return methods;\n  }\n\n  public static mergeAccessors(mixins: MixinStaticInterface[]): AccessorStaticInterface {\n    const accessors = {};\n    mixins.reverse().forEach(mixin => {\n      Reflect\n      .ownKeys(mixin)\n      .filter(key => (\n        typeof key === 'string' &&\n        API.indexOf(key) < 0 &&\n        (Object.getOwnPropertyDescriptor(mixin, key)!.get || Object.getOwnPropertyDescriptor(mixin, key)!.set)\n      ))\n      .forEach(prop => {\n        accessors[prop] = { ...accessors[prop] };\n        if (Reflect.getOwnPropertyDescriptor(mixin, prop)!.get) accessors[prop].get = Reflect.getOwnPropertyDescriptor(mixin, prop)!.get;\n        if (Reflect.getOwnPropertyDescriptor(mixin, prop)!.set) accessors[prop].set = Reflect.getOwnPropertyDescriptor(mixin, prop)!.set;\n      });\n    });\n    return accessors;\n  }\n}\n"]}

package/dist/libs/Sib.js

@@ -0,0 +1,58 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { ComponentFactory } from "./ComponentFactory.js";
+import { defineComponent } from "./helpers.js";
+export class Sib {
+  static register(componentDefinition) {
+    const component = ComponentFactory.build(componentDefinition);
+    const cls = this.toElement(component);
+    defineComponent(component.name, cls);
+  }
+
+  static toElement(component) {
+    var _temp;
+
+    return _temp = class extends HTMLElement {
+      constructor() {
+        super();
+
+        _defineProperty(this, "_component", null);
+
+        this.component = new component(this);
+        this.component.created();
+      }
+
+      get component() {
+        if (this._component === null) {
+          throw new Error('No component found');
+        }
+
+        return this._component;
+      }
+
+      set component(component) {
+        this._component = component;
+      }
+
+      static get observedAttributes() {
+        return component.observedAttributes;
+      }
+
+      attributeChangedCallback(name, oldValue, newValue) {
+        const attr = name.replace(/([a-z0-9])-([a-z0-9])/g, (_c, p1, p2) => "".concat(p1).concat(p2.toUpperCase()));
+        this.component.attributesCallback(attr, newValue, oldValue);
+      }
+
+      connectedCallback() {
+        this.component.attached();
+      }
+
+      disconnectedCallback() {
+        this.component.detached();
+      }
+
+    }, _temp;
+  }
+
+}
+//# sourceMappingURL=Sib.js.map

package/dist/libs/Sib.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Sib.ts"],"names":["ComponentFactory","defineComponent","Sib","register","componentDefinition","component","build","cls","toElement","name","HTMLElement","constructor","created","_component","Error","observedAttributes","attributeChangedCallback","oldValue","newValue","attr","replace","_c","p1","p2","toUpperCase","attributesCallback","connectedCallback","attached","disconnectedCallback","detached"],"mappings":";;AAAA,SAASA,gBAAT,QAAiC,uBAAjC;AACA,SAASC,eAAT,QAAgC,cAAhC;AAOA,OAAO,MAAMC,GAAN,CAAU;AACb,SAAcC,QAAd,CAAuBC,mBAAvB,EAAuE;AACnE,UAAMC,SAAS,GAAGL,gBAAgB,CAACM,KAAjB,CAAuBF,mBAAvB,CAAlB;AACA,UAAMG,GAAG,GAAG,KAAKC,SAAL,CAAeH,SAAf,CAAZ;AACAJ,IAAAA,eAAe,CAACI,SAAS,CAACI,IAAX,EAAiBF,GAAjB,CAAf;AACH;;AAED,SAAiBC,SAAjB,CAA2BH,SAA3B,EAAyF;AAAA;;AACrF,mBAAO,cAAcK,WAAd,CAA0B;AAG7BC,MAAAA,WAAW,GAAG;AACV;;AADU,4CAFkC,IAElC;;AAEV,aAAKN,SAAL,GAAiB,IAAIA,SAAJ,CAAc,IAAd,CAAjB;AACA,aAAKA,SAAL,CAAeO,OAAf;AACH;;AAED,UAAIP,SAAJ,GAAoC;AAChC,YAAI,KAAKQ,UAAL,KAAoB,IAAxB,EAA8B;AAC1B,gBAAM,IAAIC,KAAJ,CAAU,oBAAV,CAAN;AACH;;AACD,eAAO,KAAKD,UAAZ;AACH;;AACD,UAAIR,SAAJ,CAAcA,SAAd,EAA6C;AACzC,aAAKQ,UAAL,GAAkBR,SAAlB;AACH;;AAED,iBAAWU,kBAAX,GAAgC;AAC5B,eAAaV,SAAN,CAAiBU,kBAAxB;AACH;;AAEDC,MAAAA,wBAAwB,CAACP,IAAD,EAAOQ,QAAP,EAAiBC,QAAjB,EAA2B;AAC/C,cAAMC,IAAI,GAAGV,IAAI,CAACW,OAAL,CAAa,wBAAb,EAAuC,CAACC,EAAD,EAAKC,EAAL,EAASC,EAAT,eAAmBD,EAAnB,SAAwBC,EAAE,CAACC,WAAH,EAAxB,CAAvC,CAAb;AACA,aAAKnB,SAAL,CAAeoB,kBAAf,CAAkCN,IAAlC,EAAwCD,QAAxC,EAAkDD,QAAlD;AACH;;AAEDS,MAAAA,iBAAiB,GAAG;AAChB,aAAKrB,SAAL,CAAesB,QAAf;AACH;;AAEDC,MAAAA,oBAAoB,GAAG;AACnB,aAAKvB,SAAL,CAAewB,QAAf;AACH;;AAlC4B,KAAjC;AAoCH;;AA5CY","sourcesContent":["import { ComponentFactory } from \"./ComponentFactory.js\";\nimport { defineComponent } from \"./helpers.js\";\nimport type {\n    ComponentConstructorInterface,\n    ComponentInterface,\n    MixinStaticInterface\n} from \"./interfaces.js\";\n\nexport class Sib {\n    public static register(componentDefinition: MixinStaticInterface):void {\n        const component = ComponentFactory.build(componentDefinition);\n        const cls = this.toElement(component);\n        defineComponent(component.name, cls);\n    }\n\n    protected static toElement(component: ComponentConstructorInterface): typeof HTMLElement {\n        return class extends HTMLElement {\n            private _component: ComponentInterface | null = null;\n\n            constructor() {\n                super();\n                this.component = new component(this);\n                this.component.created();\n            }\n\n            get component(): ComponentInterface {\n                if (this._component === null) {\n                    throw new Error('No component found');\n                }\n                return this._component;\n            }\n            set component(component: ComponentInterface) {\n                this._component = component;\n            }\n\n            static get observedAttributes() {\n                return (<any>component).observedAttributes;\n            }\n\n            attributeChangedCallback(name, oldValue, newValue) {\n                const attr = name.replace(/([a-z0-9])-([a-z0-9])/g, (_c, p1, p2) => `${p1}${p2.toUpperCase()}`);\n                this.component.attributesCallback(attr, newValue, oldValue);\n            }\n\n            connectedCallback() {\n                this.component.attached();\n            }\n\n            disconnectedCallback() {\n                this.component.detached();\n            }\n        }\n    }\n}\n"]}