@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/composables/reset-password.js

@@ -0,0 +1,75 @@
+import { computed, reactive, ref } from "vue";
+import { FetchError } from "ofetch";
+import { navigateTo, useRoute } from "#imports";
+import { useCwa } from "#cwa/composables/cwa";
+export const useResetPassword = () => {
+  const route = useRoute();
+  const $cwa = useCwa();
+  const error = ref(null);
+  const submitting = ref(false);
+  const success = ref(false);
+  const submittedFormIri = ref(null);
+  const passwords = reactive({
+    first: "",
+    second: ""
+  });
+  const inputErrors = computed(() => {
+    const formIri = submittedFormIri.value;
+    if (!formIri) {
+      return;
+    }
+    return {
+      form: $cwa.forms.getFormViewErrors(formIri, "password_update").value,
+      password: $cwa.forms.getFormViewErrors(formIri, "password_update[plainPassword][first]").value
+    };
+  });
+  submittedFormIri.value && $cwa.forms.getFormViewErrors(submittedFormIri.value, "password_update[plainPassword][first]");
+  function getStringFromParam(paramName) {
+    const paramValue = route.params[paramName];
+    return (Array.isArray(paramValue) ? paramValue[0] : paramValue) || "";
+  }
+  function handleResetError(fetchError) {
+    if (fetchError.status === 404) {
+      return "The reset link is invalid or has expired. Please restart the reset password process.";
+    }
+    if (fetchError.status === 422) {
+      $cwa.resourcesManager.saveResource({
+        resource: fetchError.data
+      });
+      submittedFormIri.value = fetchError.data["@id"];
+      return;
+    }
+    return fetchError.data?.message || fetchError.statusMessage || "Unexpected error";
+  }
+  async function resetPassword() {
+    if (success.value) {
+      navigateTo("/login");
+    }
+    const previousFormIri = submittedFormIri.value;
+    if (previousFormIri) {
+      $cwa.resourcesManager.removeResource({ resource: previousFormIri });
+      submittedFormIri.value = null;
+    }
+    submitting.value = true;
+    error.value = null;
+    const response = await $cwa.auth.resetPassword({
+      username: getStringFromParam("username"),
+      token: getStringFromParam("token"),
+      passwords
+    });
+    if (response instanceof FetchError) {
+      error.value = handleResetError(response);
+    } else {
+      success.value = true;
+    }
+    submitting.value = false;
+  }
+  return {
+    error,
+    submitting,
+    success,
+    passwords,
+    inputErrors,
+    resetPassword
+  };
+};

package/dist/runtime/composables/transitions.d.ts

@@ -0,0 +1,12 @@
+interface Transitions {
+    [key: string]: {
+        enterActiveClass: string;
+        enterFromClass: string;
+        enterToClass: string;
+        leaveActiveClass: string;
+        leaveFromClass: string;
+        leaveToClass: string;
+    };
+}
+export declare function useTransitions(): Transitions;
+export {};

package/dist/runtime/composables/transitions.js

@@ -0,0 +1,12 @@
+export function useTransitions() {
+  return {
+    context: {
+      enterActiveClass: "cwa:transform-gpu cwa:transition-opacity-transform cwa:ease-out cwa:duration-200",
+      enterFromClass: "cwa:opacity-0 cwa:translate-y-0 cwa:scale-110",
+      enterToClass: "cwa:opacity-100 cwa:translate-y-0 cwa:scale-100",
+      leaveActiveClass: "cwa:duration-0",
+      leaveFromClass: "cwa:opacity-100 cwa:translate-y-0",
+      leaveToClass: "cwa:opacity-0 cwa:translate-y-0"
+    }
+  };
+}

package/dist/runtime/composables/useCwaResourceRoute.d.ts

@@ -0,0 +1,10 @@
+import type { CwaResource } from '#cwa/resources/resource-utils';
+export declare const useCwaResourceRoute: () => {
+    getInternalResourceLink: (iri: string) => {
+        name: string;
+        params: {
+            cwaPage0: string;
+        };
+    };
+    getResourceRoute: (resource: CwaResource, property: string) => any;
+};

package/dist/runtime/composables/useCwaResourceRoute.js

