@piveau/sdk-vue 0.0.0-alpha-2.0

package/dist/integrations/dcatAp/dcatAp.js

@@ -0,0 +1,185 @@
+import { computed, toRef, toValue } from "vue-demi";
+import { SchemaDataset } from "@piveau/sdk-core";
+import { defineHubSearchIntegration } from "../../index.js";
+import { useLocale } from "../../composables/locale.js";
+import { getTranslationFor, nonNullable } from "../../utils/helpers.js";
+import { usePropertyTableDataset, usePropertyTableDistribution } from "./properties.js";
+export function dcatApDataset() {
+  return defineHubSearchIntegration(SchemaDataset, (dataset) => {
+    const {
+      t,
+      d,
+      currentLocale: origCurrentLocale,
+      fallbackLocale: origFallLocale
+    } = useLocale();
+    const ds = toRef(dataset);
+    const currentLocale = toRef(origCurrentLocale);
+    const fallbackLocale = toRef(origFallLocale);
+    const getId = computed(() => ds.value?.id);
+    const getTitle = computed(() => getTranslationFor(ds.value?.title, [currentLocale.value, fallbackLocale.value]));
+    const getDescription = computed(() => getTranslationFor(ds.value?.description, [currentLocale.value, fallbackLocale.value]));
+    const getCategories = computed(() => ds.value?.categories || []);
+    const getPublisher = computed(() => ds.value?.publisher);
+    const getPropertyTable = computed(() => {
+      if (!ds.value)
+        return [];
+      const dataset2 = toValue(ds);
+      const licenses = dataset2.distributions?.flatMap((d2) => d2.license?.id || d2.license?.label || d2.license?.resource).filter(nonNullable) || [];
+      const licenseSet = new Set(licenses);
+      const table = [
+        {
+          type: "node",
+          id: "formats",
+          label: t("__pv.metadata.format"),
+          data: [
+            {
+              type: "value",
+              id: "formatVal",
+              // get unique formats
+              data: [...new Set(dataset2.distributions?.map((distribution) => distribution.format?.label || distribution.format?.id || distribution.format?.resource || "").filter(Boolean) || [])]
+            }
+          ]
+        },
+        {
+          type: "node",
+          id: "author",
+          label: t("__pv.metadata.creator"),
+          data: [
+            {
+              type: "value",
+              id: "authorVal",
+              data: dataset2.creator?.name || dataset2?.publisher?.name || ""
+            }
+          ]
+        },
+        {
+          type: "node",
+          id: "createdAt",
+          label: t("__pv.metadata.created"),
+          data: [
+            {
+              type: "value",
+              id: "createdAtVal",
+              // dataset.issued (iso) to dd.mm.yyyy
+              data: dataset2.issued ? d(dataset2.issued) : "-"
+            }
+          ]
+        },
+        {
+          type: "node",
+          id: "updatedAt",
+          label: t("__pv.metadata.modificationDate"),
+          data: [
+            {
+              type: "value",
+              id: "updatedAtVal",
+              data: dataset2.modified ? d(dataset2.modified) : "-"
+            }
+          ]
+        },
+        {
+          type: "node",
+          id: "categories",
+          label: t("__pv.metadata.categories"),
+          data: [
+            {
+              type: "value",
+              id: "categoriesVal",
+              data: dataset2.categories?.map((category) => {
+                return getTranslationFor(category.label, [currentLocale.value, fallbackLocale.value]) ?? "-";
+              }) || []
+            }
+          ]
+        },
+        {
+          type: "node",
+          id: "license",
+          label: t("__pv.metadata.license"),
+          data: [{
+            type: "value",
+            id: "licenseVal",
+            data: licenseSet.size > 0 ? [...licenseSet] : "-"
+          }]
+        },
+        {
+          type: "node",
+          id: "languages",
+          label: t("__pv.metadata.languages"),
+          data: [
+            {
+              type: "value",
+              id: "languagesVal",
+              data: ds.value?.language?.map((language) => language?.label).filter(nonNullable) || []
+            }
+          ]
+        }
+        // {
+        //   type: 'node',
+        //   id: 'contactPoints',
+        //   label: t('__pv.metadata.contactPoints'),
+        //   data: [
+        //     {
+        //       type: 'value',
+        //       id: 'contactPointsVal',
+        //       data: ds.value?.contact_point?.map(contactPoint => contactPoint.name) || [],
+        //     },
+        //   ],
+        // },
+      ];
+      return table;
+    });
+    const { getPropertyTable: getPropertyTable2 } = usePropertyTableDataset(ds);
+    const getDistributions = computed(() => {
+      if (!ds.value)
+        return [];
+      const dataset2 = toValue(ds);
+      return dataset2.distributions?.map((dist) => {
+        const { getPropertyTable: propertyTable } = usePropertyTableDistribution(dist);
+        return {
+          /**
+           * The ID of the distribution
+           */
+          id: dist.id,
+          /** The localized title of the distribution */
+          title: dist.title ? getTranslationFor(dist.title, [currentLocale.value, fallbackLocale.value]) : "",
+          /**
+           * The localized description of the distribution
+           */
+          description: dist.description ? getTranslationFor(dist.description, [currentLocale.value, fallbackLocale.value]) : "",
+          /**
+           * The format of the distribution
+           * Fallback order: label, id, resource
+           */
+          format: dist.format?.label || dist.format?.id || dist.format?.resource || "",
+          /**
+           * The modified date of the distribution
+           */
+          modified: dist.modified ? d(dist.modified) : void 0,
+          /**
+           * The license of the distribution
+           */
+          license: dist.license || void 0,
+          created: dist.issued ? d(dist.issued) : void 0,
+          issued: dist.issued ? d(dist.issued) : void 0,
+          languages: dist.language?.map((language) => language?.label).filter(nonNullable) || [],
+          accessUrls: dist.access_url || [],
+          downloadUrls: dist.download_url || [],
+          /**
+           * Opinionated recursive property table
+           */
+          properties: propertyTable.value
+        };
+      });
+    });
+    return {
+      getId,
+      getTitle,
+      getDescription,
+      getCategories,
+      getPublisher,
+      getDistributions,
+      getPropertyTable,
+      getPropertyTable2
+    };
+  });
+}

