@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

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

@@ -0,0 +1,15 @@
+import { reactive } from "vue";
+export var CwaUserRoles = /* @__PURE__ */ ((CwaUserRoles2) => {
+  CwaUserRoles2["SUPER_ADMIN"] = "ROLE_SUPER_ADMIN";
+  CwaUserRoles2["ADMIN"] = "ROLE_ADMIN";
+  CwaUserRoles2["ALLOWED_TO_SWITCH"] = "ROLE_ALLOWED_TO_SWITCH";
+  CwaUserRoles2["USER"] = "ROLE_USER";
+  return CwaUserRoles2;
+})(CwaUserRoles || {});
+export default function() {
+  return {
+    data: reactive({
+      user: void 0
+    })
+  };
+}

package/dist/runtime/storage/stores/cwa-store-types.d.ts

@@ -0,0 +1,14 @@
+import type {
+  SetupStoreDefinition,
+  Store,
+  StoreActions,
+  StoreGetters,
+  StoreState,
+} from 'pinia'
+
+export interface CwaStore {
+  useStore(): any
+}
+
+export declare type CwaPiniaStoreDefinitionInterface<N extends string, I> = SetupStoreDefinition<N, I>
+export declare type CwaPiniaStoreInterface<N extends string, I> = Store<N, StoreState<I>, StoreGetters<I>, StoreActions<I>>

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

@@ -0,0 +1,11 @@
+import type { FetchError } from 'ofetch';
+import type { ApiResourceEvent } from '../../../resources/resources-manager.js';
+import type { CwaErrorEvent, CwaErrorStateInterface } from './state.js';
+export interface CwaErrorActionsInterface {
+    error(event: ApiResourceEvent, error: FetchError): void;
+    manual(error: CwaErrorEvent): void;
+    clear(): void;
+    removeById(id: number): void;
+    removeByEndpoint(endpoint: string): void;
+}
+export default function (errorState: CwaErrorStateInterface): CwaErrorActionsInterface;

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

@@ -0,0 +1,69 @@
+import { ErrorType } from "./state.js";
+function getErrorType(type) {
+  switch (type) {
+    case "hydra:Error":
+      return ErrorType.SERVER;
+    case "TypeError":
+      return ErrorType.NETWORK;
+    case "ConstraintViolationList":
+      return ErrorType.VALIDATION;
+    default:
+      return ErrorType.UNKNOWN;
+  }
+}
+export default function(errorState) {
+  return {
+    // use endpoint to make error be replace
+    error(event, error) {
+      const id = (/* @__PURE__ */ new Date()).getTime();
+      const err = { event, timestamp: id };
+      if (error.cause) {
+        err.type = getErrorType(error.cause.constructor.name);
+        err.detail = error.cause.message;
+      } else if (error.data?.["hydra:description"]) {
+        err.type = getErrorType(error.data["@type"]);
+        err.detail = error.data["hydra:description"];
+        err.violations = error.data.violations?.map((e) => ({ property: e.propertyPath, message: e.message }));
+      } else {
+        err.type = ErrorType.SERVER;
+        err.detail = error.data;
+      }
+      if (err.type === ErrorType.SERVER || err.type === ErrorType.VALIDATION || err.type === ErrorType.UNKNOWN) {
+        err.statusCode = error.statusCode;
+      }
+      errorState.byId[id] = err;
+      errorState.allIds.push(id);
+      errorState.allEndpoints.set(event.endpoint, id);
+    },
+    manual(error) {
+      const id = error.timestamp;
+      errorState.byId[id] = error;
+      errorState.allIds.push(id);
+      errorState.allEndpoints.set("unset", id);
+    },
+    clear() {
+      errorState.allIds = [];
+      errorState.allEndpoints.clear();
+      errorState.byId = {};
+    },
+    removeById(id) {
+      const err = errorState.byId[id];
+      if (!err) {
+        return;
+      }
+      delete errorState.byId[id];
+      errorState.allIds.splice(errorState.allIds.indexOf(id), 1);
+      const endpoint = err.event?.endpoint || "local";
+      if (endpoint) {
+        errorState.allEndpoints.delete(endpoint);
+      }
+    },
+    removeByEndpoint(endpoint) {
+      if (!errorState.allEndpoints.has(endpoint)) {
+        return;
+      }
+      const id = errorState.allEndpoints.get(endpoint);
+      id && this.removeById(id);
+    }
+  };
+}

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