@@ -0,0 +1,17 @@
+export const useCwaResourceRoute = () => {
+  function getInternalResourceLink(iri) {
+    return {
+      name: "_cwa-resource-page",
+      params: {
+        cwaPage0: iri
+      }
+    };
+  }
+  function getResourceRoute(resource, property) {
+    return resource[property] || getInternalResourceLink(resource["@id"]);
+  }
+  return {
+    getInternalResourceLink,
+    getResourceRoute
+  };
+};

package/dist/runtime/composables/useCwaSiteConfig.d.ts

@@ -0,0 +1,15 @@
+import type { CwaResource } from '#cwa/resources/resource-utils';
+import type { SiteConfigParams } from '#cwa/types';
+export declare const defaultSiteConfig: SiteConfigParams;
+export declare function useCwaSiteConfig(): {
+    defaultSiteConfig: SiteConfigParams;
+    responseToConfig: (data: CwaResource, noMerge?: boolean) => Partial<SiteConfigParams>;
+    mergeConfig: (...configs: Partial<SiteConfigParams>[]) => SiteConfigParams;
+    processApiConfigValue: (configValue: any) => any;
+    resolvedConfigToSiteConfig: (config: SiteConfigParams) => {
+        name: string;
+        indexable: boolean;
+        url: string;
+    };
+};
+export default useCwaSiteConfig;

package/dist/runtime/composables/useCwaSiteConfig.js

@@ -0,0 +1,78 @@
+export const defaultSiteConfig = {
+  indexable: true,
+  robotsAllowNonSeoCrawlers: true,
+  robotsAllowAiBots: true,
+  robotsText: "",
+  robotsRemoveSitemap: false,
+  sitemapEnabled: true,
+  siteName: "CWA Web App",
+  fallbackTitle: true,
+  concatTitle: true,
+  maintenanceModeEnabled: false,
+  sitemapXml: "",
+  canonicalUrl: ""
+};
+export function useCwaSiteConfig() {
+  function processApiConfigValue(configValue) {
+    let value = configValue;
+    if (configValue === "0" || configValue === "1" || configValue === "false" || configValue === "true") {
+      value = Boolean(JSON.parse(configValue));
+    }
+    return value;
+  }
+  function getRowsFromResponse(data) {
+    const configRows = data["member"];
+    if (!configRows || !Array.isArray(configRows)) {
+      return;
+    }
+    return configRows;
+  }
+  function siteConfigRowsToConfig(configRows) {
+    const configData = {};
+    for (const configRow of configRows) {
+      const configKey = configRow.key;
+      configData[configKey] = processApiConfigValue(configRow.value);
+    }
+    return configData;
+  }
+  function mergeConfig(...configs) {
+    const filteredConfigs = configs.filter((c) => c !== void 0).map((c) => {
+      return Object.entries(c).reduce((obj, [key, value]) => {
+        if (value !== void 0 && value !== "") {
+          obj[key] = value;
+        }
+        return obj;
+      }, {});
+    });
+    return Object.assign(
+      {},
+      defaultSiteConfig,
+      ...filteredConfigs
+    );
+  }
+  function responseToConfig(data, noMerge) {
+    const rows = getRowsFromResponse(data);
+    if (!rows) {
+      return {};
+    }
+    if (noMerge) {
+      return siteConfigRowsToConfig(rows);
+    }
+    return mergeConfig(siteConfigRowsToConfig(rows));
+  }
+  function resolvedConfigToSiteConfig(config) {
+    return {
+      name: config.siteName,
+      indexable: true,
+      url: config.canonicalUrl
+    };
+  }
+  return {
+    defaultSiteConfig,
+    responseToConfig,
+    mergeConfig,
+    processApiConfigValue,
+    resolvedConfigToSiteConfig
+  };
+}
+export default useCwaSiteConfig;

package/dist/runtime/composables/useResendVerifyEmail.d.ts

@@ -0,0 +1,6 @@
+export declare const useResendVerifyEmail: () => {
+    resendVerifyEmail: (username: string, type: "current" | "new") => Promise<void>;
+    error: import("vue").Ref<string | undefined, string | undefined>;
+    submitting: import("vue").Ref<boolean, boolean>;
+    success: import("vue").Ref<boolean, boolean>;
+};

