@piveau/sdk-vue 0.0.0-alpha-2.0

package/dist/defineHubSearch.js

@@ -0,0 +1,91 @@
+import { getResourceById, searchResource } from "@piveau/sdk-core";
+import { useRoute, useRouter } from "vue-router";
+import { useRouteQuery } from "@vueuse/router";
+import { assertQueryClient } from "./utils.js";
+import { useSearchFactory } from "./useSearchFactory.js";
+import { useResourceFactory } from "./useResourceFactory.js";
+import { useQueryClient } from "./index.js";
+export function defineHubSearch(options, setup) {
+  const {
+    baseUrl,
+    index,
+    indexDetails,
+    schema,
+    facets = [],
+    defaultOptions = {},
+    enabled = true
+  } = options;
+  async function defaultFetcherFn(_opts) {
+    const res = await searchResource({
+      baseUrl,
+      params: {
+        ..._opts.params,
+        filter: index
+      },
+      additionalParams: _opts.additionalParams,
+      headers: _opts.headers
+    });
+    return res.data;
+  }
+  const {
+    qc = useQueryClient(),
+    searchFetcherFn = defaultFetcherFn
+  } = defaultOptions;
+  assertQueryClient(qc);
+  const useSearch = useSearchFactory({
+    schema,
+    ctx: options,
+    facets,
+    index,
+    fetcherFn: searchFetcherFn,
+    enabled,
+    qc
+  }, setup);
+  const useResource = useResourceFactory({
+    baseUrl,
+    schema,
+    ctx: options,
+    index: indexDetails ?? index,
+    enabled,
+    fetcherFn: async (_options) => {
+      return getResourceById(_options);
+    },
+    qc
+  }, setup);
+  function refSyncedWithRouteQuery(searchParam, defaultValue) {
+    const route = useRoute();
+    const router = useRouter();
+    return useRouteQuery(searchParam, defaultValue, {
+      router,
+      route,
+      mode: "push"
+    });
+  }
+  function refSyncedWithRouteQueryFacet(searchParam, defaultValue) {
+    const route = useRoute();
+    const router = useRouter();
+    return useRouteQuery(searchParam, defaultValue, {
+      // always transform the value to an array
+      transform: (value) => {
+        if (Array.isArray(value))
+          return value;
+        if (typeof value === "string")
+          return [value];
+        return [];
+      },
+      router,
+      route,
+      mode: "push"
+    });
+  }
+  return {
+    useSearch,
+    useResource,
+    refSyncedWithRouteQuery,
+    refSyncedWithRouteQueryFacet,
+    setup
+  };
+}
+export function defineHubSearchIntegration(schema, setup) {
+  return { setup, schema };
+}

package/dist/getters.d.ts

@@ -0,0 +1,26 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue-demi';
+import type { z } from 'zod';
+/**
+ * Type of an object of Getters that infers the argument.
+ */
+export type GettersTree<TModelSchema = any, TContext = any> = Record<string, ((data: TModelSchema, ctx?: TContext, getters?: GettersTree<TModelSchema, TContext>) => any) | (() => any)>;
+/**
+ * Type helper to make it easier to use define resource getters
+ * accepts a direct {@link GettersTree} object, a {@link z.Schema} schema, and a context object.
+ */
+export declare function defineGetters<TModelSchema = any, TContext = any, TGettersTree extends GettersTree<TModelSchema, TContext> = GettersTree<TModelSchema, TContext>>({ schema, getters, ctx, }: {
+    schema: z.Schema<TModelSchema>;
+    getters: TGettersTree;
+    ctx?: TContext;
+}): { [K in keyof TGettersTree]: TGettersTree[K]; };
+export type ComputedGettersTree<TModelSchema = any, TContext = any, TGettersTree extends GettersTree<TModelSchema, TContext> = GettersTree<TModelSchema, TContext>> = {
+    [K in keyof TGettersTree]: ComputedRef<ReturnType<TGettersTree[K]>>;
+};
+/**
+ * Composable function that takes reactive state and getters and turns it into computed getters.
+ */
+export declare function toComputedGetters<TModelSchema = any, TContext = any, TGettersTree extends GettersTree<TModelSchema, TContext> = GettersTree<TModelSchema, TContext>>({ data, getters, ctx, }: {
+    data?: MaybeRefOrGetter<TModelSchema | undefined>;
+    getters: TGettersTree;
+    ctx?: TContext;
+}): ComputedGettersTree<TModelSchema, TContext, TGettersTree>;

