@startinblox/core 0.0.0

package/dist/libs/helpers.js

@@ -0,0 +1,194 @@
+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) {
+  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 + '`');
+    return await func(...values);
+  } catch (e) {
+    console.log(e);
+    throw new SyntaxError('`' + str + '`');
+  }
+}
+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);
+    if (link) return link;
+    link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    document.head.appendChild(link);
+    linksElements.push(link);
+  }
+  ;
+  return linksElements;
+}
+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);
+    if (script) return script;
+    script = document.createElement('script');
+    script.src = url;
+    document.head.appendChild(script);
+    return script;
+  });
+}
+function relativeSource(source) {
+  if (!source.match(/^\..?\//)) return new URL(source, document.baseURI).href;
+  const e = new Error();
+  if (!e.stack) return source;
+  const f2 = e.stack.split('\n').filter(l => l.includes(':'))[2];
+  let line = f2.match(/[a-z]+:.*$/);
+  if (!line) return source;
+  const calledFile = line[0].replace(/(\:[0-9]+){2}\)?$/, '');
+  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') {
+      resolve();
+    } else {
+      document.addEventListener('DOMContentLoaded', () => resolve());
+    }
+  });
+}
+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
+  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
+}
+
+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 "${tagName}" has already been loaded in another version of sib-core.`);
+  }
+}
+function fuzzyCompare(subject, search) {
+  const fuse = new Fuse([subject], {
+    shouldSort: false,
+    threshold: 0.37
+  }).search(search);
+  return fuse.length > 0;
+}
+const compare = {
+  string(subject, query) {
+    // Exact match on empty string between query and subject
+    if (query === '' && subject.toString() === '') return false;
+    // Else if query is empty and subject is something else, return true
+    else 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;
+    if (!query['@id']) return false;
+    const ret = subject['@id'] === query['@id'];
+    return ret;
+  }
+};
+function transformArrayToContainer(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
+    if (!Array.isArray(predicateValue) && predicateValue['@id']) {
+      newValue[predicate] = transformArrayToContainer(resource[predicate]);
+    }
+
+    // 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 };

package/dist/libs/interfaces.js

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

package/dist/libs/lit-helpers.js

@@ -0,0 +1,142 @@
+/**
+ * Spread function from open-wc/lit-helpers
+ * More informations here: https://open-wc.org/developing/lit-helpers.html
+ */
+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];
+      if (value === noChange) continue;
+      const prefix = key[0];
+      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));
+        } else {
+          element.removeAttribute(key);
+        }
+      }
+    }
+  }
+  if (prevData) {
+    for (const key in prevData) {
+      if (!spreadData || !(key in spreadData)) {
+        const prefix = key[0];
+        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;
+    } else {
+      newArr.push(arr[i]);
+    }
+  }
+  return newArr;
+}
+const templateStringsCache = new WeakMap();
+
+// Convert dynamic tags to template strings
+// example: <${'div'}>${'this is example'}</${'div'}> => <div>${'this is example'}</div>
+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
+    ) {
+      needlessValues.push({
+        value: values[i],
+        index: i
+      });
+      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));
+}

package/dist/libs/polyfills.js

@@ -0,0 +1,37 @@
+// Array.prototype.flat
+if (!('flat' in Array.prototype)) {
+  Object.defineProperty(Array.prototype, 'flat', {
+    configurable: true,
+    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) {
+        if (Array.isArray(cur)) {
+          acc.push.apply(acc, flat.call(cur, depth - 1));
+        } else {
+          acc.push(cur);
+        }
+        return acc;
+      }, []);
+    },
+    writable: true
+  });
+}
+
+// Element.prototype.toggleAttribute
+if (!Element.prototype.toggleAttribute) {
+  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 {};

package/dist/libs/store/server-pagination.js

@@ -0,0 +1,22 @@
+export function formatAttributesToServerPaginationOptions(elementAttributes) {
+  const attributes = new Map(Array.from(elementAttributes).map(_ref => {
+    let {
+      name,
+      value
+    } = _ref;
+    return [name, value];
+  }));
+  const limit = attributes.get('limit');
+  const offset = attributes.get('offset');
+  if (!offset || !limit) return;
+  return {
+    limit: limit,
+    offset: offset
+  };
+}
+export function appendServerPaginationToIri(iri, options) {
+  const first = iri.includes('?') ? '&' : '?';
+  const limit = options.limit;
+  const offset = options.offset;
+  return `${iri}${first}limit=${limit}&offset=${offset}`;
+}

package/dist/libs/store/server-search.js

@@ -0,0 +1,35 @@
+export function formatAttributesToServerSearchOptions(elementAttributes) {
+  const attributes = new Map(Array.from(elementAttributes).map(_ref => {
+    let {
+      name,
+      value
+    } = _ref;
+    return [name, value];
+  }));
+  const fields = attributes.get('server-search-fields')?.split(",").map(field => field.trim());
+  const value = attributes.get('server-search-value')?.trim();
+  const method = attributes.get('server-search-method')?.trim();
+  return {
+    fields: fields && fields.length > 0 ? fields : undefined,
+    value: value ? value : undefined,
+    method: method ? method : undefined
+  };
+}
+export function mergeServerSearchOptions(attributesOptions, dynamicOptions) {
+  const fields = attributesOptions?.fields ?? dynamicOptions?.fields;
+  const value = dynamicOptions?.value ?? attributesOptions?.value;
+  const method = attributesOptions?.method ?? dynamicOptions?.method;
+  if (!fields || fields.length === 0 || !value) return;
+  return {
+    fields,
+    value,
+    method
+  };
+}
+export function appendServerSearchToIri(iri, options) {
+  const first = iri.includes('?') ? '&' : '?';
+  const fields = options.fields.map(encodeURIComponent).join(',');
+  const value = encodeURIComponent(options.value);
+  const method = encodeURIComponent(options.method ?? 'ibasic');
+  return `${iri}${first}search-fields=${fields}&search-terms=${value}&search-method=${method}`;
+}