package/dist/runtime/composables/useResendVerifyEmail.js

@@ -0,0 +1,43 @@
+import { ref } from "vue";
+import { FetchError } from "ofetch";
+import { useCwa } from "#cwa/composables/cwa";
+export const useResendVerifyEmail = () => {
+  const $cwa = useCwa();
+  const error = ref();
+  const submitting = ref(false);
+  const success = ref(false);
+  function handleResetError(fetchError) {
+    if (fetchError.status === 404) {
+      error.value = "Username not found";
+    } else {
+      error.value = fetchError.data?.message || fetchError.statusMessage || "Unexpected error";
+    }
+  }
+  async function resendVerifyEmail(username, type) {
+    if (!username) {
+      error.value = "Please enter a username";
+      return;
+    }
+    submitting.value = true;
+    error.value = void 0;
+    const callFunction = (type2) => {
+      if (type2 === "current") {
+        return $cwa.auth.resendVerifyEmail(username);
+      }
+      return $cwa.auth.resendVerifyNewEmail(username);
+    };
+    const response = await callFunction(type);
+    if (response instanceof FetchError) {
+      handleResetError(response);
+    } else {
+      success.value = true;
+    }
+    submitting.value = false;
+  }
+  return {
+    resendVerifyEmail,
+    error,
+    submitting,
+    success
+  };
+};

package/dist/runtime/composables/useVerifyEmail.d.ts

@@ -0,0 +1,8 @@
+export declare const useVerifyEmail: () => {
+    verifyEmail: () => Promise<void>;
+    confirmEmail: () => Promise<void>;
+    error: import("vue").Ref<string | undefined, string | undefined>;
+    submitting: import("vue").Ref<boolean, boolean>;
+    success: import("vue").Ref<boolean, boolean>;
+    getStringFromParam: (paramName: string) => string;
+};

package/dist/runtime/composables/useVerifyEmail.js

@@ -0,0 +1,84 @@
+import { ref } from "vue";
+import { FetchError } from "ofetch";
+import { useRoute } from "#imports";
+import { useCwa } from "#cwa/composables/cwa";
+export const useVerifyEmail = () => {
+  const route = useRoute();
+  const $cwa = useCwa();
+  const error = ref();
+  const submitting = ref(false);
+  const success = ref(false);
+  function getStringFromParam(paramName) {
+    const paramValue = route.params[paramName];
+    return (Array.isArray(paramValue) ? paramValue[0] : paramValue) || "";
+  }
+  function handleResetError(fetchError) {
+    if (fetchError.status === 404) {
+      error.value = "Request expired or has already been used.";
+    } else {
+      error.value = fetchError.data?.message || fetchError.statusMessage || "Unexpected error";
+    }
+  }
+  async function verifyEmail() {
+    const username = getStringFromParam("username");
+    if (!username) {
+      error.value = "No username specified";
+      return;
+    }
+    const token = getStringFromParam("token");
+    if (!token) {
+      error.value = "No token specified";
+      return;
+    }
+    submitting.value = true;
+    error.value = void 0;
+    const response = await $cwa.auth.verifyEmail({
+      username,
+      token
+    });
+    if (response instanceof FetchError) {
+      handleResetError(response);
+    } else {
+      success.value = true;
+    }
+    submitting.value = false;
+  }
+  async function confirmEmail() {
+    const username = getStringFromParam("username");
+    if (!username) {
+      error.value = "No username specified";
+      return;
+    }
+    const token = getStringFromParam("token");
+    if (!token) {
+      error.value = "No token specified";
+      return;
+    }
+    const newEmail = getStringFromParam("newEmail");
+    if (!newEmail) {
+      error.value = "No new email specified";
+      return;
+    }
+    submitting.value = true;
+    error.value = void 0;
+    const response = await $cwa.auth.confirmEmail({
+      username,
+      token,
+      newEmail
+    });
+    if (response instanceof FetchError) {
+      handleResetError(response);
+    } else {
+      success.value = true;
+    }
+    submitting.value = false;
+  }
+  return {
+    verifyEmail,
+    confirmEmail,
+    error,
+    submitting,
+    success,
+    getStringFromParam
+  };
+};

