@startinblox/core 2.0.1-beta.1 → 2.0.1-beta.2

package/dist/custom-getter-CZS1zXzA.js

@@ -0,0 +1,274 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { q as mergeContexts, n as normalizeContext, o as getRawContext } from "./helpers-dFpcGbvl.js";
+import { e as getStore, __tla as __tla_0 } from "./store-sU3CpiAU.js";
+let CustomGetter;
+let __tla = Promise.all([
+  (() => {
+    try {
+      return __tla_0;
+    } catch {
+    }
+  })()
+]).then(async () => {
+  const store = getStore();
+  CustomGetter = class {
+    constructor(resourceId, resource, clientContext, serverContext, parentId = "", serverPagination = {}, serverSearch = {}) {
+      __publicField(this, "resource");
+      __publicField(this, "resourceId");
+      __publicField(this, "clientContext");
+      __publicField(this, "serverContext");
+      __publicField(this, "parentId");
+      __publicField(this, "listTypes");
+      __publicField(this, "serverPagination");
+      __publicField(this, "serverSearch");
+      this.clientContext = clientContext;
+      this.serverContext = serverContext;
+      this.parentId = parentId;
+      this.resource = resource;
+      this.resourceId = resourceId;
+      this.serverPagination = serverPagination;
+      this.serverSearch = serverSearch;
+      this.listTypes = [
+        this.getExpandedPredicate("ldp:Container"),
+        this.getExpandedPredicate("dcat:Catalog"),
+        this.getExpandedPredicate("ldp:BasicContainer"),
+        this.getExpandedPredicate("ldp:DirectContainer"),
+        this.getExpandedPredicate("ldp:IndirectContainer"),
+        this.getExpandedPredicate("sib:federatedContainer")
+      ].filter(Boolean);
+    }
+    async get(path) {
+      if (!path) return;
+      try {
+        const isUrl = new URL(path);
+        if (!isUrl.protocol.startsWith("http")) throw new Error("Not a valid HTTP url");
+        if (isUrl) {
+          let resources = await this.getList(path);
+          if (!resources || Array.isArray(resources) && resources.length === 0) return void 0;
+          if (!Array.isArray(resources)) resources = [
+            resources
+          ];
+          const result = resources ? Promise.all(resources.map(async (res) => {
+            let resource = await store.get(res["@id"]);
+            if (resource) return resource;
+            resource = new CustomGetter(res["@id"], {
+              "@id": res["@id"]
+            }, this.clientContext, this.serverContext, this.parentId).getProxy();
+            await store.cacheResource(res["@id"], resource);
+            return resource;
+          })) : [];
+          return result;
+        }
+      } catch {
+        if (!path.split) return void 0;
+        const path1 = path.split(".");
+        const path2 = [];
+        let value;
+        if (!this.isFullResource()) {
+          await this.getResource(this.resourceId, {
+            ...this.clientContext,
+            ...this.serverContext
+          }, this.parentId);
+        }
+        while (true) {
+          value = await this.getList(path1[0]);
+          if (path1.length <= 1) break;
+          const lastPath1El = path1.pop();
+          if (lastPath1El) path2.unshift(lastPath1El);
+        }
+        if (path2.length === 0) {
+          if (!value || !value["@id"]) return this.getLiteralValue(value);
+          return await this.getResource(value["@id"], mergeContexts(this.clientContext, this.serverContext), this.parentId || this.resourceId);
+        }
+        if (!value || !value["@id"]) return void 0;
+        const resource = await this.getResource(value["@id"], mergeContexts(this.clientContext, this.serverContext), this.parentId || this.resourceId);
+        store.subscribeResourceTo(this.resourceId, value["@id"]);
+        return resource ? await resource[path2.join(".")] : void 0;
+      }
+    }
+    static getEmptyResource(id, clientContext, parentContext) {
+      return new CustomGetter(id, {
+        "@id": id
+      }, clientContext, parentContext).getProxy();
+    }
+    getLiteralValue(value) {
+      if (typeof value !== "object" || value === null) return value;
+      if (value["@value"]) return value["@value"];
+      if (!Array.isArray(value)) return value;
+      if (value.length === 0) return null;
+      if (!Array.isArray(value[0])) return value;
+      const ln = store._getLanguage();
+      let translatedValue = value.find((v) => v["@language"] && v["@language"] === ln);
+      if (!translatedValue) translatedValue = value.find((v) => v["@language"] && v["@language"] === "en");
+      return (translatedValue == null ? void 0 : translatedValue["@value"]) ?? null;
+    }
+    async getResource(id, context, iriParent, forceFetch = false) {
+      if (id.startsWith("_:b")) return await store.get(id + iriParent);
+      return await store.getData(id, context, iriParent, void 0, forceFetch);
+    }
+    isContainer() {
+      if (this.resource["@type"]) {
+        if (Array.isArray(this.resource["@type"])) return this.listTypes.some((type) => this.resource["@type"].includes(type));
+        return this.listTypes.includes(this.resource["@type"]);
+      }
+      if (!this.resource.type) return false;
+      if (Array.isArray(this.resource.type)) return this.listTypes.some((type) => this.resource.type.includes(type));
+      return this.listTypes.includes(this.resource.type);
+    }
+    isArray() {
+      if (Array.isArray(this.resource)) return true;
+      return false;
+    }
+    getProperties() {
+      return Object.keys(this.resource).map((prop) => this.getCompactedPredicate(prop));
+    }
+    async getList(predicateName) {
+      let value = await this.resource[predicateName];
+      if (!value) {
+        const index = this.getExpandedPredicate(predicateName);
+        if (index) {
+          value = await this.resource[index];
+        }
+      }
+      if (value === void 0 || value === null) {
+        return [];
+      }
+      return value;
+    }
+    async getListAndCacheIt(predicate) {
+      let children = await this.getList(predicate);
+      if (!children) return null;
+      if (!Array.isArray(children)) children = [
+        children
+      ];
+      const result = children ? await Promise.all(children.map(async (res) => {
+        let resource = await store.get(res["@id"]);
+        if (resource) return resource;
+        resource = new CustomGetter(res["@id"], {
+          "@id": res["@id"]
+        }, this.clientContext, this.serverContext, this.parentId).getProxy();
+        await store.cacheResource(res["@id"], resource);
+        return resource;
+      })) : [];
+      return result;
+    }
+    async getDcatDataset() {
+      return await this.getListAndCacheIt("dcat:dataset");
+    }
+    async getLdpContains() {
+      return await this.getListAndCacheIt("ldp:contains");
+    }
+    merge(resource) {
+      this.resource = {
+        ...this.getResourceData(),
+        ...resource.getResourceData()
+      };
+    }
+    getResourceData() {
+      return this.resource;
+    }
+    async getContainerList() {
+      if (this.hasType("ldp:Container")) {
+        return await this.getLdpContains();
+      }
+      if (this.getType() === "dcat:Catalog") {
+        return await this.getDcatDataset();
+      }
+      return null;
+    }
+    isFullResource() {
+      const propertiesKeys = Object.keys(this.resource).filter((p) => !p.startsWith("@"));
+      if (this.resource["@id"].startsWith("_:b")) return true;
+      if (propertiesKeys.length === 1 && propertiesKeys[0] === this.getExpandedPredicate("permissions")) return false;
+      if (propertiesKeys.length > 0) return true;
+      return false;
+    }
+    async getPermissions() {
+      const perms = this.getExpandedPredicate("permissions");
+      if (!perms) return [];
+      let permissions = this.resource[perms];
+      if (!permissions) {
+        await this.getResource(this.resourceId, {
+          ...this.clientContext,
+          ...this.serverContext
+        }, this.parentId, true);
+        permissions = this.resource[perms];
+      }
+      if (!Array.isArray(permissions)) permissions = [
+        permissions
+      ];
+      return permissions ? permissions : [];
+    }
+    getType() {
+      if (Array.isArray(this.resource["@type"])) {
+        return this.resource["@type"].map((type) => this.getCompactedIri(type));
+      }
+      return this.resource["@type"] ? this.getCompactedIri(this.resource["@type"]) : "";
+    }
+    hasType(type) {
+      const types = this.getType();
+      if (!types) return false;
+      if (Array.isArray(types)) {
+        return types.includes(this.getCompactedIri(type));
+      }
+      return types === this.getCompactedIri(type);
+    }
+    async clearCache() {
+      await store.clearCache(this.resourceId);
+    }
+    getExpandedPredicate(property) {
+      const context = normalizeContext(mergeContexts(this.clientContext, this.serverContext));
+      return context.expandTerm(property, true);
+    }
+    getCompactedPredicate(property) {
+      const context = normalizeContext(mergeContexts(this.clientContext, this.serverContext));
+      return context.compactIri(property, true);
+    }
+    getCompactedIri(id) {
+      const context = normalizeContext(mergeContexts(this.clientContext, this.serverContext));
+      return context.compactIri(id);
+    }
+    toString() {
+      return this.getCompactedIri(this.resource["@id"]);
+    }
+    [Symbol.toPrimitive]() {
+      return this.getCompactedIri(this.resource["@id"]);
+    }
+    getProxy() {
+      return new Proxy(this, {
+        get: (resource, property) => {
+          if (!this.resource) return void 0;
+          if (typeof resource[property] === "function") return resource[property].bind(resource);
+          switch (property) {
+            case "@id":
+              if (this.resource["@id"]) return this.getCompactedIri(this.resource["@id"]);
+              return;
+            case "@type":
+              return this.resource["@type"];
+            case "properties":
+              return this.getProperties();
+            case "ldp:contains":
+            case "listPredicate":
+              return this.getContainerList();
+            case "permissions":
+              return this.getPermissions();
+            case "clientContext":
+              return getRawContext(this.clientContext);
+            case "serverContext":
+              return getRawContext(this.serverContext);
+            case "then":
+              return;
+            default:
+              return resource.get(property);
+          }
+        }
+      });
+    }
+  };
+});
+export {
+  CustomGetter,
+  __tla
+};

