@startinblox/components-ds4go 1.0.0

package/src/components/solid-fact-bundle.ts

@@ -0,0 +1,225 @@
+import { formatDate, OrbitComponent, requestNavigation, sort } from "@helpers";
+import { msg } from "@lit/localize";
+import { Task } from "@lit/task";
+import type { PropertiesPicker, Resource, SearchObject } from "@src/component";
+import { css, html, nothing } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+
+@customElement("solid-fact-bundle")
+export class SolidFactBundle extends OrbitComponent {
+  static styles = css`
+    .modal {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background-color: rgba(0, 2, 49, 0.2);
+      z-index: 9999;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+    }
+  `;
+
+  @property({ attribute: "header", type: String })
+  header?: string = "DS4GO Fact Bundling";
+
+  @state()
+  search: SearchObject[] = [];
+
+  @state()
+  resultCount = this.objects?.length || 0;
+
+  cherryPickedProperties: PropertiesPicker[] = [
+    { key: "created_at", value: "created_at", cast: formatDate },
+    { key: "updated_at", value: "updated_at", cast: formatDate },
+    { key: "name", value: "name" },
+    { key: "description", value: "description" },
+  ];
+
+  async _responseAdaptator(response: Resource): Promise<Resource> {
+    if (response?._originalResource?.hasType("ds4go:FactBundle")) {
+      response.facts = await Promise.all(
+        (await response._originalResource["ldp:contains"]).map(
+          (fact: Resource) => {
+            return this._getProxyValue(fact["@id"], false, [
+              { key: "updated_at", value: "updated_at", cast: formatDate },
+              { key: "name", value: "name" },
+              { key: "description", value: "description" },
+              {
+                key: "categories",
+                value: "categories",
+                expand: true,
+                cast: (c: Resource[]) => sort(c, "name"),
+              },
+              { key: "author", value: "author" },
+              { key: "link", value: "link" },
+              { key: "enclosure", value: "enclosure" },
+              { key: "medias", value: "medias", expand: true },
+              { key: "url", value: "url" },
+              { key: "file_size", value: "file_size" },
+              { key: "file_type", value: "file_type" },
+              { key: "width", value: "width" },
+              { key: "height", value: "height" },
+              // Can't get raw review json, as store does not support datas without ids
+              // { key: "review", value: "review" },
+            ]);
+          },
+        ),
+      );
+      console.log(response.facts);
+    }
+    return Promise.resolve(response);
+  }
+
+  async _afterAttach() {
+    this.menuComponent = document.querySelector(
+      `[uniq="${this.orbit?.getComponent("menu")?.uniq}"]`,
+    );
+
+    return Promise.resolve();
+  }
+
+  _getResource = new Task(this, {
+    task: async ([dataSrc, objSrc]) => {
+      if (
+        (!dataSrc && !objSrc) ||
+        !this.orbit ||
+        (!this.noRouter &&
+          this.route &&
+          this.currentRoute &&
+          !this.route.startsWith(this.currentRoute))
+      )
+        return;
+
+      if (!this.menuComponent.ready) {
+        await new Promise((resolve) => {
+          this.menuComponent.addEventListener("user-ready", () => {
+            resolve(true);
+          });
+        });
+      }
+
+      this.displayFiltering = !this.component.parameters.disableFiltering;
+
+      if (!this.hasCachedDatas || this.oldDataSrc !== dataSrc) {
+        if (!dataSrc) return;
+
+        this.objects = (await this._getProxyValue(dataSrc)) as Resource[];
+        this.hasCachedDatas = true;
+      }
+
+      if (this.oldDataSrc !== dataSrc) {
+        this.oldDataSrc = dataSrc;
+      }
+
+      if (!Array.isArray(this.objects)) {
+        this.objects = [];
+      }
+
+      this.object = this.objects.find((obj: Resource) => obj["@id"] === objSrc);
+
+      return sort(this.objects, "name", "asc");
+    },
+    args: () => [
+      this.defaultDataSrc,
+      this.dataSrc,
+      this.caching,
+      this.currentRoute,
+    ],
+  });
+
+  _search(e: Event) {
+    e.preventDefault();
+    this.search = e.detail;
+    this.filterCount = this.search.filter((s) => s.name !== "search").length;
+  }
+
+  _openModal(e: Event) {
+    e.preventDefault();
+    if (this.route) {
+      if ("use-id" in (this.component.routeAttributes || {})) {
+        requestNavigation(this.route, e.detail["@id"]);
+      } else {
+        const rdfType = e.detail["@type"]?.at(-1) ?? e.detail["@type"];
+        if (rdfType) {
+          const compatibleComponents = window.orbit?.components?.filter(
+            (c) => c?.routeAttributes?.["rdf-type"] === rdfType,
+          );
+
+          if (compatibleComponents?.[0]?.route) {
+            requestNavigation(compatibleComponents[0]?.route, e.detail["@id"]);
+          }
+        }
+      }
+    }
+  }
+
+  _closeModal(e: Event) {
+    e.preventDefault();
+    if (this.route) requestNavigation(this.route, this.defaultDataSrc);
+  }
+
+  _closeModalFromBackground(e: Event) {
+    e.preventDefault();
+    if (this.route && e.target?.classList.contains("modal"))
+      requestNavigation(this.route, this.defaultDataSrc);
+  }
+
+  _resultCountUpdate(e: Event) {
+    this.resultCount = e.detail ?? 0;
+  }
+
+  render() {
+    return (
+      this.gatekeeper() ||
+      this._getResource.render({
+        pending: () => html`<solid-loader></solid-loader>`,
+        error: (e) => {
+          console.warn("[solid-fact-bundle] Task error:", e);
+          return nothing;
+        },
+        complete: (datas) => {
+          return html`<tems-viewport>
+            <tems-header slot="header" heading=${this.header}>
+              <div slot="cta">
+                <tems-button
+                  type="primary"
+                  label=${msg("Create a bundle")}
+                ></tems-button>
+              </div>
+            </tems-header>
+            <div slot="content">
+              <tems-catalog-filter-holder
+                .displayFiltering=${this.displayFiltering}
+                @search=${this._search}
+                .search=${this.search}
+                .objects=${datas}
+                .resultCount=${this.resultCount}
+                .filterCount=${this.filterCount}
+              ></tems-catalog-filter-holder>
+              <ds4go-fact-bundle-holder
+                .objects=${datas}
+                .search=${this.search}
+                @clicked=${this._openModal}
+                @result-count=${this._resultCountUpdate}
+              ></ds4go-fact-bundle-holder>
+              ${this.object
+                ? html`<div
+                    class="modal"
+                    @click=${this._closeModalFromBackground}
+                  >
+                    <ds4go-fact-bundle-modal
+                      .object=${this.object}
+                      @close=${this._closeModal}
+                    ></ds4go-fact-bundle-modal>
+                  </div>`
+                : nothing}
+            </div>
+          </tems-viewport>`;
+        },
+      })
+    );
+  }
+}