package/dist/runtime/cwa.d.ts

@@ -0,0 +1,70 @@
+import type { RouteLocationNormalizedLoaded, Router } from 'vue-router';
+import type { CwaModuleOptions, CwaResourcesMeta } from '#cwa/types';
+import type { FetchEvent, FetchResourceEvent } from './api/fetcher/fetcher.js';
+import type { ApiDocumentationComponentMetadataCollection } from './api/api-documentation.js';
+import type { CwaApiDocumentationDataInterface } from './storage/stores/api-documentation/state.js';
+import { ResourcesManager } from './resources/resources-manager.js';
+import { Resources } from './resources/resources.js';
+import Auth from './api/auth.js';
+import Forms from './api/forms.js';
+import Admin from './admin/admin.js';
+import SiteConfig from '#cwa/api/site-config';
+export default class Cwa {
+    private readonly apiUrl;
+    private readonly options;
+    private readonly storage;
+    private readonly apiDocumentation;
+    private readonly mercure;
+    private readonly fetcher;
+    private readonly fetchStatusManager;
+    private readonly cwaFetch;
+    readonly siteConfig: SiteConfig;
+    readonly resources: Resources;
+    readonly resourcesManager: ResourcesManager;
+    readonly auth: Auth;
+    readonly forms: Forms;
+    readonly admin: Admin;
+    private readonly adminNavGuard;
+    readonly currentModulePackageInfo: {
+        version: string;
+        name: string;
+    };
+    constructor($router: Router, options: CwaModuleOptions, currentModulePackageInfo: {
+        version: string;
+        name: string;
+    });
+    get adminNavigationGuardFn(): (toRoute: import("vue-router").RouteLocationNormalized) => boolean | {
+        path: string;
+        query: import("vue-router").LocationQuery;
+        hash: string;
+    };
+    get navigationDisabled(): boolean;
+    getApiDocumentation(refresh?: boolean): Promise<CwaApiDocumentationDataInterface | undefined>;
+    getComponentMetadata(refresh?: boolean, includePosition?: boolean): Promise<undefined | ApiDocumentationComponentMetadataCollection>;
+    fetchResource(event: FetchResourceEvent): Promise<import("#cwa/resources/resource-utils").CwaResource | undefined>;
+    fetchRoute(route: RouteLocationNormalizedLoaded): Promise<import("#cwa/resources/resource-utils").CwaResource | undefined>;
+    fetch(event: FetchEvent): import("./api/fetcher/fetcher.js").CwaFetchResponseRaw;
+    clearPrimaryFetch(): void;
+    initClientSide(): Promise<void>;
+    get resourcesConfig(): CwaResourcesMeta;
+    setResourceMeta(meta: CwaResourcesMeta): void;
+    get layoutsConfig(): {
+        [type: string]: import("#cwa/types").CwaUiMeta;
+    } | undefined;
+    get pagesConfig(): {
+        [type: string]: import("#cwa/types").CwaUiMeta;
+    } | undefined;
+    get pageDataConfig(): {
+        [resourceClass: string]: Pick<import("#cwa/types").CwaUiMeta, "name"> & {
+            metaFields?: {
+                field: string;
+                type: "input" | "select";
+                label: string;
+                options?: import("#imports").SelectOption[];
+            }[];
+        };
+    } | undefined;
+    get config(): import("#cwa/types").SiteConfigParams;
+    get apiUrlBase(): string;
+    addUniquePromise(scope: string, key: string, fn: () => Promise<void>): Promise<void> | undefined;
+}

package/dist/runtime/cwa.js