package/dist/integrations/dcatAp/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dcatAp.js';
+export * from './properties.js';

package/dist/integrations/dcatAp/index.js

@@ -0,0 +1,2 @@
+export * from "./dcatAp.js";
+export * from "./properties.js";

package/dist/integrations/dcatAp/properties.d.ts

@@ -0,0 +1,9 @@
+import type { Dataset, Distribution } from '@piveau/sdk-core';
+import { type MaybeRefOrGetter } from 'vue-demi';
+import type { PropertyTableEntryNode } from '../../utils/propertyTable.js';
+export declare function usePropertyTableDataset(dataset?: MaybeRefOrGetter<Dataset | undefined>): {
+    getPropertyTable: import("vue-demi").ComputedRef<PropertyTableEntryNode[]>;
+};
+export declare function usePropertyTableDistribution(distribution?: MaybeRefOrGetter<Distribution | undefined>): {
+    getPropertyTable: import("vue-demi").ComputedRef<PropertyTableEntryNode[]>;
+};

package/dist/integrations/dcatAp/properties.js

@@ -0,0 +1,142 @@
+import { computed, toRef, toValue } from "vue-demi";
+import { useLocale } from "../../composables/locale.js";
+import { parseResource, parseResourceList, parseUrl, definePropertyNodeCompact as pn } from "../../utils/propertyTable.js";
+import { getTranslationFor } from "../../utils/helpers.js";
+export function usePropertyTableDataset(dataset) {
+  const {
+    t,
+    d,
+    currentLocale: _currentLocale,
+    fallbackLocale: _fallbackLocale
+  } = useLocale();
+  const ds = toRef(dataset);
+  const currentLocale = toRef(_currentLocale);
+  const fallbackLocale = toRef(_fallbackLocale);
+  const getPropertyTable = computed(() => {
+    if (!ds.value)
+      return [];
+    const dataset2 = toValue(ds);
+    const created = pn({ id: "created", label: t("__pv.metadata.created"), help: t("__pv.tooltip.datasetDetails.created"), data: dataset2.issued ? d(dataset2.issued ?? "", "medium") : void 0 });
+    const modified = pn({ id: "modified", label: t("__pv.metadata.modificationDate"), help: t("__pv.tooltip.datasetDetails.modified"), data: dataset2.modified ? d(dataset2.modified ?? "", "medium") : void 0 });
+    const landingPage = pn({ id: "landingPage", label: t("__pv.metadata.landingPage"), help: t("__pv.tooltip.datasetDetails.landingPage"), data: parseResourceList(dataset2.landing_page, "landingPageVal") });
+    const sources = pn({ id: "sources", label: t("__pv.metadata.sources"), help: t("__pv.tooltip.datasetDetails.sources"), data: dataset2.source });
+    const languages = pn({ id: "languages", label: t("__pv.metadata.languages"), help: t("__pv.tooltip.datasetDetails.languages"), data: parseResourceList(dataset2.language) });
+    const publisher = pn({ id: "publisher", label: t("__pv.metadata.publisher"), help: t("__pv.tooltip.datasetDetails.publisher"), data: [
+      pn({ id: "publisherName", label: t("__pv.metadata.name"), help: t("__pv.tooltip.datasetDetails.publisherName"), data: dataset2.publisher?.name }),
+      pn({ id: "publisherHomepage", label: t("__pv.metadata.homepage"), help: t("__pv.tooltip.datasetDetails.publisherHomepage"), data: parseUrl(dataset2.publisher?.homepage) }),
+      pn({ id: "publisherEmail", label: t("__pv.metadata.email"), help: t("__pv.tooltip.datasetDetails.publisherEmail"), data: dataset2.publisher?.email })
+    ] });
+    const contactPointItems = dataset2.contact_point ? dataset2.contact_point.map((contactPoint2) => {
+      return pn({ id: "contactPoint", label: contactPoint2.name || contactPoint2.organisation_name || "", data: [
+        pn({ id: "contactPointName", label: t("__pv.metadata.name"), help: t("__pv.tooltip.datasetDetails.contactPointName"), data: contactPoint2.name }),
+        pn({ id: "contactPointOrganization", label: t("__pv.metadata.organizationName"), help: t("__pv.tooltip.datasetDetails.contactPointOrganisationName"), data: contactPoint2.organisation_name }),
+        pn({ id: "contactPointEmail", label: t("__pv.metadata.email"), help: t("__pv.tooltip.datasetDetails.contactPointEmail"), data: contactPoint2.email }),
+        pn({ id: "contactPointTelephone", label: t("__pv.metadata.telephone"), help: t("__pv.tooltip.datasetDetails.contactPointTelephone"), data: contactPoint2.telephone }),
+        pn({ id: "contactPointAddressCity", label: t("__pv.metadata.address"), help: t("__pv.tooltip.datasetDetails.contactPointAdressCity"), data: contactPoint2.address }),
+        pn({ id: "contactPointUrl", label: t("__pv.metadata.url"), help: t("__pv.tooltip.datasetDetails.contactPointUrl"), data: contactPoint2.url })
+      ] });
+    }) : [];
+    const contactPoint = pn({ id: "contactPoint", label: t("__pv.metadata.contactPoints"), help: t("__pv.tooltip.datasetDetails.contactPoints"), data: contactPointItems });
+    const catalogRecord = pn({ id: "catalogRecord", label: t("__pv.metadata.catalogRecord"), help: t("__pv.tooltip.datasetDetails.catalogRecord"), data: [
+      `${t("__pv.metadata.created")} ${d(dataset2.catalog_record?.issued ?? "", "medium")}`,
+      `${t("__pv.metadata.modificationDate")} ${d(dataset2.catalog_record?.modified ?? "", "medium")}`
+    ] });
+    const conformsTo = pn({ id: "conformsTo", label: t("__pv.metadata.conformsTo"), help: t("__pv.tooltip.datasetDetails.conformsTo"), data: parseResourceList(dataset2.conforms_to) });
+    const provenance = pn({ id: "provenance", label: t("__pv.metadata.provenances"), help: t("__pv.tooltip.datasetDetails.provenance"), data: parseResourceList(dataset2.provenance) });
+    const identifiers = pn({ id: "identifiers", label: t("__pv.metadata.identifiers"), help: t("__pv.tooltip.datasetDetails.identifiers"), data: dataset2.identifier });
+    const admsIdentifierItems = dataset2.adms_identifier ? dataset2.adms_identifier.map((adms) => {
+      return pn({ id: "admsIdentifier", label: "", data: [
+        `${t("__pv.metadata.identifier")} ${adms.identifier}`,
+        `${t("__pv.metadata.scheme")} ${adms.scheme}`
+      ] });
+    }) : [];
+    const admsIdentifiers = pn({ id: "admsIdentifiers", label: t("__pv.metadata.otherIdentifiers"), help: t("__pv.tooltip.datasetDetails.otherIdentifiers"), data: admsIdentifierItems });
+    const resource = pn({ id: "resource", label: t("__pv.metadata.resource"), help: t("__pv.tooltip.datasetDetails.resources"), data: dataset2.resource });
+    const accessRight = pn({ id: "accessRight", label: t("__pv.metadata.accessRights"), help: t("__pv.tooltip.datasetDetails.accessRights"), data: parseResource(dataset2.access_right) });
+    const accrualPeriodicity = pn({ id: "accrualPeriodicity", label: t("__pv.metadata.accrualPeriodicity"), help: t("__pv.tooltip.datasetDetails.accrualPeriodicity"), data: parseResource(dataset2.accrual_periodicity) });
+    const hasVersion = pn({ id: "hasVersion", label: t("__pv.metadata.hasVersion"), help: t("__pv.tooltip.datasetDetails.hasVersion"), data: dataset2.has_version });
+    const isVersionOf = pn({ id: "isVersionOf", label: t("__pv.metadata.isVersionOf"), help: t("__pv.tooltip.datasetDetails.isVersionOf"), data: dataset2.is_version_of });
+    const temporal = pn({ id: "temporal", label: t("__pv.metadata.temporal"), help: t("__pv.tooltip.datasetDetails.temporalCoverage"), data: dataset2.temporal && dataset2.temporal.map(
+      (t2) => `${d(t2.gte, "medium")} - ${d(t2.lte, "medium")}`
+    ) });
+    const versionInfo = pn({ id: "version", label: t("__pv.metadata.versionInfo"), help: t("__pv.tooltip.datasetDetails.versionInfo"), data: dataset2.version_info });
+    const versionNotes = pn({ id: "versionNotes", label: t("__pv.metadata.versionNotes"), help: t("__pv.tooltip.datasetDetails.versionNotes"), data: getTranslationFor(dataset2.version_notes, [currentLocale.value, fallbackLocale.value]) });
+    const isReferencedBy = pn({ id: "isReferencedBy", label: t("__pv.metadata.isReferencedBy"), help: t("__pv.tooltip.datasetDetails.isReferencedBy"), data: dataset2.is_referenced_by });
+    const qualifiedRelationItems = dataset2.qualified_relation ? dataset2.qualified_relation.map((relation) => {
+      return pn({ id: "qualifiedRelation", label: "", data: [
+        `${t("__pv.metadata.relation")} ${relation.relation}`,
+        `${t("__pv.metadata.role")} ${relation.had_role}`
+      ] });
+    }) : [];
+    const qualifiedRelation = pn({ id: "qualifiedRelation", label: t("__pv.metadata.qualifiedRelation"), help: t("__pv.tooltip.datasetDetails.qualifiedRelation"), data: qualifiedRelationItems });
+    const sample = pn({ id: "sample", label: t("__pv.metadata.sample"), help: t("__pv.tooltip.datasetDetails.sample"), data: dataset2.sample });
+    const type = pn({ id: "type", label: t("__pv.metadata.type"), help: t("__pv.tooltip.datasetDetails.type"), data: parseResource(dataset2.type) });
+    const temporalResolution = pn({ id: "temporalResolution", label: t("__pv.metadata.temporalResolution"), help: t("__pv.tooltip.datasetDetails.temporalResolution"), data: dataset2.temporal_resolution });
+    const table = [
+      created,
+      modified,
+      landingPage,
+      sources,
+      languages,
+      publisher,
+      contactPoint,
+      catalogRecord,
+      conformsTo,
+      provenance,
+      identifiers,
+      admsIdentifiers,
+      resource,
+      accessRight,
+      accrualPeriodicity,
+      hasVersion,
+      isVersionOf,
+      temporal,
+      versionInfo,
+      versionNotes,
+      isReferencedBy,
+      qualifiedRelation,
+      sample,
+      type,
+      temporalResolution
+    ];
+    return table;
+  });
+  return {
+    getPropertyTable
+  };
+}
+export function usePropertyTableDistribution(distribution) {
+  const {
+    t,
+    d,
+    n,
+    currentLocale: _currentLocale,
+    fallbackLocale: _fallbackLocale
+  } = useLocale();
+  const dist = toRef(distribution);
+  const getPropertyTable = computed(() => {
+    if (!dist.value)
+      return [];
+    const di = toValue(dist);
+    const propertyTable = [
+      pn({ id: "license", label: t("__pv.metadata.license"), help: t("__pv.tooltip.datasetDetails.distribution.licence"), data: [
+        { type: "href", id: "licenseVal", data: { href: di.license?.resource || "", label: di.license?.label || di.license?.description || di.license?.id || "" } }
+      ] }),
+      pn({ id: "modified", label: t("__pv.metadata.modificationDate"), help: t("__pv.tooltip.datasetDetails.distribution.modified"), data: d(di.modified || "", "medium") }),
+      pn({ id: "created", label: t("__pv.metadata.created"), help: t("__pv.tooltip.datasetDetails.distribution.created"), data: d(di.issued || "", "medium") }),
+      pn({ id: "languages", label: t("__pv.metadata.languages"), help: t("__pv.tooltip.datasetDetails.distribution.languages"), data: parseResourceList(di.language || []) }),
+      pn({ id: "status", label: t("__pv.metadata.status"), help: t("__pv.tooltip.datasetDetails.distribution.status"), data: parseResource(di.status) }),
+      pn({ id: "rights", label: t("__pv.metadata.rights"), help: t("__pv.tooltip.datasetDetails.distribution.rights"), data: parseResource(di.rights) }),
+      pn({ id: "mediaType", label: t("__pv.metadata.mediaType"), help: t("__pv.tooltip.datasetDetails.distribution.mediaType"), data: di.media_type }),
+      pn({ id: "byteSize", label: t("__pv.metadata.byteSize"), help: t("__pv.tooltip.datasetDetails.distribution.byteSize"), data: di.byte_size ? n(di.byte_size) : void 0 }),
+      pn({ id: "pages", label: t("__pv.metadata.pages"), help: t("__pv.tooltip.datasetDetails.distribution.pages"), data: di.page?.map((p) => p?.resource) }),
+      pn({ id: "compressFormat", label: t("__pv.metadata.compressFormat"), help: t("__pv.tooltip.datasetDetails.distribution.compressFormat"), data: parseResource(di.compress_format) }),
+      pn({ id: "packageFormat", label: t("__pv.metadata.packageFormat"), help: t("__pv.tooltip.datasetDetails.distribution.packageFormat"), data: parseResource(di.package_format) }),
+      pn({ id: "conformsTo", label: t("__pv.metadata.conformsTo"), help: t("__pv.tooltip.datasetDetails.distribution.conformsTo"), data: parseResourceList(di.conforms_to || []) })
+    ];
+    return propertyTable;
+  });
+  return {
+    getPropertyTable
+  };
+}

