@startinblox/core 0.18.0-beta.3 → 0.18.0-beta.4

package/dist/components/solid-form-search.js

@@ -70,8 +70,7 @@ export const SolidFormSearch = {
     });
     return values;
   },
-  getWidget(field) {
-    let isSet = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  getWidget(field, isSet = false) {
     let tagName = '';
     // If auto-range-[field] exists, create range-[field] and sets its value
     if (this.element.hasAttribute('auto-range-' + field) && !this.element.hasAttribute('range-' + field)) {

package/dist/components/solid-form.js

@@ -87,8 +87,7 @@ export const SolidForm = {
     }
     return transformArrayToContainer(value);
   },
-  getWidget(field) {
-    let isSet = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  getWidget(field, isSet = false) {
     let tagName = '';
     const widgetAttribute = this.element.getAttribute('widget-' + field);
 
@@ -163,8 +162,7 @@ export const SolidForm = {
     if (!this.isCreationForm(formValue) && this.isSavingAutomatically) this.submitForm(); // if autosave, submitForm
   },
 
-  findErrorMessage(errors) {
-    let errorFullName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  findErrorMessage(errors, errorFullName = '') {
     let errorsArray = [];
     errors.forEach(member => {
       let errorNextName = Object.values(member)[0];

package/dist/libs/ComponentFactory.js

@@ -131,10 +131,7 @@ export class ComponentFactory {
   static bindMethods(componentConstructor, methods) {
     methods.forEach((method, methodName) => {
       Reflect.defineProperty(componentConstructor.prototype, methodName, {
-        value: function () {
-          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-          }
+        value: function (...args) {
           return Reflect.apply(method, this, args);
         }
       });

package/dist/libs/filter.js

@@ -116,7 +116,7 @@ const cacheFieldsProps = (cacheKey, filter, fields, searchForm) => {
  * @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 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

package/dist/libs/helpers.js

@@ -7,8 +7,7 @@ function stringToDom(html) {
   template.innerHTML = html;
   return template.content;
 }
-async function evalTemplateString(str) {
-  let variables = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+async function evalTemplateString(str, variables = {}) {
   const keys = Object.keys(variables);
   const values = keys.map(key => variables[key]);
   try {
@@ -20,11 +19,8 @@ async function evalTemplateString(str) {
     throw new SyntaxError('`' + str + '`');
   }
 }
-function importCSS() {
+function importCSS(...stylesheets) {
   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);
@@ -38,10 +34,7 @@ function importCSS() {
   ;
   return linksElements;
 }
-function importJS() {
-  for (var _len2 = arguments.length, plugins = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    plugins[_key2] = arguments[_key2];
-  }
+function importJS(...plugins) {
   return plugins.map(url => {
     url = new URL(url, document.baseURI).href;
     let script = Array.from(document.querySelectorAll('script')).find(script => script.src === url);
@@ -169,6 +162,7 @@ function transformArrayToContainer(resource) {
     // iterate over all properties
     const predicateValue = newValue[predicate];
     if (!predicateValue || typeof predicateValue !== 'object') continue; // undefined or literal, do nothing
+    if (['permissions', '@context'].includes(predicate)) continue; // do not transform permissions and context
 
     // check all keys of nested resource
     if (!Array.isArray(predicateValue) && predicateValue['@id']) {

package/dist/libs/lit-helpers.js

@@ -93,12 +93,9 @@ 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) {
+export function preHTML(strings, ...values) {
   // 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;

package/dist/libs/polyfills.js

@@ -2,8 +2,7 @@
 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;
+    value: function flat(depth = 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) {
@@ -21,8 +20,7 @@ if (!('flat' in Array.prototype)) {
 
 // Element.prototype.toggleAttribute
 if (!Element.prototype.toggleAttribute) {
-  Element.prototype.toggleAttribute = function (name) {
-    let force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  Element.prototype.toggleAttribute = function (name, force = undefined) {
     if (force !== undefined) force = !!force;
     if (this.hasAttribute(name)) {
       if (force) return true;

package/dist/libs/store/custom-getter.js

@@ -0,0 +1,344 @@
+let _Symbol$toPrimitive;
+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 JSONLDContextParser from '../../_snowpack/pkg/jsonld-context-parser.js';
+import { store } from './store.js';
+const ContextParser = JSONLDContextParser.ContextParser;
+_Symbol$toPrimitive = Symbol.toPrimitive;
+export class CustomGetter {
+  // search attributes to give to server
+
+  constructor(resourceId, resource, clientContext, serverContext, parentId = "", serverPagination = {}, serverSearch = {}) {
+    _defineProperty(this, "resource", void 0);
+    // content of the requested resource
+    _defineProperty(this, "resourceId", void 0);
+    _defineProperty(this, "clientContext", void 0);
+    // context given by the app
+    _defineProperty(this, "serverContext", void 0);
+    // context given by the server
+    _defineProperty(this, "parentId", void 0);
+    // id of the parent resource, used to get the absolute url of the current resource
+    _defineProperty(this, "containerTypes", void 0);
+    // types of resources interpreted as containers
+    _defineProperty(this, "serverPagination", void 0);
+    // pagination attributes to give to server
+    _defineProperty(this, "serverSearch", void 0);
+    this.clientContext = clientContext;
+    this.serverContext = serverContext;
+    this.parentId = parentId;
+    this.resource = resource;
+    // this.resource = this.expandProperties({ ...resource }, serverContext);
+    this.resourceId = resourceId;
+    this.serverPagination = serverPagination;
+    this.serverSearch = serverSearch;
+    this.containerTypes = [this.getExpandedPredicate("ldp:Container"), this.getExpandedPredicate("ldp:BasicContainer"), this.getExpandedPredicate("ldp:DirectContainer"), this.getExpandedPredicate("ldp:IndirectContainer"), "sib:federatedContainer"];
+  }
+
+  // /**
+  //  * Expand all predicates of a resource with a given context
+  //  * @param resource: object
+  //  * @param context: object
+  //  */
+  // expandProperties(resource: object, context: object | string) {
+  //     for (let prop of Object.keys(resource)) {
+  //         if (!prop) continue;
+  //         this.objectReplaceProperty(resource, prop, ContextParser.expandTerm(prop, context as JSONLDContextParser.IJsonLdContextNormalized, true));
+  //     }
+  //     return resource
+  // }
+
+  // /**
+  //  * Change the key of an object
+  //  * @param object: object
+  //  * @param oldProp: string - current key
+  //  * @param newProp: string - new key to set
+  //  */
+  // objectReplaceProperty(object: object, oldProp: string, newProp: string) {
+  //     if (newProp !== oldProp) {
+  //         Object.defineProperty(
+  //             object,
+  //             newProp,
+  //             Object.getOwnPropertyDescriptor(object, oldProp) || ''
+  //         );
+  //         delete object[oldProp];
+  //     }
+  // }
+
+  /**
+   * Get the property of a resource for a given path
+   * Which means that if the resource is not complete, it will fetch it
+   * And that we handle the `.` notation, traversing the path recursively
+   * @param path: string
+   */
+  async get(path) {
+    if (!path) return;
+
+    // Specific case where the predicates is a full IRI, avoid splitting it on the dot notation
+    try {
+      let isUrl = new URL(path);
+      // If the path is an absolute url, we need to fetch the resource
+      if (isUrl) {
+        let value = this.resource[this.getExpandedPredicate(path)];
+        return value ? value : undefined;
+      }
+    } catch (e) {
+      // Split the path on each dots
+      const path1 = path.split('.');
+
+      // Intermediate path var to request each resource individually until the path traversal is completed
+      const path2 = [];
+
+      // Actual value found from the store, if any
+      let value;
+      if (!this.isFullResource()) {
+        // if resource is not complete, fetch it first
+        await this.getResource(this.resourceId, {
+          ...this.clientContext,
+          ...this.serverContext
+        }, this.parentId);
+      }
+
+      // If the path contains dot, we need to traverse the path recursively
+      // We do that by poping one element from path1 at each step and affecting it to path2
+      // Trying to get the value from it
+      while (true) {
+        try {
+          value = this.resource[this.getExpandedPredicate(path1[0])];
+        } catch (e) {
+          break;
+        }
+        if (path1.length <= 1) break; // no dot path
+        const lastPath1El = path1.pop();
+        if (lastPath1El) path2.unshift(lastPath1El);
+      }
+      if (path2.length === 0) {
+        // end of the path
+        if (!value || !value['@id']) return this.getLiteralValue(value); // no value or not a resource
+        return await this.getResource(value['@id'], {
+          ...this.clientContext,
+          ...this.serverContext
+        }, this.parentId || this.resourceId); // return complete resource
+      }
+
+      if (!value) return undefined;
+      let resource = await this.getResource(value['@id'], {
+        ...this.clientContext,
+        ...this.serverContext
+      }, this.parentId || this.resourceId);
+      store.subscribeResourceTo(this.resourceId, value['@id']);
+      return resource ? await resource[path2.join('.')] : undefined; // return value
+    }
+  }
+
+  /**
+   * Return value depending of the current language
+   * @param value
+   * @returns
+   */
+  getLiteralValue(value) {
+    if (typeof value === "object") {
+      // value object: https://www.w3.org/TR/json-ld11/#value-objects
+      if (value['@value']) {
+        // 1 language
+        return value['@value'];
+      } else if (Array.isArray(value)) {
+        // multiple languages
+        if (value.length === 0) return null;
+        const ln = store._getLanguage();
+        let translatedValue = value.find(v => v['@language'] && v['@language'] === ln); // find current language
+        if (!translatedValue) translatedValue = value.find(v => v['@language'] && v['@language'] === 'en'); // default to en
+        return translatedValue ? translatedValue['@value'] || null : null;
+      }
+    }
+    return value; // simple value
+  }
+
+  /**
+   * Cache resource in the store, and return the created proxy
+   * @param id
+   * @param context
+   * @param iriParent
+   */
+  async getResource(id, context, iriParent, forceFetch = false) {
+    if (id.startsWith('_:b')) return store.get(id + iriParent); // anonymous node = get from cache
+    return store.getData(id, context, iriParent, undefined, forceFetch);
+  }
+
+  /**
+   * Return true if the resource is a container
+   */
+  isContainer() {
+    if (this.resource["@type"]) {
+      // @type is an array
+      if (Array.isArray(this.resource["@type"])) return this.containerTypes.some(type => this.resource["@type"].includes(type));
+      return this.containerTypes.includes(this.resource["@type"]);
+    } else if (this.resource["type"]) {
+      if (Array.isArray(this.resource["type"])) return this.containerTypes.some(type => this.resource["type"].includes(type));
+      return this.containerTypes.includes(this.resource["type"]);
+    }
+    return false;
+  }
+
+  /**
+   * Return true if the given key in the current resource in an array
+   */
+  isArray() {
+    if (Array.isArray(this.resource)) return true;
+    return false;
+  }
+
+  /**
+   * Get all properties of a resource
+   */
+  getProperties() {
+    return Object.keys(this.resource).map(prop => this.getCompactedPredicate(prop));
+  }
+
+  /**
+   * Get children of container as objects
+   */
+  getChildren(predicateName) {
+    return this.resource[this.getExpandedPredicate(predicateName)] || [];
+  }
+
+  /**
+   * Get children of container as Proxys
+   */
+  getLdpContains() {
+    let children = this.resource[this.getExpandedPredicate("ldp:contains")];
+    if (!children) return null;
+    if (!Array.isArray(children)) children = [children]; // convert to array if compacted to 1 resource
+
+    let result = children ? children.map(res => {
+      let resource = store.get(res['@id']);
+      if (resource) return resource;
+
+      // if not in cache, generate the basic resource
+      resource = new CustomGetter(res['@id'], {
+        '@id': res['@id']
+      }, this.clientContext, this.serverContext, this.parentId).getProxy();
+      store.cacheResource(res['@id'], resource); // put it in cache
+      return resource; // and return it
+    }) : [];
+    return result;
+  }
+  merge(resource) {
+    this.resource = {
+      ...this.getResourceData(),
+      ...resource.getResourceData()
+    };
+  }
+  getResourceData() {
+    return this.resource;
+  }
+
+  /**
+   * return true resource seems complete
+   * @param prop
+   */
+  isFullResource() {
+    return Object.keys(this.resource).filter(p => !p.startsWith('@')).length > 0 // has some properties
+    || this.resource['@id'].startsWith('_:b'); // anonymous node = always full resource
+  }
+
+  /**
+   * Get permissions of a resource
+   * @param resourceId
+   * @returns 
+   */
+  async getPermissions() {
+    let permissionsIds = this.resource[this.getExpandedPredicate("permissions")];
+    if (!permissionsIds) {
+      // if no permission, re-fetch data from store
+      await this.getResource(this.resourceId, {
+        ...this.clientContext,
+        ...this.serverContext
+      }, this.parentId, true);
+      permissionsIds = this.resource[this.getExpandedPredicate("permissions")];
+    }
+    if (!permissionsIds) return [];
+    if (!Array.isArray(permissionsIds)) permissionsIds = [permissionsIds]; // convert to array if compacted to 1 resource
+    const permissions = await Promise.all(permissionsIds.map(p => store.get(p['@id'] + this.parentId)) // get anonymous node from store
+    .map(p => p ? p['mode.@type'] : ''));
+    return permissions ? permissions.map(perm => ContextParser.expandTerm(perm, this.serverContext, true)) : [];
+  }
+
+  /**
+   * returns compacted @type of resource
+   */
+  getType() {
+    return this.resource['@type'] ? this.getCompactedIri(this.resource['@type']) : '';
+  }
+
+  /**
+   * Remove the resource from the cache
+   */
+  clearCache() {
+    store.clearCache(this.resourceId);
+  }
+  getExpandedPredicate(property) {
+    return ContextParser.expandTerm(property, {
+      ...this.clientContext,
+      ...this.serverContext
+    }, true);
+  }
+  getCompactedPredicate(property) {
+    return ContextParser.compactIri(property, {
+      ...this.clientContext,
+      ...this.serverContext
+    }, true);
+  }
+  getCompactedIri(id) {
+    return ContextParser.compactIri(id, {
+      ...this.clientContext,
+      ...this.serverContext
+    });
+  }
+  toString() {
+    return this.getCompactedIri(this.resource['@id']);
+  }
+  [_Symbol$toPrimitive]() {
+    return this.getCompactedIri(this.resource['@id']);
+  }
+
+  /**
+   * Returns a Proxy which handles the different get requests
+   */
+  getProxy() {
+    return new Proxy(this, {
+      get: (resource, property) => {
+        if (!this.resource) return undefined;
+        if (typeof resource[property] === 'function') return resource[property].bind(resource);
+        switch (property) {
+          case '@id':
+            if (this.resource['@id']) return this.getCompactedIri(this.resource['@id']); // Compact @id if possible
+            else console.log(this.resource, this.resource['@id']);
+            return;
+          case '@type':
+            return this.resource['@type'];
+          // return synchronously
+          case 'properties':
+            return this.getProperties();
+          case 'ldp:contains':
+            return this.getLdpContains();
+          // returns standard arrays synchronously
+          case 'permissions':
+            return this.getPermissions();
+          // get expanded permissions
+          case 'clientContext':
+            return this.clientContext;
+          // get saved client context to re-fetch easily a resource
+          case 'serverContext':
+            return this.serverContext;
+          // get saved client context to re-fetch easily a resource
+          case 'then':
+            return;
+          default:
+            // FIXME: missing 'await'
+            return resource.get(property);
+        }
+      }
+    });
+  }
+}

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

@@ -1,11 +1,8 @@
 export function formatAttributesToServerPaginationOptions(elementAttributes) {
-  const attributes = new Map(Array.from(elementAttributes).map(_ref => {
-    let {
-      name,
-      value
-    } = _ref;
-    return [name, value];
-  }));
+  const attributes = new Map(Array.from(elementAttributes).map(({
+    name,
+    value
+  }) => [name, value]));
   const limit = attributes.get('limit');
   const offset = attributes.get('offset');
   if (!offset || !limit) return;

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

@@ -1,11 +1,8 @@
 export function formatAttributesToServerSearchOptions(elementAttributes) {
-  const attributes = new Map(Array.from(elementAttributes).map(_ref => {
-    let {
-      name,
-      value
-    } = _ref;
-    return [name, value];
-  }));
+  const attributes = new Map(Array.from(elementAttributes).map(({
+    name,
+    value
+  }) => [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();