@@ -0,0 +1,133 @@
+import { useCookie, useRuntimeConfig } from "#imports";
+import { Storage } from "./storage/storage.js";
+import Fetcher from "./api/fetcher/fetcher.js";
+import Mercure from "./api/mercure.js";
+import ApiDocumentation from "./api/api-documentation.js";
+import CwaFetch from "./api/fetcher/cwa-fetch.js";
+import FetchStatusManager from "./api/fetcher/fetch-status-manager.js";
+import { ResourcesManager } from "./resources/resources-manager.js";
+import { Resources } from "./resources/resources.js";
+import Auth from "./api/auth.js";
+import Forms from "./api/forms.js";
+import { useProcess } from "./composables/process.js";
+import Admin from "./admin/admin.js";
+import NavigationGuard from "./admin/navigation-guard.js";
+import { ResourceTypeFromIri } from "#cwa/resources/resource-utils";
+import SiteConfig from "#cwa/api/site-config";
+export default class Cwa {
+  apiUrl;
+  options;
+  storage;
+  apiDocumentation;
+  mercure;
+  fetcher;
+  fetchStatusManager;
+  cwaFetch;
+  siteConfig;
+  // public resources repository and utility getters
+  resources;
+  // public service for managing resources - CRUD functions etc.
+  resourcesManager;
+  // public service for authentication
+  auth;
+  forms;
+  admin;
+  adminNavGuard;
+  currentModulePackageInfo;
+  constructor($router, options, currentModulePackageInfo) {
+    this.currentModulePackageInfo = currentModulePackageInfo;
+    const { isClient } = useProcess();
+    const { public: { cwa: { apiUrl, apiUrlBrowser } } } = useRuntimeConfig();
+    const defaultApiUrl = "https://api-url-not-set.com";
+    if (isClient) {
+      this.apiUrl = apiUrlBrowser || apiUrl || defaultApiUrl;
+    } else {
+      this.apiUrl = apiUrl || apiUrlBrowser || defaultApiUrl;
+    }
+    if (this.apiUrl) {
+      ResourceTypeFromIri.setPathPrefix(new URL(this.apiUrl).pathname);
+    }
+    this.cwaFetch = new CwaFetch(this.apiUrl);
+    this.options = options;
+    this.storage = new Storage(this.options.storeName);
+    this.siteConfig = new SiteConfig(this.cwaFetch, this.storage.stores.siteConfig, this.options.siteConfig);
+    this.apiDocumentation = new ApiDocumentation(this.cwaFetch, this.storage.stores.apiDocumentation);
+    this.mercure = new Mercure(this.storage.stores.mercure, this.storage.stores.resources, this.storage.stores.fetcher);
+    this.fetchStatusManager = new FetchStatusManager(this.storage.stores.fetcher, this.mercure, this.apiDocumentation, this.storage.stores.resources);
+    this.fetcher = new Fetcher(this.cwaFetch, this.fetchStatusManager, $router, this.storage.stores.resources);
+    this.resources = new Resources(this.storage.stores.resources, this.storage.stores.fetcher);
+    this.admin = new Admin(this.storage.stores.admin, this.storage.stores.resources, this.resources);
+    this.resourcesManager = new ResourcesManager(this.cwaFetch, this.storage.stores.resources, this.fetchStatusManager, this.storage.stores.error, this.fetcher, this.admin, this.resources);
+    this.auth = new Auth(
+      this.cwaFetch,
+      this.mercure,
+      this.fetcher,
+      this.admin,
+      this.apiDocumentation,
+      this.storage.stores.auth,
+      this.storage.stores.resources,
+      this.storage.stores.fetcher,
+      useCookie("cwa_auth", { sameSite: "strict" })
+    );
+    this.forms = new Forms(this.storage.stores.resources);
+    this.mercure.setFetcher(this.fetcher);
+    this.mercure.setRequestCount(this.resourcesManager.requestCount);
+    this.adminNavGuard = new NavigationGuard($router, this.storage.stores.admin);
+  }
+  get adminNavigationGuardFn() {
+    return this.adminNavGuard.adminNavigationGuardFn;
+  }
+  get navigationDisabled() {
+    return this.adminNavGuard.navigationDisabled;
+  }
+  // API Documentation service is private, exposing only function required by applications
+  async getApiDocumentation(refresh = false) {
+    return await this.apiDocumentation.getApiDocumentation(refresh);
+  }
+  async getComponentMetadata(refresh = false, includePosition = false) {
+    return await this.apiDocumentation.getComponentMetadata(refresh, includePosition);
+  }
+  // fetcher is private, exposing the only function required by applications
+  fetchResource(event) {
+    return this.fetcher.fetchResource(event);
+  }
+  fetchRoute(route) {
+    return this.fetcher.fetchRoute(route);
+  }
+  fetch(event) {
+    return this.fetcher.fetch(event);
+  }
+  clearPrimaryFetch() {
+    this.fetchStatusManager.clearPrimaryFetch();
+  }
+  // Added as utility to bridge primary functionality of initialising 2 CWA services - this is not required by an application though, perhaps could be moved
+  async initClientSide() {
+    await this.auth.init();
+    this.mercure.init();
+  }
+  get resourcesConfig() {
+    return this.options.resources || {};
+  }
+  // @internal
+  setResourceMeta(meta) {
+    this.options.resources = meta;
+  }
+  get layoutsConfig() {
+    return this.options.layouts;
+  }
+  get pagesConfig() {
+    return this.options.pages;
+  }
+  get pageDataConfig() {
+    return this.options.pageData;
+  }
+  get config() {
+    return this.siteConfig.config;
+  }
+  get apiUrlBase() {
+    return this.apiUrl;
+  }
+  addUniquePromise(scope, key, fn) {
+    return this.storage.addUniquePromise(scope, key, fn);
+  }
+}