package/dist/{fr-ClQZ5-J-.js → fr-BZZDTsmw.js}

@@ -1,7 +1,7 @@
 const fr = {
-  "autocompletion.placeholder": "Sélectionner une valeur",
+  "autocompletion.placeholder": "S\xE9lectionner une valeur",
   "autocompletion.searchPlaceholder": "Rechercher",
-  "autocompletion.searchText": "Aucun résultat",
+  "autocompletion.searchText": "Aucun r\xE9sultat",
   "solid-delete.button": "Supprimer",
   "solid-form.submit-button": "Envoyer",
   "solid-form.validation-error": "Erreur de validation.",

package/dist/{helpers-4GFJ8HI8.js → helpers-dFpcGbvl.js}

@@ -1861,7 +1861,7 @@ function fuzzyCompare(subject, search) {
   return compareTransform(subject).includes(compareTransform(String(search)));
 }
 function compareTransform(str) {
-  return str.normalize("NFD").replaceAll(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replaceAll("œ", "oe").replaceAll("æ", "ae").replaceAll(/[ ,.!?;:-`"]+/g, " ").trim();
+  return str.normalize("NFD").replaceAll(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replaceAll("\u0153", "oe").replaceAll("\xE6", "ae").replaceAll(/[ ,.!?;:-`"]+/g, " ").trim();
 }
 const compare = {
   string(subject, query) {
@@ -2089,12 +2089,12 @@ export {
   importInlineCSS as i,
   importCSS as j,
   helpers as k,
-  getRawContext as l,
-  mergeContexts as m,
+  isUrlOrRelativePath as l,
+  jsonldContextParserExports as m,
   normalizeContext as n,
-  isUrlOrRelativePath as o,
+  getRawContext as o,
   parseFieldsString as p,
-  jsonldContextParserExports as q,
+  mergeContexts as q,
   stringToDom as r,
   setDeepProperty as s,
   transformArrayToContainer as t,

package/dist/helpers.js

@@ -1,4 +1,4 @@
-import { A, h, y, c, A as A2, d, a, x, e, f, b, g, l, j, i, v, o, w, m, n, p, s, r, t, u } from "./helpers-4GFJ8HI8.js";
+import { A, h, y, c, A as A2, d, a, x, e, f, b, g, o, j, i, v, l, w, q, n, p, s, r, t, u } from "./helpers-dFpcGbvl.js";
 export {
   A as AsyncIterableBuilder,
   h as asyncQuerySelector,
@@ -12,13 +12,13 @@ export {
   f as findClosingBracketMatchIndex,
   b as fuzzyCompare,
   g as generalComparator,
-  l as getRawContext,
+  o as getRawContext,
   j as importCSS,
   i as importInlineCSS,
   v as importJS,
-  o as isUrlOrRelativePath,
+  l as isUrlOrRelativePath,
   w as loadScript,
-  m as mergeContexts,
+  q as mergeContexts,
   n as normalizeContext,
   p as parseFieldsString,
   s as setDeepProperty,