package/src/context.json

@@ -0,0 +1 @@
+{}

package/src/helpers/components/ResourceMapper.ts

@@ -0,0 +1,450 @@
+/**
+ * Resource Mapper Service
+ *
+ * Provides unified, configurable mapping from source data formats (FC self-descriptions,
+ * DSP datasets, etc.) to TEMS-compatible resource objects with LDP containers.
+ *
+ * Architecture:
+ * - Stores (sib-core): Fetch raw data
+ * - ResourceMapper (solid-tems): Transform raw data to TEMS format
+ * - Components (solid-tems): Configure mapper and render UI
+ *
+ * Usage:
+ * ```typescript
+ * const mapper = new ResourceMapper(fcMappingConfig);
+ * const temsResource = mapper.map(sourceData, context);
+ * ```
+ */
+
+// import type { Resource } from '@startinblox/core';
+
+// ============================================================================
+// Types and Interfaces
+// ============================================================================
+
+export interface ResourceMapperConfig {
+  /**
+   * Base field mappings (simple property extractions)
+   */
+  baseFields: Record<string, FieldMapping>;
+
+  /**
+   * LDP Container field mappings (arrays wrapped in ldp:Container)
+   */
+  containerFields?: Record<string, ContainerFieldMapping>;
+
+  /**
+   * Nested object mappings
+   */
+  nestedObjects?: Record<string, NestedObjectMapping>;
+
+  /**
+   * Contract negotiation field mappings
+   */
+  contractFields?: Record<string, FieldMapping>;
+
+  /**
+   * Optional custom post-processing function
+   */
+  postProcess?: (resource: Resource, source: any, context: MappingContext) => Resource;
+}
+
+export interface FieldMapping {
+  /**
+   * Path to source value (array of keys to traverse)
+   */
+  source: string[];
+
+  /**
+   * Optional transform function
+   */
+  transform?: (value: any, source: any, context: MappingContext) => any;
+
+  /**
+   * Optional fallback if source is not found
+   */
+  fallback?: string | ((source: any, context: MappingContext) => any);
+
+  /**
+   * Optional default value if source and fallback are not found
+   */
+  defaultValue?: any;
+}
+
+export interface ContainerFieldMapping {
+  /**
+   * Path to source array
+   */
+  source: string[];
+
+  /**
+   * LDP container type (e.g., 'ldp:Container')
+   */
+  containerType: string;
+
+  /**
+   * Item type for contained objects (e.g., 'tems:Category')
+   */
+  itemType: string;
+
+  /**
+   * Field mappings for each item
+   */
+  itemFields: Record<string, (item: any, index: number, context: MappingContext) => any>;
+
+  /**
+   * Optional filter function to include/exclude items
+   */
+  filter?: (item: any, index: number, context: MappingContext) => boolean;
+
+  /**
+   * Optional transform for the entire array before item mapping
+   */
+  transform?: (value: any, source: any, context: MappingContext) => any[];
+}
+
+export interface NestedObjectMapping {
+  /**
+   * Path to source object
+   */
+  source: string[];
+
+  /**
+   * Field mappings for the nested object
+   */
+  fields: Record<string, string[] | FieldMapping>;
+
+  /**
+   * Optional type for the nested object
+   */
+  type?: string;
+}
+
+export interface MappingContext {
+  /**
+   * Base URL for generating @id values
+   */
+  temsServiceBase?: string;
+  temsCategoryBase?: string;
+  temsImageBase?: string;
+  temsProviderBase?: string;
+
+  /**
+   * Additional context data (provider info, etc.)
+   */
+  [key: string]: any;
+}
+
+// ============================================================================
+// Transform Functions
+// ============================================================================
+
+/**
+ * Strips URN prefixes from IDs
+ */
+export function stripUrnPrefix(value: string | undefined): string {
+  if (!value) return '';
+  return value
+    .replace(/^urn:uuid:/i, '')
+    .replace(/^urn:tems:/i, '');
+}
+
+/**
+ * Processes ODRL policy: strips URN prefixes and adds target field
+ */
+export function processPolicyTransform(
+  policy: any,
+  source: any,
+  _context: MappingContext
+): any {
+  if (!policy) return null;
+
+  const processedPolicy = JSON.parse(JSON.stringify(policy)); // Deep clone
+
+  // Strip URN prefix from policy @id
+  if (processedPolicy['@id']) {
+    processedPolicy['@id'] = stripUrnPrefix(processedPolicy['@id']);
+  }
+
+  // Add target field (asset ID)
+  const assetId = getNestedValue(source, ['@id']) || '';
+  processedPolicy['target'] = stripUrnPrefix(assetId);
+
+  return processedPolicy;
+}
+
+/**
+ * Extracts first value from array or returns the value itself
+ */
+export function firstOrSelf(value: any): any {
+  return Array.isArray(value) && value.length > 0 ? value[0] : value;
+}
+
+/**
+ * Generates unique ID based on name
+ */
+export function generateIdFromName(name: string, base: string): string {
+  const slug = name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return `${base}${slug}`;
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Gets nested value from object using path array
+ */
+export function getNestedValue(obj: any, path: string[]): any {
+  // If path is empty, return undefined (don't return the entire object)
+  // Empty paths are used when the field should be computed via transform or use defaultValue
+  if (path.length === 0) {
+    return undefined;
+  }
+
+  let current = obj;
+  for (const key of path) {
+    if (current === null || current === undefined) {
+      return undefined;
+    }
+    current = current[key];
+  }
+  return current;
+}
+
+/**
+ * Sets nested value in object using path array
+ */
+export function setNestedValue(obj: any, path: string[], value: any): void {
+  if (path.length === 0) return;
+
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (!(key in current)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[path[path.length - 1]] = value;
+}
+
+// ============================================================================
+// ResourceMapper Class
+// ============================================================================
+
+export class ResourceMapper {
+  private config: ResourceMapperConfig;
+
+  constructor(config: ResourceMapperConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Maps source data to TEMS-compatible resource
+   */
+  map(source: any, context: MappingContext = {}): Resource {
+    const resource: Resource = {};
+
+    // Map base fields
+    for (const [destKey, mapping] of Object.entries(this.config.baseFields)) {
+      const value = this.mapField(source, mapping, context);
+      if (value !== undefined) {
+        resource[destKey] = value;
+      }
+    }
+
+    // Map container fields
+    if (this.config.containerFields) {
+      for (const [destKey, mapping] of Object.entries(this.config.containerFields)) {
+        const container = this.mapContainerField(source, mapping, context);
+        if (container) {
+          resource[destKey] = container;
+        }
+      }
+    }
+
+    // Map nested objects
+    if (this.config.nestedObjects) {
+      for (const [destKey, mapping] of Object.entries(this.config.nestedObjects)) {
+        const nestedObj = this.mapNestedObject(source, mapping, context);
+        if (nestedObj) {
+          resource[destKey] = nestedObj;
+        }
+      }
+    }
+
+    // Map contract fields
+    if (this.config.contractFields) {
+      for (const [destKey, mapping] of Object.entries(this.config.contractFields)) {
+        const value = this.mapField(source, mapping, context);
+        if (value !== undefined) {
+          resource[destKey] = value;
+        }
+      }
+    }
+
+    // Apply post-processing
+    if (this.config.postProcess) {
+      return this.config.postProcess(resource, source, context);
+    }
+
+    return resource;
+  }
+
+  /**
+   * Maps a single field
+   */
+  private mapField(source: any, mapping: FieldMapping, context: MappingContext): any {
+    // Get source value
+    let value = getNestedValue(source, mapping.source);
+
+    // Apply transform
+    if (mapping.transform) {
+      value = mapping.transform(value, source, context);
+    }
+
+    // Apply fallback
+    if (value === undefined || value === null || value === '') {
+      if (mapping.fallback) {
+        if (typeof mapping.fallback === 'function') {
+          value = mapping.fallback(source, context);
+        } else {
+          // Fallback is a path to another field
+          value = getNestedValue(source, [mapping.fallback]);
+        }
+      }
+    }
+
+    // Apply default value
+    if (value === undefined || value === null || value === '') {
+      value = mapping.defaultValue;
+    }
+
+    return value;
+  }
+
+  /**
+   * Maps a container field (array wrapped in LDP container)
+   */
+  private mapContainerField(
+    source: any,
+    mapping: ContainerFieldMapping,
+    context: MappingContext
+  ): any {
+    // Get source array
+    let sourceArray = getNestedValue(source, mapping.source);
+
+    if (!sourceArray) {
+      return null;
+    }
+
+    // Apply array-level transform
+    if (mapping.transform) {
+      sourceArray = mapping.transform(sourceArray, source, context);
+    }
+
+    // Ensure it's an array
+    if (!Array.isArray(sourceArray)) {
+      sourceArray = [sourceArray];
+    }
+
+    // Filter items
+    if (mapping.filter) {
+      sourceArray = sourceArray.filter((item, index) =>
+        mapping.filter!(item, index, context)
+      );
+    }
+
+    // Map items
+    const items = sourceArray.map((item, index) => {
+      const mappedItem: any = {
+        '@type': mapping.itemType,
+      };
+
+      for (const [fieldKey, fieldFn] of Object.entries(mapping.itemFields)) {
+        const fieldValue = fieldFn(item, index, context);
+        if (fieldValue !== undefined) {
+          mappedItem[fieldKey] = fieldValue;
+        }
+      }
+
+      return mappedItem;
+    });
+
+    // Return LDP container
+    return {
+      '@type': mapping.containerType,
+      'ldp:contains': items,
+    };
+  }
+
+  /**
+   * Maps a nested object
+   */
+  private mapNestedObject(
+    source: any,
+    mapping: NestedObjectMapping,
+    context: MappingContext
+  ): any {
+    // Get source object
+    const sourceObj = getNestedValue(source, mapping.source);
+
+    if (!sourceObj) {
+      return null;
+    }
+
+    const nestedObj: any = {};
+
+    // Add type if specified
+    if (mapping.type) {
+      nestedObj['@type'] = mapping.type;
+    }
+
+    // Map fields
+    for (const [destKey, fieldMapping] of Object.entries(mapping.fields)) {
+      let value: any;
+
+      if (Array.isArray(fieldMapping)) {
+        // Simple path mapping
+        value = getNestedValue(sourceObj, fieldMapping);
+      } else {
+        // Full FieldMapping
+        value = this.mapField(sourceObj, fieldMapping, context);
+      }
+
+      if (value !== undefined) {
+        nestedObj[destKey] = value;
+      }
+    }
+
+    return Object.keys(nestedObj).length > (mapping.type ? 1 : 0) ? nestedObj : null;
+  }
+
+  /**
+   * Unwraps LDP containers (converts ldp:contains arrays to plain arrays)
+   *
+   * This is typically called by components after mapping to simplify data structure
+   * for rendering.
+   */
+  static unwrapLdpContainers(resource: Resource): Resource {
+    const unwrapped: Resource = { ...resource };
+
+    for (const [key, value] of Object.entries(unwrapped)) {
+      if (
+        value &&
+        typeof value === 'object' &&
+        value['@type'] === 'ldp:Container' &&
+        value['ldp:contains']
+      ) {
+        unwrapped[key] = value['ldp:contains'];
+      }
+    }
+
+    return unwrapped;
+  }
+}

package/src/helpers/components/componentObjectHandler.ts

@@ -0,0 +1,22 @@
+import type {
+  LimitedResource,
+  Resource,
+} from "@src/component";
+import { LitElement } from "lit";
+
+export class ComponentObjectHandler extends LitElement {
+  object?: LimitedResource = {
+    "@id": ""
+  };
+
+  isType = (type: string, obj: Resource = (this.object as Resource)) => {
+    const typeValue = obj["@type"];
+    if (Array.isArray(typeValue)) {
+      return typeValue.includes(type);
+    }
+    if (typeof typeValue === "string") {
+      return typeValue === type;
+    }
+    return false;
+  };
+}

package/src/helpers/components/componentObjectsHandler.ts

@@ -0,0 +1,14 @@
+import type { Resource } from "@src/component";
+import { LitElement } from "lit";
+
+import { property } from "lit/decorators.js";
+
+export class ComponentObjectsHandler extends LitElement {
+  @property({ attribute: false })
+  objects?: Resource[] = [];
+
+  hasType = (type: string, objs: Resource[] = this.objects as Resource[]) => {
+    const typeValue = new Set(objs.flatMap((o) => o["@type"]));
+    return typeValue.has(type);
+  };
+}