@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

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 "#app";
+import { useCwa } from "#cwa/runtime/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/cwa.d.ts

@@ -0,0 +1,61 @@
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
+import type { CwaModuleOptions, CwaResourcesMeta } from '../module.js';
+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 { type NuxtApp } from '#app/nuxt';
+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 resources: Resources;
+    readonly resourcesManager: ResourcesManager;
+    readonly auth: Auth;
+    readonly forms: Forms;
+    readonly admin: Admin;
+    private readonly adminNavGuard;
+    readonly currentModulePackageInfo: {
+        version: string;
+        name: string;
+    };
+    constructor(nuxtApp: Pick<NuxtApp, '_route' | '_middleware' | '$router' | 'cwaResources'>, 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("./resources/resource-utils.js").CwaResource | undefined>;
+    fetchRoute(route: RouteLocationNormalizedLoaded): Promise<import("./resources/resource-utils.js").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("../module.js").CwaUiMeta;
+    } | undefined;
+    get pagesConfig(): {
+        [type: string]: import("../module.js").CwaUiMeta;
+    } | undefined;
+    get pageDataConfig(): {
+        [resourceClass: string]: Pick<import("../module.js").CwaUiMeta, "name">;
+    } | undefined;
+    get appName(): string;
+    get apiUrlBase(): string;
+}

package/dist/runtime/cwa.js

@@ -0,0 +1,123 @@
+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 { useRuntimeConfig } from "#app/nuxt";
+import { useCookie } from "#app/composables/cookie.js";
+export default class Cwa {
+  apiUrl;
+  options;
+  storage;
+  apiDocumentation;
+  mercure;
+  fetcher;
+  fetchStatusManager;
+  cwaFetch;
+  // 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(nuxtApp, 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;
+    }
+    this.cwaFetch = new CwaFetch(this.apiUrl);
+    this.options = options;
+    this.storage = new Storage(this.options.storeName);
+    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, nuxtApp._route, 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.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(nuxtApp.$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 appName() {
+    return this.options.appName;
+  }
+  get apiUrlBase() {
+    return this.apiUrl;
+  }
+}

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

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

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

@@ -0,0 +1,54 @@
+export class CwaResourceError extends Error {
+  name = "CwaResourceError";
+  statusCode;
+  statusMessage;
+  statusText;
+  request;
+  primaryMessage;
+  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, "asObject", {
+    get() {
+      return {
+        message: this.message,
+        statusCode: this.statusCode,
+        statusMessage: this.statusMessage,
+        statusText: this.statusText,
+        primaryMessage: this.primaryMessage,
+        request: this.request
+      };
+    }
+  });
+  return cwaResourceError;
+}

package/dist/runtime/plugin.d.ts

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

package/dist/runtime/plugin.js

@@ -0,0 +1,18 @@
+import { addRouteMiddleware, defineNuxtPlugin } from "#app";
+import CwaRouteMiddleware from "#cwa/runtime/route-middleware";
+import Cwa from "#cwa/runtime/cwa";
+import { options, currentModulePackageInfo } from "#build/cwa-options";
+export default defineNuxtPlugin({
+  name: "cwa-plugin",
+  enforce: "post",
+  setup(nuxtApp) {
+    const cwa = new Cwa(nuxtApp, options, currentModulePackageInfo);
+    addRouteMiddleware("cwa-route-middleware", CwaRouteMiddleware, { global: true });
+    return {
+      provide: {
+        cwa
+      }
+    };
+  },
+  hooks: {}
+});

package/dist/runtime/resources/resource-utils.d.ts