package/dist/integrations/index.d.ts

@@ -0,0 +1 @@
+export * from './dcatAp/index.js';

package/dist/integrations/index.js

@@ -0,0 +1 @@
+export * from "./dcatAp/index.js";

package/dist/locale/__tests__/index.test.d.ts

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

package/dist/locale/__tests__/index.test.js

@@ -0,0 +1,12 @@
+import fs from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import * as locales from "../index.js";
+describe("locales", () => {
+  it("should export all locales inside locales folder", () => {
+    const files = fs.readdirSync(path.join(__dirname, ".."));
+    const localeFiles = files.filter((f) => f.endsWith(".ts") && f !== "index.ts");
+    const keys = Object.keys(locales);
+    expect(localeFiles.length).toBe(keys.length);
+  });
+});

package/dist/locale/adapters/default.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue-demi';
+import type { DateFormatStrings, DateFormats, DateLike, LocaleInstance, LocaleMessages, LocaleOptions } from '../../composables/locale.js';
+export declare function createTranslateFunction(current: Ref<string>, fallback: Ref<string>, messages: Ref<LocaleMessages>): (key: string, ...params: unknown[]) => string;
+export declare function createNumberFunction(current: Ref<string>, fallback: Ref<string>): (value: number, options?: Intl.NumberFormatOptions) => string;
+export declare function createDateFunction(current: Ref<string>, fallback: Ref<string>, dateFormatStrings: Ref<DateFormatStrings>): (value: DateLike, format?: DateFormats, locale?: Intl.LocalesArgument) => string;
+export declare function defaultLocaleAdapter(options?: LocaleOptions): LocaleInstance;