package/dist/runtime/errors/cwa-resource-error.d.ts

@@ -0,0 +1,20 @@
+export interface CwaResourceErrorObject {
+    message?: string;
+    statusCode?: number;
+    statusMessage?: string;
+    statusText?: string;
+    request?: string;
+    primaryMessage: string;
+    setCookieHeaders?: string[];
+}
+export declare class CwaResourceError extends Error {
+    name: "CwaResourceError";
+    statusCode?: number;
+    statusMessage?: string;
+    statusText?: string;
+    request?: string;
+    primaryMessage?: string;
+    setCookieHeaders?: string[];
+    asObject?: CwaResourceErrorObject;
+}
+export declare function createCwaResourceError(error: any): CwaResourceError;

package/dist/runtime/errors/cwa-resource-error.js

@@ -0,0 +1,61 @@
+export class CwaResourceError extends Error {
+  name = "CwaResourceError";
+  statusCode;
+  statusMessage;
+  statusText;
+  request;
+  primaryMessage;
+  setCookieHeaders;
+  asObject;
+}
+export function createCwaResourceError(error) {
+  let message = error?.message;
+  if (!message || message === "") {
+    message = "An unknown error occurred";
+  }
+  const cwaResourceError = new CwaResourceError(message);
+  Object.defineProperty(cwaResourceError, "statusCode", {
+    get() {
+      return error?.statusCode;
+    }
+  });
+  Object.defineProperty(cwaResourceError, "statusMessage", {
+    get() {
+      return error?.statusMessage;
+    }
+  });
+  Object.defineProperty(cwaResourceError, "statusText", {
+    get() {
+      return error?.statusText;
+    }
+  });
+  Object.defineProperty(cwaResourceError, "request", {
+    get() {
+      return error?.request ? error.request.toString() : void 0;
+    }
+  });
+  Object.defineProperty(cwaResourceError, "primaryMessage", {
+    get() {
+      return error?.statusText || error?.statusMessage || message;
+    }
+  });
+  Object.defineProperty(cwaResourceError, "setCookieHeaders", {
+    get() {
+      return error?.response?.headers.getSetCookie();
+    }
+  });
+  Object.defineProperty(cwaResourceError, "asObject", {
+    get() {
+      return {
+        message: this.message,
+        statusCode: this.statusCode,
+        statusMessage: this.statusMessage,
+        statusText: this.statusText,
+        primaryMessage: this.primaryMessage,
+        request: this.request,
+        setCookieHeaders: this.setCookieHeaders
+      };
+    }
+  });
+  return cwaResourceError;
+}

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectPlugin } from '#app/nuxt';
+import Cwa from '#cwa/cwa';
+declare const _default: import("nuxt/app").Plugin<{
+    cwa: Cwa;
+}> & ObjectPlugin<{
+    cwa: Cwa;
+}>;
+export default _default;