@@ -0,0 +1,44 @@
+import type { CwaCurrentResourceInterface } from '#cwa/runtime/storage/stores/resources/state';
+export declare enum CwaResourceTypes {
+    ROUTE = "ROUTE",
+    PAGE = "PAGE",
+    LAYOUT = "LAYOUT",
+    PAGE_DATA = "PAGE_DATA",
+    COMPONENT_GROUP = "COMPONENT_GROUP",
+    COMPONENT_POSITION = "COMPONENT_POSITION",
+    COMPONENT = "COMPONENT"
+}
+export interface CwaResource {
+    '@id': string;
+    '@type': string;
+    'publishedResource'?: string;
+    'draftResource'?: string;
+    'uiComponent'?: string;
+    'sortValue'?: number;
+    'componentGroup'?: string;
+    '_metadata': {
+        adding?: {
+            instantAdd: boolean;
+            endpoint: string;
+            isPublishable: boolean;
+        };
+        persisted: boolean;
+        publishable?: {
+            published: boolean;
+            publishedAt: string;
+        };
+        sortDisplayNumber?: number;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+type TypeToNestedPropertiesMap = {
+    [T in CwaResourceTypes]: Array<string>;
+};
+export declare function getResourceTypeFromIri(iri: string): CwaResourceTypes | undefined;
+export declare function getPublishedResourceState(resource: Pick<CwaCurrentResourceInterface, 'data'>): undefined | boolean;
+export declare function getPublishedResourceIri(resourceData: CwaResource): string | null;
+export declare function isCwaResource(obj: any): obj is CwaResource;
+export declare function isCwaResourceSame(resource1: CwaResource, resource2: CwaResource): boolean;
+export declare const resourceTypeToNestedResourceProperties: TypeToNestedPropertiesMap;
+export {};

package/dist/runtime/resources/resource-utils.js

@@ -0,0 +1,73 @@
+export var CwaResourceTypes = /* @__PURE__ */ ((CwaResourceTypes2) => {
+  CwaResourceTypes2["ROUTE"] = "ROUTE";
+  CwaResourceTypes2["PAGE"] = "PAGE";
+  CwaResourceTypes2["LAYOUT"] = "LAYOUT";
+  CwaResourceTypes2["PAGE_DATA"] = "PAGE_DATA";
+  CwaResourceTypes2["COMPONENT_GROUP"] = "COMPONENT_GROUP";
+  CwaResourceTypes2["COMPONENT_POSITION"] = "COMPONENT_POSITION";
+  CwaResourceTypes2["COMPONENT"] = "COMPONENT";
+  return CwaResourceTypes2;
+})(CwaResourceTypes || {});
+const resourceTypeToIriPrefix = {
+  ["ROUTE" /* ROUTE */]: "/_/routes/",
+  ["PAGE" /* PAGE */]: "/_/pages/",
+  ["PAGE_DATA" /* PAGE_DATA */]: "/page_data/",
+  ["LAYOUT" /* LAYOUT */]: "/_/layouts/",
+  ["COMPONENT_GROUP" /* COMPONENT_GROUP */]: "/_/component_groups/",
+  ["COMPONENT_POSITION" /* COMPONENT_POSITION */]: "/_/component_positions/",
+  ["COMPONENT" /* COMPONENT */]: "/component/"
+};
+export function getResourceTypeFromIri(iri) {
+  for (const type of Object.values(CwaResourceTypes)) {
+    const prefix = resourceTypeToIriPrefix[type];
+    if (iri.startsWith(prefix) || iri === prefix.slice(0, -1)) {
+      return type;
+    }
+  }
+}
+export function getPublishedResourceState(resource) {
+  const publishableMeta = resource.data?._metadata.publishable;
+  return publishableMeta?.published;
+}
+export function getPublishedResourceIri(resourceData) {
+  const publishableMetadata = resourceData._metadata?.publishable;
+  const resourceIri = resourceData["@id"];
+  if (!publishableMetadata) {
+    return resourceIri;
+  }
+  if (publishableMetadata.published) {
+    return resourceIri;
+  }
+  return resourceData.publishedResource || null;
+}
+export function isCwaResource(obj) {
+  if (typeof obj !== "object") {
+    return false;
+  }
+  return obj["@id"] !== void 0 && obj["@type"] !== void 0 && obj._metadata !== void 0 && typeof obj._metadata === "object";
+}
+export function isCwaResourceSame(resource1, resource2) {
+  const clearAndStringify = (obj) => {
+    const newObj = Object.assign({}, obj);
+    delete newObj.publishedResource;
+    delete newObj.draftResource;
+    delete newObj.modifiedAt;
+    delete newObj._metadata;
+    if (getResourceTypeFromIri(newObj["@id"]) === "COMPONENT" /* COMPONENT */) {
+      delete newObj.componentPositions;
+    }
+    Object.keys(newObj).forEach((k) => newObj[k] === null && delete newObj[k]);
+    return JSON.stringify(newObj);
+  };
+  return clearAndStringify(resource1) === clearAndStringify(resource2);
+}
+export const resourceTypeToNestedResourceProperties = {
+  ["ROUTE" /* ROUTE */]: ["pageData", "page"],
+  ["PAGE" /* PAGE */]: ["layout", "componentGroups"],
+  ["PAGE_DATA" /* PAGE_DATA */]: ["page"],
+  ["LAYOUT" /* LAYOUT */]: ["componentGroups"],
+  ["COMPONENT_GROUP" /* COMPONENT_GROUP */]: ["componentPositions"],
+  ["COMPONENT_POSITION" /* COMPONENT_POSITION */]: ["component"],
+  // draft will always be fetched by default if exists and auth to do, so we just need to fetch the associated published resource - will only be returned if we have auth
+  ["COMPONENT" /* COMPONENT */]: ["componentGroups", "publishedResource"]
+};

package/dist/runtime/resources/resources-manager.d.ts

@@ -0,0 +1,70 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { ResourcesStore } from '../storage/stores/resources/resources-store.js';
+import type CwaFetch from '../api/fetcher/cwa-fetch.js';
+import type FetchStatusManager from '../api/fetcher/fetch-status-manager.js';
+import type { DeleteResourceEvent, SaveNewResourceEvent, SaveResourceEvent } from '../storage/stores/resources/actions.js';
+import type { ErrorStore } from '../storage/stores/error/error-store.js';
+import type { CwaErrorEvent } from '../storage/stores/error/state.js';
+import { type CwaResource } from './resource-utils.js';
+import type Fetcher from '#cwa/runtime/api/fetcher/fetcher';
+import type { AddResourceEvent, ResourceStackItem } from '#cwa/runtime/admin/resource-stack-manager';
+import type Admin from '#cwa/runtime/admin/admin';
+import type { Resources } from '#cwa/runtime/resources/resources';
+interface DeleteApiResourceEvent {
+    iri?: string;
+    endpoint: string;
+    requestCompleteFn?: (resource?: CwaResource) => void | Promise<void>;
+    saveCompleteFn?: (resource?: CwaResource) => void | Promise<void>;
+    refreshEndpoints?: string[];
+}
+interface DataApiResourceEvent extends DeleteApiResourceEvent {
+    data: any;
+    source?: string;
+    headers?: Record<string, string>;
+}
+export type ApiResourceEvent = DataApiResourceEvent | DeleteApiResourceEvent;
+export declare class ResourcesManager {
+    private readonly fetcher;
+    private readonly admin;
+    private readonly resources;
+    private readonly cwaFetch;
+    private readonly resourcesStoreDefinition;
+    private readonly fetchStatusManager;
+    private readonly errorStoreDefinition;
+    private requestsInProgress;
+    private readonly reqCount;
+    private readonly _addResourceEvent;
+    private _requestCount?;
+    constructor(cwaFetch: CwaFetch, resourcesStoreDefinition: ResourcesStore, fetchStatusManager: FetchStatusManager, errorStoreDefinition: ErrorStore, fetcher: Fetcher, admin: Admin, resources: Resources);
+    mergeNewResources(): void;
+    get requestCount(): ComputedRef<number>;
+    getWaitForRequestPromise(endpoint: string, property: string, source?: string): Promise<void>;
+    createResource(event: DataApiResourceEvent): Promise<CwaResource | undefined>;
+    private confirmDelete;
+    private getEndpointForIri;
+    deleteResource(event: ApiResourceEvent): Promise<false | CwaResource | undefined>;
+    removeResource(event: DeleteResourceEvent): void;
+    updateResource(event: DataApiResourceEvent): Promise<CwaResource | undefined>;
+    private doResourceRequest;
+    addError(error: CwaErrorEvent): void;
+    get errors(): CwaErrorEvent[];
+    get hasErrors(): boolean;
+    removeError(id: number): void;
+    saveResource(event: SaveResourceEvent | SaveNewResourceEvent): void;
+    private requestOptions;
+    initAddResource(targetIri: string, addAfter: null | boolean, resourceStack: ResourceStackItem[], pageDataProperty?: string): Promise<void>;
+    setAddResourceEventResource(resourceType: string, endpoint: string, isPublishable: boolean, instantAdd: boolean, defaultData?: {
+        [key: string]: any;
+    }): Promise<void>;
+    clearAddResourceEventResource(): void;
+    clearAddResource(): void;
+    get addResourceEvent(): Ref<AddResourceEvent | undefined, AddResourceEvent | undefined>;
+    confirmDiscardAddingResource(): Promise<boolean>;
+    addResourceAction(publish?: boolean): Promise<CwaResource | undefined>;
+    private getRefreshPositions;
+    private get groupResource();
+    private get groupResourcePositions();
+    private get resourcesStore();
+    private get errorStore();
+}
+export {};