package/dist/locale/adapters/default.js

@@ -0,0 +1,60 @@
+import { ref, shallowRef } from "vue-demi";
+import { formatDate, normalizeDate } from "@vueuse/core";
+import { getObjectValueByPath, replace } from "../../utils/vHelpers.js";
+import { de, en } from "../index.js";
+const LANG_PREFIX = "__pv.";
+export function createTranslateFunction(current, fallback, messages) {
+  return (key, ...params) => {
+    if (!key.startsWith(LANG_PREFIX))
+      return replace(key, params);
+    const shortKey = key.replace(LANG_PREFIX, "");
+    const currentLocale = current.value && messages.value[current.value];
+    const fallbackLocale = fallback.value && messages.value[fallback.value];
+    let str = getObjectValueByPath(currentLocale, shortKey, null);
+    if (!str) {
+      console.warn(`Translation key "${key}" not found in "${current.value}", trying fallback locale`);
+      str = getObjectValueByPath(fallbackLocale, shortKey, null);
+    }
+    if (!str) {
+      console.error(`Translation key "${key}" not found in fallback`);
+      str = key;
+    }
+    if (typeof str !== "string") {
+      console.error(`Translation key "${key}" has a non-string value`);
+      str = key;
+    }
+    return replace(str, params);
+  };
+}
+export function createNumberFunction(current, fallback) {
+  return (value, options) => {
+    const numberFormat = new Intl.NumberFormat([current.value, fallback.value], options);
+    return numberFormat.format(value);
+  };
+}
+export function createDateFunction(current, fallback, dateFormatStrings) {
+  return (value, format = "short", locale) => {
+    const locales = locale ? Array.isArray(locale) ? locale : [locale] : [current.value, fallback.value];
+    return formatDate(normalizeDate(value), dateFormatStrings.value?.[format] || "", { locales });
+  };
+}
+export function defaultLocaleAdapter(options) {
+  const currentLocale = shallowRef(options?.locale ?? "en");
+  const fallbackLocale = shallowRef(options?.fallback ?? "en");
+  const messages = ref({ en, de, ...options?.messages });
+  const dateFormatStrings = shallowRef({
+    short: "YYYY-MM-DD",
+    medium: "YYYY-MM-DD HH:mm",
+    long: "YYYY-MM-DD HH:mm:ss",
+    ...options?.dateFormatStrings
+  });
+  return {
+    name: "__default",
+    currentLocale,
+    fallbackLocale,
+    messages,
+    t: createTranslateFunction(currentLocale, fallbackLocale, messages),
+    n: createNumberFunction(currentLocale, fallbackLocale),
+    d: createDateFunction(currentLocale, fallbackLocale, dateFormatStrings)
+  };
+}