@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/storage/stores/fetcher/actions.js

@@ -0,0 +1,138 @@
+import { v4 as uuidv4 } from "uuid";
+import { reactive } from "vue";
+import { consola as logger } from "consola";
+export var FinishFetchManifestType = /* @__PURE__ */ ((FinishFetchManifestType2) => {
+  FinishFetchManifestType2["SUCCESS"] = "SUCCESS";
+  FinishFetchManifestType2["ERROR"] = "ERROR";
+  return FinishFetchManifestType2;
+})(FinishFetchManifestType || {});
+export default function(fetcherState, fetcherGetters) {
+  function getFetchStatusFromToken(token) {
+    const fetchStatus = fetcherState.fetches[token];
+    if (!fetchStatus) {
+      throw new Error(`The fetch chain token '${token}' does not exist`);
+    }
+    return fetchStatus;
+  }
+  return {
+    abortFetch(event) {
+      const fetchStatus = getFetchStatusFromToken(event.token);
+      fetchStatus.abort = true;
+    },
+    setManifestIrisByDepth(event) {
+      const fetchStatus = getFetchStatusFromToken(event.token);
+      if (!fetchStatus.manifest) {
+        throw new Error(`Cannot set manifest IRIs by depth for '${event.token}'. The manifest was never started.`);
+      }
+      fetchStatus.manifest.irisByDepth = event.irisByDepth;
+    },
+    finishManifestFetch(event) {
+      let fetchStatus;
+      try {
+        fetchStatus = getFetchStatusFromToken(event.token);
+      } catch (error) {
+        logger.trace(error.message);
+        return;
+      }
+      if (!fetchStatus.manifest) {
+        throw new Error(`Cannot set manifest status for '${event.token}'. The manifest was never started.`);
+      }
+      if (event.type === "SUCCESS" /* SUCCESS */) {
+        fetchStatus.manifest.fetchComplete = true;
+      }
+      if (event.type === "ERROR" /* ERROR */) {
+        fetchStatus.manifest.error = event.error.asObject;
+      }
+    },
+    startFetch(event) {
+      const timestamp = (/* @__PURE__ */ new Date()).getTime();
+      if (event.token) {
+        try {
+          const existingFetchStatus = getFetchStatusFromToken(event.token);
+          return {
+            continue: !existingFetchStatus.abort,
+            resources: existingFetchStatus.resources,
+            token: event.token
+          };
+        } catch (error) {
+          return {
+            continue: false,
+            resources: [],
+            token: event.token
+          };
+        }
+      }
+      if (event.isPrimary && fetcherState.primaryFetch.successToken) {
+        const lastSuccessState = fetcherState.fetches[fetcherState.primaryFetch.successToken];
+        if (lastSuccessState?.path === event.path && event.isCurrentSuccessResourcesResolved) {
+          fetcherState.primaryFetch.fetchingToken = void 0;
+          for (const [existingToken, existingValue] of Object.entries(fetcherState.fetches)) {
+            if (existingToken !== fetcherState.primaryFetch.successToken) {
+              const secondsDifference = (timestamp - existingValue.timestamp) / 1e3;
+              const abortRequest = existingValue.isPrimary || secondsDifference >= 1;
+              if (abortRequest) {
+                existingValue.abort = true;
+              }
+            }
+          }
+          return {
+            continue: false,
+            resources: lastSuccessState.resources,
+            token: fetcherState.primaryFetch.successToken
+          };
+        }
+      }
+      const token = uuidv4();
+      const initialState = reactive({
+        path: event.path,
+        resources: [],
+        isPrimary: !!event.isPrimary,
+        timestamp
+      });
+      if (event.manifestPath) {
+        initialState.manifest = {
+          path: event.manifestPath
+        };
+      }
+      if (event.isPrimary) {
+        fetcherState.primaryFetch.fetchingToken = token;
+      }
+      fetcherState.fetches[token] = initialState;
+      return { token, continue: true, resources: [] };
+    },
+    finishFetch(event) {
+      const fetchStatus = getFetchStatusFromToken(event.token);
+      if (!fetchStatus.isPrimary) {
+        delete fetcherState.fetches[event.token];
+        return;
+      }
+      const initialFetchingToken = fetcherState.primaryFetch.fetchingToken;
+      const initialSuccessToken = fetcherState.primaryFetch.successToken;
+      if (event.token === initialFetchingToken) {
+        fetcherState.primaryFetch.fetchingToken = void 0;
+        fetcherState.primaryFetch.successToken = event.token;
+      }
+      if (initialSuccessToken && fetcherState.primaryFetch.successToken !== initialSuccessToken) {
+        delete fetcherState.fetches[initialSuccessToken];
+      }
+      if (event.token !== fetcherState.primaryFetch.successToken) {
+        delete fetcherState.fetches[event.token];
+      }
+    },
+    addFetchResource(event) {
+      const fetchStatus = getFetchStatusFromToken(event.token);
+      if (fetchStatus.resources.includes(event.resource) || !fetcherGetters.isCurrentFetchingToken.value(event.token)) {
+        return false;
+      }
+      fetchStatus.resources.push(event.resource);
+      return true;
+    },
+    clearFetches() {
+      fetcherState.primaryFetch.fetchingToken = void 0;
+      fetcherState.primaryFetch.successToken = void 0;
+      for (const token of Object.keys(fetcherState.fetches)) {
+        delete fetcherState.fetches[token];
+      }
+    }
+  };
+}

