@startinblox/core 0.19.0-beta.2 → 0.19.0-beta.20

package/dist/components/solid-widget.js

@@ -1,72 +0,0 @@
-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`${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);

package/dist/import.css

@@ -1,4 +0,0 @@
-/* @ 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/libs/Component.js

@@ -1,13 +0,0 @@
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-export class Component {
-  constructor(element) {
-    _defineProperty(this, "element", void 0);
-    this.element = element;
-  }
-  created() {}
-  attached() {}
-  detached() {}
-  attributesCallback(_key, _value, _oldValue) {}
-}

package/dist/libs/ComponentFactory.js

@@ -1,165 +0,0 @@
-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 ${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;
-  }
-}

package/dist/libs/Compositor.js

@@ -1,96 +0,0 @@
-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 (${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;
-  }
-}

package/dist/libs/Sib.js

@@ -1,44 +0,0 @@
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-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) {
-    return 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) => `${p1}${p2.toUpperCase()}`);
-        this.component.attributesCallback(attr, newValue, oldValue);
-      }
-      connectedCallback() {
-        this.component.attached();
-      }
-      disconnectedCallback() {
-        this.component.detached();
-      }
-    };
-  }
-}

package/dist/libs/filter.js

@@ -1,184 +0,0 @@
-import { parseFieldsString, findClosingBracketMatchIndex, compare, uniqID } from "./helpers.js";
-/**
- * Check if the field is a set
- * @param field - field to test
- * @param fields - list of fields
- * @returns true if the field is a set, false otherwise
- */
-const isSet = (field, fields) => {
-  if (!fields) return false;
-  let foundSets = fields.match(getSetRegexp(field));
-  return foundSets ? foundSets.length > 0 : false;
-};
-/**
- * Get the list of fields in the set
- * @param field - set name to get
- * @param fields - list of fields
- * @returns a list of fields in the set
- */
-const getSet = (field, fields) => {
-  const setString = fields.match(getSetRegexp(field));
-  if (!setString) return [];
-  const firstSetBracket = fields.indexOf(setString[0]) + setString[0].length - 1;
-  const lastSetBracket = findClosingBracketMatchIndex(fields, firstSetBracket);
-  const set = fields.substring(firstSetBracket + 1, lastSetBracket);
-  return parseFieldsString(set);
-};
-const getSetRegexp = field => {
-  return new RegExp(`(^|\\,|\\(|\\s)\\s*${field}\\s*\\(`, 'g');
-};
-/**
- * Check if the field is a special search field
- * @param field - field to test
- * @param searchForm - current search form
- * @returns true if the field is a special search field
- */
-const isSearchField = (field, searchForm) => {
-  return searchForm.hasAttribute('search-' + field);
-};
-/**
- * Get the fields targetted by a search field
- * @param field - search field to get
- * @param searchForm - current search form
- * @returns a list of fields targetted by the current search field
- */
-const getSearchField = (field, searchForm) => {
-  return parseFieldsString(searchForm.getAttribute('search-' + field));
-};
-
-/**
- * Throw or simply return value
- * @param throwOn - should throw on True or False
- * @param ret - value to return
- * @returns
- */
-const orThrow = (throwOn, ret) => {
-  if (throwOn === true && ret) throw true;
-  if (throwOn === false && !ret) throw false;
-  return ret;
-};
-
-/**
- * Compare a value to the query
- * @param val - value to compare
- * @param query - object to know how and what value to compare
- * @param throwOn - should function throw error on True or False
- * @returns true if value matches, throw error otherwise
- */
-const matchValue = async (val, query, throwOn) => {
-  const subject = await val;
-  if (subject == null && query.value === '') return orThrow(throwOn, true); // filter not set and subject not existing -> ignore filter
-  if (subject == null) return orThrow(throwOn, false); // return false; // property does not exist on resource
-  if (query.list) {
-    // Filter on a container
-    if (query.value.length === 0) return orThrow(throwOn, true);
-    for (const v of query.value) {
-      if (await matchValue(subject, {
-        type: query.type,
-        value: v,
-        list: false
-      })) {
-        // do not throw here, we need the result
-        return orThrow(throwOn, true);
-      }
-    }
-    return orThrow(throwOn, false);
-  }
-  if (subject.isContainer?.()) {
-    let ret = Promise.resolve(query.value === ''); // if no query, return a match
-    for (const value of subject['ldp:contains']) {
-      ret = (await ret) || (await matchValue(value, query)); // do not throw here, we need the result
-      if (ret) return orThrow(throwOn, true);
-    }
-    return orThrow(throwOn, await ret);
-  }
-  return orThrow(throwOn, compare[query.type](subject, query.value));
-};
-
-/**
- * Cache properties of a filter to avoid repeated parsing
- * @param cacheKey - uniq key
- * @param filter - filter to check
- * @param fields - fields attribute of the element
- * @param searchForm - current search form
- */
-const cacheFieldsProps = (cacheKey, filter, fields, searchForm) => {
-  if (!window.cachePropsSearchFilter[cacheKey]) {
-    window.cachePropsSearchFilter[cacheKey] = {
-      setFields: isSet(filter, fields) ? getSet(filter, fields) : null,
-      setSearchFields: isSearchField(filter, searchForm) ? getSearchField(filter, searchForm) : null
-    };
-  }
-};
-
-/**
- * Check if one resource match one filter
- * @param resource - resource to test
- * @param filter - name of the property tested
- * @param query - query object to know how to compare values
- * @param fieldsAttr - fields attribute of the element
- * @param searchForm - searchForm component
- * @param filterId - uniqId used to fill the cache
- * @param throwOn - should function throw error on True or False
- * @returns return true if the resource matches the filter, throw error otherwise
- */
-const matchFilter = async (resource, filter, query, fieldsAttr, searchForm, filterId, throwOn) => {
-  let fields = null;
-  const cacheKey = `${filter}_${filterId}`;
-  cacheFieldsProps(cacheKey, filter, fieldsAttr, searchForm);
-  if (window.cachePropsSearchFilter[cacheKey].setFields !== null) {
-    fields = window.cachePropsSearchFilter[cacheKey].setFields;
-  } else if (window.cachePropsSearchFilter[cacheKey].setSearchFields !== null) {
-    fields = window.cachePropsSearchFilter[cacheKey].setSearchFields;
-  } else {
-    // search on 1 field
-    return matchValue(resource[filter], query, throwOn);
-  }
-
-  // search on multiple fields
-  try {
-    await Promise.all((fields || []).map(field => matchFilter(resource, field, query, fieldsAttr, searchForm, filterId, true // stop searching when 1 filter is true (= OR)
-    )));
-  } catch (e) {
-    return true;
-  }
-  throw false;
-};
-
-/**
- * Check if one resource match all the filters
- * @param resource - resource to test
- * @param filters - current filters
- * @param filterNames - names of the filters
- * @param fields - fields attribute of the element
- * @param searchForm - searchForm component
- * @param filterId - uniqId used to fill the cache
- * @returns true if resource match, false otherwise
- */
-const matchFilters = async (resource, filters, filterNames, fields, searchForm, filterId) => {
-  // return true if all filters values are contained in the corresponding field of the resource
-  try {
-    await Promise.all(filterNames.map(filter => matchFilter(resource, filter, filters[filter], fields, searchForm, filterId, false // stop searching when 1 filter is false (= AND)
-    )));
-  } catch (e) {
-    return false;
-  }
-  return true;
-};
-
-/**
- * Check which resources match the filters
- * @param resources - list of resources to filter
- * @param filters - current filters
- * @param fields - fields attribute of the element
- * @param searchForm - searchForm component
- * @returns resources filtered
- */
-const searchInResources = async (resources, filters, fields, searchForm) => {
-  // Optim: use cache to do these things only once
-  const filterNames = Object.keys(filters);
-  const filterId = uniqID();
-  window.cachePropsSearchFilter = {};
-  return Promise.all(resources.map(resource => matchFilters(resource, filters, filterNames, fields, searchForm, filterId)));
-};
-export { searchInResources };