@@ -0,0 +1,13 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaErrorStateInterface } from './state.js';
+import type { CwaErrorActionsInterface } from './actions.js';
+import type { CwaErrorsGettersInterface } from './getters.js';
+export interface CwaErrorInterface extends CwaErrorStateInterface, CwaErrorActionsInterface, CwaErrorsGettersInterface {
+}
+export type CwaErrorStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.error`, CwaErrorInterface>;
+export type CwaErrorStoreInterface = CwaPiniaStoreInterface<`${string}.error`, CwaErrorInterface>;
+export declare class ErrorStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaErrorStoreInterface;
+}

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

@@ -0,0 +1,21 @@
+import { defineStore } from "pinia";
+import CwaErrorState from "./state.js";
+import CwaErrorActions from "./actions.js";
+import CwaErrorGetters from "./getters.js";
+export class ErrorStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.error`, () => {
+      const errorState = CwaErrorState();
+      const getters = CwaErrorGetters(errorState);
+      return {
+        ...errorState,
+        ...getters,
+        ...CwaErrorActions(errorState)
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

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

@@ -0,0 +1,7 @@
+import type { ComputedRef } from 'vue';
+import type { CwaErrorEvent, CwaErrorStateInterface } from './state.js';
+export interface CwaErrorsGettersInterface {
+    hasErrors: ComputedRef<boolean>;
+    getErrors: ComputedRef<CwaErrorEvent[]>;
+}
+export default function (resourcesState: CwaErrorStateInterface): CwaErrorsGettersInterface;

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

@@ -0,0 +1,11 @@
+import { computed } from "vue";
+export default function(resourcesState) {
+  return {
+    hasErrors: computed(() => {
+      return resourcesState.allIds.length > 0;
+    }),
+    getErrors: computed(() => {
+      return resourcesState.allIds.map((e) => resourcesState.byId[e]);
+    })
+  };
+}

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

@@ -0,0 +1,35 @@
+import type { ApiResourceEvent } from '../../../resources/resources-manager.js';
+export interface CwaViolationError {
+    message: string;
+    property: string;
+}
+export declare enum ErrorType {
+    NETWORK = "NETWORK",
+    VALIDATION = "VALIDATION",
+    SERVER = "SERVER",
+    UNKNOWN = "UNKNOWN"
+}
+interface CwaBaseErrorEvent {
+    event?: ApiResourceEvent;
+    detail: string;
+    violations: CwaViolationError[];
+    timestamp: number;
+}
+interface CwaResolvedErrorEvent extends CwaBaseErrorEvent {
+    type: Exclude<ErrorType, ErrorType.NETWORK>;
+    statusCode: number;
+}
+interface CwaNetworkErrorEvent extends CwaBaseErrorEvent {
+    type: ErrorType.NETWORK;
+    statusCode: undefined;
+}
+export type CwaErrorEvent = CwaNetworkErrorEvent | CwaResolvedErrorEvent;
+export interface CwaErrorStateInterface {
+    byId: {
+        [key: number]: CwaErrorEvent;
+    };
+    allIds: Array<number>;
+    allEndpoints: Map<string, number>;
+}
+export default function (): CwaErrorStateInterface;
+export {};

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

@@ -0,0 +1,15 @@
+import { reactive } from "vue";
+export var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["NETWORK"] = "NETWORK";
+  ErrorType2["VALIDATION"] = "VALIDATION";
+  ErrorType2["SERVER"] = "SERVER";
+  ErrorType2["UNKNOWN"] = "UNKNOWN";
+  return ErrorType2;
+})(ErrorType || {});
+export default function() {
+  return reactive({
+    byId: {},
+    allIds: [],
+    allEndpoints: /* @__PURE__ */ new Map()
+  });
+}

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

@@ -0,0 +1,49 @@
+import type { CwaResourceError } from '../../../errors/cwa-resource-error.js';
+import type { CwaFetcherStateInterface } from './state.js';
+import type { CwaFetcherGettersInterface } from './getters.js';
+export interface StartFetchEvent {
+    token?: string;
+    path: string;
+    manifestPath?: string;
+    isPrimary?: boolean;
+    isCurrentSuccessResourcesResolved: boolean;
+}
+export interface FinishFetchEvent {
+    token: string;
+}
+export interface AddFetchResourceEvent {
+    token: string;
+    resource: string;
+}
+export interface StartFetchResponse {
+    continue: boolean;
+    resources: string[];
+    token: string;
+}
+export declare enum FinishFetchManifestType {
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+export interface ManifestSuccessFetchEvent {
+    type: FinishFetchManifestType.SUCCESS;
+    token: string;
+    resources: string[];
+}
+export interface ManifestErrorFetchEvent {
+    type: FinishFetchManifestType.ERROR;
+    token: string;
+    error: CwaResourceError;
+}
+interface AbortFetchEvent {
+    token: string;
+}
+export interface CwaFetcherActionsInterface {
+    abortFetch(event: AbortFetchEvent): void;
+    finishManifestFetch(event: ManifestSuccessFetchEvent | ManifestErrorFetchEvent): void;
+    startFetch(event: StartFetchEvent): StartFetchResponse;
+    finishFetch(event: FinishFetchEvent): void;
+    addFetchResource(event: AddFetchResourceEvent): boolean;
+    clearFetches(): void;
+}
+export default function (fetcherState: CwaFetcherStateInterface, fetcherGetters: CwaFetcherGettersInterface): CwaFetcherActionsInterface;
+export {};

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

@@ -0,0 +1,125 @@
+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;
+    },
+    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.resources = event.resources;
+      }
+      if (event.type === "ERROR" /* ERROR */) {
+        fetchStatus.manifest.error = event.error.asObject;
+      }
+    },
+    startFetch(event) {
+      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 of Object.keys(fetcherState.fetches)) {
+            if (existingToken !== fetcherState.primaryFetch.successToken) {
+              fetcherState.fetches[existingToken].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
+      });
+      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.resources === void 0 && 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,25 @@
+import type { CwaResourceErrorObject } from '../../../errors/cwa-resource-error.js';
+interface FetchManifestInterface {
+    path: string;
+    resources?: string[];
+    error?: CwaResourceErrorObject;
+}
+export interface FetchStatus {
+    path: string;
+    isPrimary: boolean;
+    resources: string[];
+    manifest?: FetchManifestInterface;
+    abort?: true;
+}
+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)
+  };
+}