@startinblox/core 2.0.5 → 2.0.6-beta.2

package/README.md

@@ -21,6 +21,8 @@ npm run dev
 
 You can now see examples at [http://127.0.0.1:3000](http://127.0.0.1:3000/).
 
+
+
 ## Adding new features
 To develop new features for `sib-core`, you can add an HTML example file in `/examples` directory and link it in `/index.html`.
 Don't forget to import the framework:
@@ -30,6 +32,9 @@ Don't forget to import the framework:
 ```
 You can now write HTML using `sib-core` and test it in your browser.
 
+## Documentation
+
+- **[Store API Documentation](./docs/store.md)** - Comprehensive guide to the StartinBlox Store API, including data retrieval, manipulation, and advanced querying capabilities.
 
 ## Testing
 

package/dist/custom-getter-C9i4kdAJ.js

@@ -0,0 +1,440 @@
+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, o as getRawContext, n as normalizeContext } from "./helpers-vZrb1UDN.js";
+import { S as StoreService } from "./store-DI-dmiKR.js";
+const store = StoreService.getInstance();
+class CustomGetter {
+  // search attributes to give to server
+  constructor(resourceId, resource, clientContext, serverContext, parentId = "", serverPagination = {}, serverSearch = {}) {
+    __publicField(this, "resource");
+    // content of the requested resource
+    __publicField(this, "resourceId");
+    __publicField(this, "clientContext");
+    // context given by the app
+    __publicField(this, "serverContext");
+    // context given by the server
+    __publicField(this, "parentId");
+    // id of the parent resource, used to get the absolute url of the current resource
+    __publicField(this, "listTypes");
+    // types of resources interpreted as containers
+    __publicField(this, "serverPagination");
+    // pagination attributes to give to server
+    __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);
+  }
+  /**
+   * 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;
+    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 = this.resource[path1[0]];
+        if (!value) {
+          const expandedPath = this.getExpandedPredicate(path1[0]);
+          if (expandedPath) {
+            value = this.resource[expandedPath];
+          }
+        }
+        if (!value) {
+          value = await this.getList(path1[0]);
+          if (Array.isArray(value) && value.length === 0) {
+            value = void 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);
+        const valueKeys = Object.keys(value).filter((k) => k !== "@type");
+        if (valueKeys.length === 1 && valueKeys[0] === "@id") {
+          const cachedResource = await store.get(value["@id"]);
+          if (cachedResource) {
+            return cachedResource;
+          }
+          try {
+            const mergedContext = mergeContexts(
+              this.clientContext,
+              this.serverContext
+            );
+            const rawContext = getRawContext(mergedContext);
+            const pathsToCheck = [path];
+            try {
+              const expandedPath = this.getExpandedPredicate(path);
+              if (expandedPath && expandedPath !== path) {
+                pathsToCheck.push(expandedPath);
+              }
+            } catch (_expandError) {
+            }
+            for (const pathToCheck of pathsToCheck) {
+              if ((rawContext == null ? void 0 : rawContext[pathToCheck]) && typeof rawContext[pathToCheck] === "object" && rawContext[pathToCheck]["@type"] === "@id") {
+                return value["@id"];
+              }
+            }
+          } catch (error) {
+            console.warn("Context parsing failed in CustomGetter:", error);
+          }
+          try {
+            const resource2 = await this.getResource(
+              value["@id"],
+              mergeContexts(this.clientContext, this.serverContext),
+              this.parentId || this.resourceId
+            );
+            if (resource2 !== null) {
+              return resource2;
+            }
+          } catch (fetchError) {
+            console.warn("Failed to fetch resource:", value["@id"], fetchError);
+          }
+          return value["@id"];
+        }
+        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();
+  }
+  /**
+   * Return value depending of the current language
+   * @param value
+   * @returns
+   */
+  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;
+  }
+  /**
+   * 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 await store.get(id + iriParent);
+    return await store.getData(
+      id,
+      context,
+      iriParent,
+      void 0,
+      forceFetch
+    );
+  }
+  /**
+   * Return true if the resource is a container
+   */
+  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);
+  }
+  /**
+   * 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
+   */
+  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");
+  }
+  /**
+   * Get children of container as Proxys
+   */
+  async getLdpContains() {
+    return await this.getListAndCacheIt("ldp:contains");
+  }
+  merge(resource) {
+    this.resource = {
+      ...this.getResourceData(),
+      ...resource.getResourceData()
+    };
+  }
+  getResourceData() {
+    return this.resource;
+  }
+  /**
+   * Get the list of resources associated with the list predicate of the resource
+   * If the resource is a container, it will return the ldp:contains list
+   * If the resource is a dcat:Catalog, it will return the dcat:dataset list
+   * If the resource is not a container or a catalog, it will return null
+   * @returns object[] | null
+   */
+  async getContainerList() {
+    if (this.hasType("ldp:Container")) {
+      return await this.getLdpContains();
+    }
+    if (this.getType() === "dcat:Catalog") {
+      return await this.getDcatDataset();
+    }
+    return null;
+  }
+  /**
+   * return true if resource seems complete
+   * A resource is considered complete if it has at least one property which is not a permission
+   */
+  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;
+  }
+  /**
+   * Get permissions of a resource
+   * @param resourceId
+   * @returns
+   */
+  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 : [];
+  }
+  /**
+   * returns compacted @type of resource
+   */
+  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"]) : "";
+  }
+  /**
+   * Check if the resource has a specific type
+   * @param 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);
+  }
+  /**
+   * Remove the resource from the cache
+   */
+  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"]);
+  }
+  /**
+   * Returns a Proxy which handles the different get requests
+   */
+  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"];
+          // return synchronously
+          case "properties":
+            return this.getProperties();
+          case "ldp:contains":
+          case "listPredicate":
+            return this.getContainerList();
+          // returns standard arrays synchronously
+          case "permissions":
+            return this.getPermissions();
+          // get expanded permissions
+          case "clientContext":
+            return getRawContext(this.clientContext);
+          // get saved client context to re-fetch easily a resource
+          case "serverContext":
+            return getRawContext(this.serverContext);
+          // get saved client context to re-fetch easily a resource
+          case "then":
+            return;
+          default:
+            return resource.get(property);
+        }
+      }
+    });
+  }
+}
+export {
+  CustomGetter
+};

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-vZrb1UDN.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) {
@@ -2078,29 +2078,32 @@ const helpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 }, Symbol.toStringTag, { value: "Module" }));
 export {
   AsyncIterableBuilder as A,
-  doesResourceContainList as a,
-  fuzzyCompare as b,
-  compare as c,
+  domIsReady as B,
+  asyncQuerySelectorAll as C,
+  asyncQuerySelector as a,
+  importCSS as b,
+  doesResourceContainList as c,
   defineComponent as d,
-  evalTemplateString as e,
-  findClosingBracketMatchIndex as f,
-  generalComparator as g,
-  asyncQuerySelector as h,
+  findClosingBracketMatchIndex as e,
+  fuzzyCompare as f,
+  evalTemplateString as g,
+  compare as h,
   importInlineCSS as i,
-  importCSS as j,
+  generalComparator 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,
-  stringToDom as r,
+  mergeContexts as q,
+  requireJsonldContextParser as r,
   setDeepProperty as s,
   transformArrayToContainer as t,
   uniqID as u,
-  importJS as v,
-  loadScript as w,
-  domIsReady as x,
-  asyncQuerySelectorAll as y
+  requireErrorCoded as v,
+  requireLink as w,
+  stringToDom as x,
+  importJS as y,
+  loadScript as z
 };

package/dist/helpers.js

@@ -1,28 +1,28 @@
-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, a, C, h, A as A2, d, c, B, g, e, f, j, o, b, i, y, l, z, q, n, p, s, x, t, u } from "./helpers-vZrb1UDN.js";
 export {
   A as AsyncIterableBuilder,
-  h as asyncQuerySelector,
-  y as asyncQuerySelectorAll,
-  c as compare,
+  a as asyncQuerySelector,
+  C as asyncQuerySelectorAll,
+  h as compare,
   A2 as default,
   d as defineComponent,
-  a as doesResourceContainList,
-  x as domIsReady,
-  e as evalTemplateString,
-  f as findClosingBracketMatchIndex,
-  b as fuzzyCompare,
-  g as generalComparator,
-  l as getRawContext,
-  j as importCSS,
+  c as doesResourceContainList,
+  B as domIsReady,
+  g as evalTemplateString,
+  e as findClosingBracketMatchIndex,
+  f as fuzzyCompare,
+  j as generalComparator,
+  o as getRawContext,
+  b as importCSS,
   i as importInlineCSS,
-  v as importJS,
-  o as isUrlOrRelativePath,
-  w as loadScript,
-  m as mergeContexts,
+  y as importJS,
+  l as isUrlOrRelativePath,
+  z as loadScript,
+  q as mergeContexts,
   n as normalizeContext,
   p as parseFieldsString,
   s as setDeepProperty,
-  r as stringToDom,
+  x as stringToDom,
   t as transformArrayToContainer,
   u as uniqID
 };