package/dist/getters.js

@@ -0,0 +1,28 @@
+import { computed, toValue } from "vue-demi";
+export function defineGetters({
+  schema,
+  getters,
+  ctx
+}) {
+  return { schema, getters, ctx }.getters;
+}
+export function toComputedGetters({
+  data,
+  getters,
+  ctx
+}) {
+  return Object.keys(getters || {}).reduce(
+    (computedGetters, name) => {
+      const getter = getters[name];
+      computedGetters[name] = computed(() => {
+        const dataValue = toValue(data);
+        if (!dataValue)
+          return null;
+        if (typeof getter === "function")
+          return getter(dataValue, ctx);
+      });
+      return computedGetters;
+    },
+    {}
+  );
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import type { App, InjectionKey } from 'vue-demi';
+import { QueryClient } from '@tanstack/vue-query';
+import { type LocaleOptions } from './composables/locale.js';
+export interface PiveauKitPluginOptions {
+    queryClient?: QueryClient;
+    locale?: LocaleOptions;
+}
+export declare const keyQueryClient: InjectionKey<QueryClient>;
+export declare const plugin: {
+    install(app: App, options?: PiveauKitPluginOptions): void;
+};
+export declare function useQueryClient(): QueryClient | null;
+export declare const piveauKitPlugin: {
+    install(app: App, options?: PiveauKitPluginOptions): void;
+};
+export * from './useResourceFactory.js';
+export * from './useSearchFactory.js';
+export * from './defineHubSearch.js';
+export * from './integrations/index.js';

package/dist/index.js

@@ -0,0 +1,29 @@
+import { inject, isVue2 } from "vue-demi";
+import { QueryClient } from "@tanstack/vue-query";
+import { localeKey } from "./composables/locale.js";
+import { defaultLocaleAdapter } from "./locale/adapters/default.js";
+export const keyQueryClient = Symbol("");
+export const plugin = {
+  install(app, options = {}) {
+    const {
+      queryClient = new QueryClient(),
+      locale
+    } = options || {};
+    if (isVue2) {
+      throw new Error("Vue 2 is not supported");
+    } else {
+      const resolvedLocale = locale?.adapter ?? defaultLocaleAdapter(locale);
+      app.provide(keyQueryClient, queryClient);
+      app.provide(localeKey, resolvedLocale);
+    }
+  }
+};
+export function useQueryClient() {
+  const maybeQueryClient = inject(keyQueryClient, null);
+  return maybeQueryClient;
+}
+export const piveauKitPlugin = plugin;
+export * from "./useResourceFactory.js";
+export * from "./useSearchFactory.js";
+export * from "./defineHubSearch.js";
+export * from "./integrations/index.js";

package/dist/integrations/__tests__/dcatAp.test.d.ts

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

package/dist/integrations/__tests__/dcatAp.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { nextTick, ref } from "vue-demi";
+import { dcatApDataset } from "../dcatAp/dcatAp.js";
+import { withSetup } from "../../../test/utils.js";
+import dataset from "./https-data-paysdelaloire-fr-explore-dataset-agenda-culture-de-la-region-des-pays-de-la-loire-.json";
+describe("integration dcat-ap", async () => {
+  it("should run the setup function", async () => {
+    const { setup } = dcatApDataset();
+    const { result } = await withSetup(() => setup(dataset));
+    expect(result.getId.value).toBe(dataset.id);
+  });
+  it.each([
+    { getter: "getId", expected: dataset.id },
+    { getter: "getTitle", expected: dataset.title.en },
+    { getter: "getDescription", expected: dataset.description.en },
+    { getter: "getPublisher", expected: dataset.publisher }
+  ])("($getter) should return $expected", async ({ getter, expected }) => {
+    const { setup } = dcatApDataset();
+    const { result } = await withSetup(() => setup(dataset));
+    if (typeof expected === "string")
+      expect(result[getter].value).toBe(expected);
+    if (typeof expected === "object")
+      expect(result[getter].value).toEqual(expected);
+  });
+  it("should update reactively when dataset changes", async () => {
+    const dataset2 = JSON.parse(JSON.stringify(dataset));
+    dataset2.id = "new-id";
+    const datasetRef = ref(dataset);
+    const { setup } = dcatApDataset();
+    const { result } = await withSetup(() => setup(datasetRef));
+    expect(result.getId.value).toBe(dataset.id);
+    datasetRef.value = dataset2;
+    await nextTick();
+    expect(result.getId.value).toBe(dataset2.id);
+  });
+});