package/dist/runtime/storage/stores/fetcher/fetcher-store.d.ts

@@ -0,0 +1,19 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaFetcherActionsInterface } from './actions.js';
+import type { CwaFetcherStateInterface } from './state.js';
+import type { CwaFetcherGettersInterface } from './getters.js';
+/**
+ * Interface Definitions
+ */
+export interface CwaFetcherInterface extends CwaFetcherStateInterface, CwaFetcherActionsInterface, CwaFetcherGettersInterface {
+}
+export type CwaFetcherStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.fetcher`, CwaFetcherInterface>;
+export type CwaFetcherStoreInterface = CwaPiniaStoreInterface<`${string}.fetcher`, CwaFetcherInterface>;
+/**
+ * Main Store Class
+ */
+export declare class FetcherStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaFetcherStoreInterface;
+}

package/dist/runtime/storage/stores/fetcher/fetcher-store.js

@@ -0,0 +1,23 @@
+import {
+  defineStore
+} from "pinia";
+import CwaFetcherActions from "./actions.js";
+import CwaFetcherState from "./state.js";
+import CwaFetcherGetters from "./getters.js";
+export class FetcherStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.fetcher`, () => {
+      const fetcherState = CwaFetcherState();
+      const getters = CwaFetcherGetters(fetcherState);
+      return {
+        ...fetcherState,
+        ...getters,
+        ...CwaFetcherActions(fetcherState, getters)
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

package/dist/runtime/storage/stores/fetcher/getter-utils.d.ts

@@ -0,0 +1,7 @@
+import type { CwaFetcherStateInterface, FetchStatus } from './state.js';
+export declare class FetcherGetterUtils {
+    private fetcherState;
+    constructor(fetcherState: CwaFetcherStateInterface);
+    getFetchStatusByToken(token: string): FetchStatus | undefined;
+    isFetchResolving(token: string): boolean;
+}

package/dist/runtime/storage/stores/fetcher/getter-utils.js

@@ -0,0 +1,27 @@
+export class FetcherGetterUtils {
+  fetcherState;
+  constructor(fetcherState) {
+    this.fetcherState = fetcherState;
+  }
+  getFetchStatusByToken(token) {
+    const fetchStatus = this.fetcherState.fetches[token];
+    if (!fetchStatus) {
+      return;
+    }
+    return fetchStatus;
+  }
+  isFetchResolving(token) {
+    const fetchStatus = this.getFetchStatusByToken(token);
+    if (!fetchStatus) {
+      return false;
+    }
+    if (fetchStatus.abort) {
+      return false;
+    }
+    const resources = fetchStatus.resources;
+    if (!resources.length) {
+      return false;
+    }
+    return !!(fetchStatus.manifest && !fetchStatus.manifest.fetchComplete && fetchStatus.manifest.error === void 0);
+  }
+}

package/dist/runtime/storage/stores/fetcher/getters.d.ts

@@ -0,0 +1,13 @@
+import type { ComputedRef } from 'vue';
+import type { CwaFetcherStateInterface, FetchStatus } from './state.js';
+export interface CwaFetcherGettersInterface {
+    resolvedSuccessFetchStatus: ComputedRef<FetchStatus | undefined>;
+    primaryFetchPath: ComputedRef<string | undefined>;
+    fetchesResolved: ComputedRef<boolean>;
+    isFetchResolving: ComputedRef<(token: string) => {
+        fetchStatus: FetchStatus | undefined;
+        resolving: boolean;
+    }>;
+    isCurrentFetchingToken: ComputedRef<(token: string) => boolean | undefined>;
+}
+export default function (fetcherState: CwaFetcherStateInterface): CwaFetcherGettersInterface;

package/dist/runtime/storage/stores/fetcher/getters.js

@@ -0,0 +1,52 @@
+import { computed } from "vue";
+import { FetcherGetterUtils } from "./getter-utils.js";
+export default function(fetcherState) {
+  const utils = new FetcherGetterUtils(fetcherState);
+  const primaryFetchPath = computed(() => {
+    const primaryFetchToken = fetcherState.primaryFetch.fetchingToken || fetcherState.primaryFetch.successToken;
+    if (!primaryFetchToken) {
+      return;
+    }
+    const fetchStatus = fetcherState.fetches[primaryFetchToken];
+    return fetchStatus?.path;
+  });
+  return {
+    primaryFetchPath,
+    resolvedSuccessFetchStatus: computed(() => {
+      if (!fetcherState.primaryFetch.successToken) {
+        return;
+      }
+      const fetchStatus = utils.getFetchStatusByToken(fetcherState.primaryFetch.successToken);
+      if (!fetchStatus || utils.isFetchResolving(fetcherState.primaryFetch.successToken)) {
+        return;
+      }
+      return fetchStatus;
+    }),
+    fetchesResolved: computed(() => {
+      for (const token of Object.keys(fetcherState.fetches)) {
+        if (utils.isFetchResolving(token)) {
+          return false;
+        }
+      }
+      return true;
+    }),
+    isFetchResolving: computed(() => {
+      return (token) => ({
+        fetchStatus: utils.getFetchStatusByToken(token),
+        resolving: utils.isFetchResolving(token)
+      });
+    }),
+    isCurrentFetchingToken: computed(() => {
+      return (token) => {
+        const fetchStatus = fetcherState.fetches[token];
+        if (!fetchStatus) {
+          throw new Error(`Failed to check if the token '${token}' is current. It does not exist.`);
+        }
+        if (fetchStatus.abort) {
+          return false;
+        }
+        return !fetchStatus.isPrimary || token === fetcherState.primaryFetch.fetchingToken;
+      };
+    })
+  };
+}

package/dist/runtime/storage/stores/fetcher/state.d.ts

@@ -0,0 +1,27 @@
+import type { CwaResourceErrorObject } from '../../../errors/cwa-resource-error.js';
+interface FetchManifestInterface {
+    path: string;
+    irisByDepth?: string[][];
+    fetchComplete?: true;
+    error?: CwaResourceErrorObject;
+}
+export interface FetchStatus {
+    path: string;
+    isPrimary: boolean;
+    resources: string[];
+    manifest?: FetchManifestInterface;
+    abort?: true;
+    timestamp: number;
+}
+export interface FetcherChainInterface {
+    [token: string]: FetchStatus;
+}
+export interface CwaFetcherStateInterface {
+    primaryFetch: {
+        fetchingToken?: string;
+        successToken?: string;
+    };
+    fetches: FetcherChainInterface;
+}
+export default function (): CwaFetcherStateInterface;
+export {};

package/dist/runtime/storage/stores/fetcher/state.js

@@ -0,0 +1,7 @@
+import { reactive } from "vue";
+export default function() {
+  return {
+    primaryFetch: reactive({}),
+    fetches: reactive({})
+  };
+}

package/dist/runtime/storage/stores/mercure/mercure-store.d.ts

@@ -0,0 +1,16 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaMercureStateInterface } from './state.js';
+/**
+ * Interface Definitions
+ */
+export type CwaMercureInterface = CwaMercureStateInterface;
+export type CwaMercureStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.mercure`, CwaMercureInterface>;
+export type CwaMercureStoreInterface = CwaPiniaStoreInterface<`${string}.mercure`, CwaMercureInterface>;
+/**
+ * Main Store Class
+ */
+export declare class MercureStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaMercureStoreInterface;
+}

package/dist/runtime/storage/stores/mercure/mercure-store.js

@@ -0,0 +1,18 @@
+import {
+  defineStore
+} from "pinia";
+import CwaMercureState from "./state.js";
+export class MercureStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.mercure`, () => {
+      const mercureState = CwaMercureState();
+      return {
+        ...mercureState
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

package/dist/runtime/storage/stores/mercure/state.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from 'vue';
+export interface CwaMercureStateInterface {
+    hub: Ref<string | null>;
+}
+export default function (): CwaMercureStateInterface;

package/dist/runtime/storage/stores/mercure/state.js

@@ -0,0 +1,6 @@
+import { ref } from "vue";
+export default function() {
+  return {
+    hub: ref(null)
+  };
+}

package/dist/runtime/storage/stores/resources/actions.d.ts

@@ -0,0 +1,59 @@
+import type { CwaFetchRequestHeaders } from '#cwa/api/fetcher/fetcher';
+import type { CwaResourceError } from '#cwa/errors/cwa-resource-error';
+import type { CwaResource } from '#cwa/resources/resource-utils';
+import type { CwaResourcesGettersInterface } from './getters.js';
+import type { CwaResourcesStateInterface } from './state.js';
+import type { AddResourceEvent } from '#cwa/admin/resource-stack-manager';
+export interface SaveResourceEvent {
+    resource: CwaResource;
+    isNew?: undefined | false;
+}
+export interface SaveNewResourceEvent {
+    resource: CwaResource;
+    isNew: true;
+    path: string | undefined;
+}
+export interface DeleteResourceEvent {
+    resource: string;
+    noCascade?: boolean;
+}
+export interface SetResourceInProgressStatusEvent {
+    iri: string;
+    path: string;
+    isComplete: false;
+    headers?: CwaFetchRequestHeaders;
+}
+export interface SetResourceCompletedStatusEvent {
+    iri: string;
+    path?: string;
+    isComplete: true;
+    headers: CwaFetchRequestHeaders;
+    responseIri?: string;
+}
+export interface SetResourceResetStatusEvent {
+    iri: string;
+    path?: undefined;
+    isComplete: null;
+}
+declare type SetResourceStatusEvent = SetResourceInProgressStatusEvent | SetResourceCompletedStatusEvent | SetResourceResetStatusEvent;
+export interface SetResourceFetchErrorEvent {
+    iri: string;
+    error?: CwaResourceError;
+    isCurrent?: boolean;
+    showErrorPage?: boolean;
+}
+export interface CwaResourcesActionsInterface {
+    resetNewResource(): void;
+    initNewResource(addResourceEvent: AddResourceEvent, resourceType: string, endpoint: string, isPublishable: boolean, instantAdd: boolean, defaultData?: {
+        [key: string]: any;
+    }): void;
+    resetCurrentResources(currentIds?: string[]): void;
+    clearResources(): void;
+    setResourceFetchStatus(event: SetResourceStatusEvent): void;
+    setResourceFetchError(event: SetResourceFetchErrorEvent): void;
+    saveResource(event: SaveResourceEvent | SaveNewResourceEvent): void;
+    deleteResource(event: DeleteResourceEvent): void;
+    mergeNewResources(): void;
+}
+export default function (resourcesState: CwaResourcesStateInterface, resourcesGetters: CwaResourcesGettersInterface): CwaResourcesActionsInterface;
+export {};