@startinblox/core 0.17.31 → 0.18.0-beta.1

package/dist/libs/Sib.js

@@ -1,5 +1,6 @@
-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; }
-
+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 {
@@ -8,51 +9,36 @@ export class Sib {
     const cls = this.toElement(component);
     defineComponent(component.name, cls);
   }
-
   static toElement(component) {
-    var _temp;
-
-    return _temp = class extends HTMLElement {
+    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) => "".concat(p1).concat(p2.toUpperCase()));
+        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();
       }
-
-    }, _temp;
+    };
   }
-
-}
-//# sourceMappingURL=Sib.js.map
+}

package/dist/libs/filter.js

@@ -0,0 +1,184 @@
+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 fields - 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 };

package/dist/libs/helpers.js

@@ -1,19 +1,16 @@
 import Fuse from "../_snowpack/pkg/fusejs.js";
-
 function uniqID() {
   return '_' + (Math.random() * Math.pow(36, 20)).toString(36).slice(0, 10);
 }
-
 function stringToDom(html) {
   const template = document.createElement('template');
   template.innerHTML = html;
   return template.content;
 }
-
-async function evalTemplateString(str, variables = {}) {
+async function evalTemplateString(str) {
+  let variables = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   const keys = Object.keys(variables);
   const values = keys.map(key => variables[key]);
-
   try {
     const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
     const func = AsyncFunction.call(null, ...keys, 'return `' + str + '`');
@@ -23,10 +20,11 @@ async function evalTemplateString(str, variables = {}) {
     throw new SyntaxError('`' + str + '`');
   }
 }
-
-function importCSS(...stylesheets) {
+function importCSS() {
   const linksElements = [];
-
+  for (var _len = arguments.length, stylesheets = new Array(_len), _key = 0; _key < _len; _key++) {
+    stylesheets[_key] = arguments[_key];
+  }
   for (let url of stylesheets) {
     url = relativeSource(url);
     let link = Array.from(document.head.querySelectorAll('link')).find(link => link.href === url);
@@ -37,12 +35,13 @@ function importCSS(...stylesheets) {
     document.head.appendChild(link);
     linksElements.push(link);
   }
-
   ;
   return linksElements;
 }
-
-function importJS(...plugins) {
+function importJS() {
+  for (var _len2 = arguments.length, plugins = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    plugins[_key2] = arguments[_key2];
+  }
   return plugins.map(url => {
     url = new URL(url, document.baseURI).href;
     let script = Array.from(document.querySelectorAll('script')).find(script => script.src === url);
@@ -53,7 +52,6 @@ function importJS(...plugins) {
     return script;
   });
 }
-
 function relativeSource(source) {
   if (!source.match(/^\..?\//)) return new URL(source, document.baseURI).href;
   const e = new Error();
@@ -65,21 +63,17 @@ function relativeSource(source) {
   source = new URL(source, calledFile).href;
   return source;
 }
-
 function loadScript(source) {
   source = relativeSource(source);
   return new Promise(resolve => {
     var script = document.createElement('script');
     var head = document.querySelector('head');
     script.async = true;
-
     script.onload = () => setTimeout(resolve, 0);
-
     script.src = source;
     if (head) head.appendChild(script);
   });
 }
-
 function domIsReady() {
   return new Promise(function (resolve) {
     if (document.readyState === 'complete') {
@@ -89,29 +83,24 @@ function domIsReady() {
     }
   });
 }
-
 function setDeepProperty(obj, path, value) {
   const name = path.shift();
-
   if (name) {
     if (!(name in obj)) obj[name] = {};
     if (path.length) setDeepProperty(obj[name], path, value);else obj[name] = value;
   }
 }
-
 function parseFieldsString(fields) {
-  let fieldsArray; // remove all sets from fields
+  let fieldsArray;
 
+  // remove all sets from fields
   while (fields.indexOf('(') > 0) {
     let firstBracket = fields.indexOf('(');
     let noset = fields.substring(firstBracket, findClosingBracketMatchIndex(fields, firstBracket) + 1);
     fields = fields.replace(noset, '');
   }
-
   const re = /((^\s*|,)\s*)(("(\\"|[^"])*")|('(\\'|[^'])*')|[^,]*)/gm; // match , not inside quotes
-
   fieldsArray = fields.match(re) || []; // separate fields
-
   if (!fieldsArray) return [];
   return fieldsArray.map(a => a.replace(/^[\s,]+/, '')); // remove commas and spaces
 }
@@ -119,30 +108,25 @@ function parseFieldsString(fields) {
 function findClosingBracketMatchIndex(str, pos) {
   if (str[pos] != '(') throw new Error("No '(' at index " + pos);
   let depth = 1;
-
   for (let i = pos + 1; i < str.length; i++) {
     switch (str[i]) {
       case '(':
         depth++;
         break;
-
       case ')':
         if (--depth == 0) return i;
         break;
     }
   }
-
   return -1;
 }
-
 function defineComponent(tagName, componentClass) {
   if (!customElements.get(tagName)) {
     customElements.define(tagName, componentClass);
   } else {
-    console.warn("Warning: the component \"".concat(tagName, "\" has already been loaded in another version of sib-core."));
+    console.warn(`Warning: the component "${tagName}" has already been loaded in another version of sib-core.`);
   }
 }
-
 function fuzzyCompare(subject, search) {
   const fuse = new Fuse([subject], {
     shouldSort: false,
@@ -150,31 +134,25 @@ function fuzzyCompare(subject, search) {
   }).search(search);
   return fuse.length > 0;
 }
-
 const compare = {
   string(subject, query) {
     if (query === '') return true;
     if (subject.toString().toLowerCase().includes(String(query).toLowerCase())) return true;
     return fuzzyCompare(subject, query);
   },
-
   boolean(subject, query) {
     if (!query) return true;
     return subject;
   },
-
   number(subject, query) {
     return subject === query;
   },
-
   list(subject, list) {
     return list.includes(subject);
   },
-
   range(subject, range) {
     return (range[0] == null || range[0] === '' || subject >= range[0]) && (range[1] == null || range[1] === '' || subject <= range[1]);
   },
-
   resource(subject, query) {
     // dropdown default ' - ' option return an empty string
     if (query === '') return true;
@@ -182,38 +160,32 @@ const compare = {
     const ret = subject['@id'] === query['@id'];
     return ret;
   }
-
 };
-
 function transformArrayToContainer(resource) {
-  const newValue = { ...resource
+  const newValue = {
+    ...resource
   };
-
   for (let predicate of Object.keys(newValue)) {
     // iterate over all properties
     const predicateValue = newValue[predicate];
     if (!predicateValue || typeof predicateValue !== 'object') continue; // undefined or literal, do nothing
-    // check all keys of nested resource
 
+    // check all keys of nested resource
     if (!Array.isArray(predicateValue) && predicateValue['@id']) {
       newValue[predicate] = transformArrayToContainer(resource[predicate]);
-    } // for arrays
-
+    }
 
+    // for arrays
     if (Array.isArray(predicateValue)) {
       newValue[predicate] = {
         'ldp:contains': [...predicateValue]
       }; // transform to container
-
       newValue[predicate]['ldp:contains'].forEach((childPredicate, index) => {
         // and check all nested resources
         newValue[predicate]['ldp:contains'][index] = transformArrayToContainer(childPredicate);
       });
     }
   }
-
   return newValue;
 }
-
-export { uniqID, stringToDom, evalTemplateString, importCSS, importJS, loadScript, domIsReady, setDeepProperty, parseFieldsString, findClosingBracketMatchIndex, defineComponent, fuzzyCompare, compare, transformArrayToContainer };
-//# sourceMappingURL=helpers.js.map
+export { uniqID, stringToDom, evalTemplateString, importCSS, importJS, loadScript, domIsReady, setDeepProperty, parseFieldsString, findClosingBracketMatchIndex, defineComponent, fuzzyCompare, compare, transformArrayToContainer };

package/dist/libs/interfaces.js

@@ -3,4 +3,4 @@
 ;
 ;
 ;
-//# sourceMappingURL=interfaces.js.map
+export {};

package/dist/libs/lit-helpers.js

@@ -6,13 +6,10 @@ import { html, directive, noChange } from '../_snowpack/pkg/lit-html.js';
 const prevCache = new WeakMap();
 export const spread = directive(spreadData => part => {
   const prevData = prevCache.get(part);
-
   if (prevData === spreadData) {
     return;
   }
-
   prevCache.set(part, spreadData);
-
   if (spreadData) {
     for (const key in spreadData) {
       const value = spreadData[key];
@@ -21,41 +18,32 @@ export const spread = directive(spreadData => part => {
       const {
         element
       } = part.committer;
-
       if (prefix === '@') {
         const prevHandler = prevData && prevData[key];
-
         if (!prevHandler || prevHandler !== value) {
           const name = key.slice(1);
           if (prevHandler) element.removeEventListener(name, prevHandler);
           element.addEventListener(name, value);
         }
-
         continue;
       }
-
       if (prefix === '.') {
         if (!prevData || prevData[key] !== value) {
           element[key.slice(1)] = value;
         }
-
         continue;
       }
-
       if (prefix === '?') {
         if (!prevData || prevData[key] !== value) {
           const name = key.slice(1);
-
           if (value) {
             element.setAttribute(name, '');
           } else {
             element.removeAttribute(name);
           }
         }
-
         continue;
       }
-
       if (!prevData || prevData[key] !== value) {
         if (value != null) {
           element.setAttribute(key, String(value));
@@ -65,7 +53,6 @@ export const spread = directive(spreadData => part => {
       }
     }
   }
-
   if (prevData) {
     for (const key in prevData) {
       if (!spreadData || !(key in spreadData)) {
@@ -73,32 +60,26 @@ export const spread = directive(spreadData => part => {
         const {
           element
         } = part.committer;
-
         if (prefix === '@') {
           element.removeEventListener(key.slice(1), prevData[key]);
           continue;
         }
-
         if (prefix === '.') {
           element[key.slice(1)] = undefined;
           continue;
         }
-
         if (prefix === '?') {
           element.removeAttribute(key.slice(1));
           continue;
         }
-
         element.removeAttribute(key);
       }
     }
   }
 });
-
 function dropIndices(arr, needlessValues) {
   const newArr = [];
   let j = 0;
-
   for (let i = 0, n = arr.length; i < n; ++i) {
     if (needlessValues[j].index === i) {
       ++j;
@@ -106,42 +87,38 @@ function dropIndices(arr, needlessValues) {
       newArr.push(arr[i]);
     }
   }
-
   return newArr;
 }
+const templateStringsCache = new WeakMap();
 
-const templateStringsCache = new WeakMap(); // Convert dynamic tags to template strings
+// Convert dynamic tags to template strings
 // example: <${'div'}>${'this is example'}</${'div'}> => <div>${'this is example'}</div>
-
-export function preHTML(strings, ...values) {
+export function preHTML(strings) {
   // check cache !important return equal link at first argument
   let cachedStrings = templateStringsCache.get(strings);
-
+  for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    values[_key - 1] = arguments[_key];
+  }
   if (cachedStrings) {
     for (let i = 0, n = cachedStrings.length; i < n; ++i) {
       const needlessValues = cachedStrings[i].needlessValues;
       let isSame = true;
-
       for (let ii = 0, nn = needlessValues.length; ii < nn; ++ii) {
         if (values[needlessValues[ii].index] !== needlessValues[ii].value) {
           isSame = false;
           break;
         }
       }
-
       if (isSame) {
         return html(cachedStrings[i].strings, ...dropIndices(values, needlessValues));
       }
     }
   }
-
   const needlessValues = [];
   const newStrings = [];
   let str;
-
   for (let i = 0, n = strings.length; i < n; ++i) {
     str = strings[i];
-
     while (str[str.length - 1] === '<' // open tag
     || str[str.length - 2] === '<' && str[str.length - 1] === '/' // close tag
     ) {
@@ -151,19 +128,15 @@ export function preHTML(strings, ...values) {
       });
       str += values[i] + strings[++i];
     }
-
     newStrings.push(str);
   }
-
   if (!cachedStrings) {
     cachedStrings = [];
     templateStringsCache.set(strings, cachedStrings);
   }
-
   cachedStrings.push({
     strings: newStrings,
     needlessValues
   });
   return html(newStrings, ...dropIndices(values, needlessValues));
-}
-//# sourceMappingURL=lit-helpers.js.map
+}

package/dist/libs/polyfills.js

@@ -2,7 +2,8 @@
 if (!('flat' in Array.prototype)) {
   Object.defineProperty(Array.prototype, 'flat', {
     configurable: true,
-    value: function flat(depth = 1) {
+    value: function flat() {
+      let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
       depth = isNaN(depth) ? 1 : Number(depth);
       if (depth === 0) return Array.prototype.slice.call(this);
       return Array.prototype.reduce.call(this, function (acc, cur) {
@@ -11,30 +12,26 @@ if (!('flat' in Array.prototype)) {
         } else {
           acc.push(cur);
         }
-
         return acc;
       }, []);
     },
     writable: true
   });
-} // Element.prototype.toggleAttribute
-
+}
 
+// Element.prototype.toggleAttribute
 if (!Element.prototype.toggleAttribute) {
-  Element.prototype.toggleAttribute = function (name, force = undefined) {
+  Element.prototype.toggleAttribute = function (name) {
+    let force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
     if (force !== undefined) force = !!force;
-
     if (this.hasAttribute(name)) {
       if (force) return true;
       this.removeAttribute(name);
       return false;
     }
-
     if (force === false) return false;
     this.setAttribute(name, '');
     return true;
   };
 }
-
-export {};
-//# sourceMappingURL=polyfills.js.map
+export {};