@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

package/dist/runtime/resources/resources.js

@@ -0,0 +1,300 @@
+import { computed } from "vue";
+import { CwaResourceApiStatuses, NEW_RESOURCE_IRI } from "../storage/stores/resources/state.js";
+import {
+  CwaResourceTypes,
+  getResourceTypeFromIri
+} from "./resource-utils.js";
+export class Resources {
+  constructor(resourcesStoreDefinition, fetcherStoreDefinition) {
+    this.resourcesStoreDefinition = resourcesStoreDefinition;
+    this.fetcherStoreDefinition = fetcherStoreDefinition;
+  }
+  get currentIds() {
+    return this.resourcesStore.current.currentIds;
+  }
+  isIriPublishableEquivalent(oldIri, newIri) {
+    return this.resourcesStore.isIriPublishableEquivalent(oldIri, newIri);
+  }
+  findAllPublishableIris(iri) {
+    return this.resourcesStore.findAllPublishableIris(iri);
+  }
+  getResource(id) {
+    return computed(() => {
+      return this.resourcesStore.getResource(id);
+    });
+  }
+  getChildIris(iri, addResourceEvent) {
+    return this.resourcesStore.getChildIris(iri, addResourceEvent);
+  }
+  get newResource() {
+    return computed(() => this.resourcesStore.getResource(NEW_RESOURCE_IRI));
+  }
+  getComponentGroupByReference(reference) {
+    const componentGroups = this.resourcesStore.resourcesByType[CwaResourceTypes.COMPONENT_GROUP];
+    return componentGroups.find((componentGroupResource) => {
+      return componentGroupResource.data?.reference === reference;
+    });
+  }
+  get currentResources() {
+    return this.resourcesStore.current.currentIds.reduce((obj, id) => {
+      const idResource = this.getResource(id).value;
+      if (idResource) {
+        obj[id] = idResource;
+      }
+      return obj;
+    }, {});
+  }
+  get displayFetchStatus() {
+    const fetchingToken = this.fetcherStore.primaryFetch.fetchingToken;
+    if (fetchingToken) {
+      const fetchingStatus = this.fetcherStore.fetches[fetchingToken];
+      if (fetchingStatus) {
+        const pageIri = this.getPageIriByFetchStatus(fetchingStatus);
+        if (pageIri && this.resourcesStore.current.currentIds.includes(pageIri)) {
+          const pageResource = this.getResource(pageIri).value;
+          if (pageResource?.data && pageResource.apiState.status === CwaResourceApiStatuses.SUCCESS) {
+            return fetchingStatus;
+          }
+        }
+      }
+    }
+    return this.fetcherStore.resolvedSuccessFetchStatus;
+  }
+  get pageLoadResources() {
+    const token = this.fetcherStore.primaryFetch.fetchingToken;
+    if (!token) {
+      return;
+    }
+    const fetchStatus = this.fetcherStore.fetches[token];
+    if (!fetchStatus) {
+      return;
+    }
+    const type = this.getFetchStatusType(fetchStatus);
+    if (!type) {
+      return;
+    }
+    const resources = [
+      this.getLayoutIriByFetchStatus(fetchStatus),
+      this.getPageIriByFetchStatus(fetchStatus)
+    ];
+    if (type === CwaResourceTypes.ROUTE || type === CwaResourceTypes.PAGE_DATA) {
+      resources.push(fetchStatus.path);
+    }
+    if (type === CwaResourceTypes.ROUTE) {
+      const routeResource = this.getResource(fetchStatus.path).value;
+      if (routeResource) {
+        const pageDataIri = routeResource.data?.value?.pageData;
+        if (pageDataIri) {
+          resources.push(pageDataIri);
+        }
+      }
+    }
+    return resources;
+  }
+  get pageLoadProgress() {
+    return computed(() => {
+      const pageLoadResources = this.pageLoadResources;
+      if (!pageLoadResources) {
+        return {
+          resources: [],
+          total: 0,
+          complete: 0,
+          percent: 100
+        };
+      }
+      const total = pageLoadResources.length;
+      let complete = 0;
+      for (const resourceIri of pageLoadResources) {
+        if (!resourceIri) {
+          continue;
+        }
+        const resource = this.getResource(resourceIri).value;
+        if (resource?.apiState.status !== CwaResourceApiStatuses.IN_PROGRESS) {
+          complete++;
+        }
+      }
+      const percent = complete ? Math.round(complete / total * 100) : 0;
+      return {
+        resources: pageLoadResources,
+        total,
+        complete,
+        percent
+      };
+    });
+  }
+  isPageDataResource(iri) {
+    return computed(() => {
+      if (!this.pageData?.value?.data || !iri) {
+        return false;
+      }
+      if (getResourceTypeFromIri(iri) !== CwaResourceTypes.COMPONENT) {
+        return false;
+      }
+      const allIris = this.findAllPublishableIris(iri);
+      for (const iri2 of allIris) {
+        if (Object.values(this.pageData.value.data).includes(iri2)) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  getFetchStatusType(fetchStatus) {
+    if (!fetchStatus) {
+      return;
+    }
+    const type = getResourceTypeFromIri(fetchStatus.path);
+    if (!type) {
+      return;
+    }
+    return type;
+  }
+  getLayoutIriByFetchStatus(fetchStatus) {
+    const pageIri = this.getPageIriByFetchStatus(fetchStatus);
+    if (!pageIri) {
+      return;
+    }
+    const pageResource = this.getResource(pageIri).value;
+    return pageResource?.data?.layout;
+  }
+  getPageIriByFetchStatus(fetchStatus) {
+    const type = this.getFetchStatusType(fetchStatus);
+    if (!type) {
+      return;
+    }
+    if (!fetchStatus?.path) {
+      return;
+    }
+    if (type === CwaResourceTypes.PAGE) {
+      return fetchStatus.path;
+    }
+    const successResource = this.getResource(fetchStatus.path).value;
+    if (!successResource) {
+      return;
+    }
+    switch (type) {
+      case CwaResourceTypes.PAGE_DATA: {
+        return successResource.data?.page;
+      }
+      case CwaResourceTypes.ROUTE: {
+        const pageData = successResource.data?.pageData;
+        if (pageData) {
+          const pageDataResource = this.getResource(pageData).value;
+          return pageDataResource?.data?.page;
+        }
+        return successResource.data?.page;
+      }
+    }
+  }
+  get pageDataIri() {
+    return computed(() => {
+      const fetchStatus = this.displayFetchStatus;
+      const type = this.getFetchStatusType(fetchStatus);
+      if (!type) {
+        return;
+      }
+      if (!fetchStatus?.path) {
+        return;
+      }
+      if (type === CwaResourceTypes.PAGE_DATA) {
+        return fetchStatus.path;
+      }
+      const successResource = this.getResource(fetchStatus.path).value;
+      return type === CwaResourceTypes.ROUTE ? successResource?.data?.pageData : void 0;
+    });
+  }
+  get pageData() {
+    if (!this.pageDataIri.value) {
+      return;
+    }
+    return this.getResource(this.pageDataIri.value);
+  }
+  get pageIri() {
+    return computed(() => this.getPageIriByFetchStatus(this.displayFetchStatus));
+  }
+  get page() {
+    if (!this.pageIri.value) {
+      return;
+    }
+    return this.getResource(this.pageIri.value);
+  }
+  get layoutIri() {
+    return computed(() => this.getLayoutIriByFetchStatus(this.displayFetchStatus));
+  }
+  get layout() {
+    return computed(() => {
+      const layoutIri = this.layoutIri.value;
+      if (!layoutIri) {
+        return;
+      }
+      return this.getResource(layoutIri).value;
+    });
+  }
+  findPublishedComponentIri(iri) {
+    return computed(() => {
+      return this.resourcesStore.findPublishedComponentIri(iri);
+    });
+  }
+  findDraftComponentIri(iri) {
+    return computed(() => {
+      return this.resourcesStore.findDraftComponentIri(iri);
+    });
+  }
+  get getOrderedPositionsForGroup() {
+    return this.resourcesStore.getOrderedPositionsForGroup;
+  }
+  get getPositionSortDisplayNumber() {
+    return this.resourcesStore.getPositionSortDisplayNumber;
+  }
+  getRefreshEndpointsForDelete(iri) {
+    const refreshEndpoints = [];
+    if (this.pageDataIri.value) {
+      refreshEndpoints.push(this.pageDataIri.value);
+    }
+    const allIris = this.resourcesStore.findAllPublishableIris(iri);
+    for (const checkIri of allIris) {
+      const componentPositions = this.resourcesStore.current.positionsByComponent[checkIri];
+      if (!componentPositions) {
+        continue;
+      }
+      refreshEndpoints.push(...componentPositions);
+      for (const posIri of componentPositions) {
+        const positionResource = this.getResource(posIri).value;
+        if (positionResource?.data?.componentGroup) {
+          refreshEndpoints.push(positionResource.data.componentGroup);
+        }
+      }
+    }
+    return refreshEndpoints;
+  }
+  get isLoading() {
+    return computed(() => {
+      return !this.fetcherStore.fetchesResolved || !!this.resourceLoadStatus.pending;
+    });
+  }
+  get resourceLoadStatus() {
+    return this.resourcesStore.resourceLoadStatus;
+  }
+  get fetcherStore() {
+    return this.fetcherStoreDefinition.useStore();
+  }
+  get resourcesStore() {
+    return this.resourcesStoreDefinition.useStore();
+  }
+  get usesPageTemplate() {
+    return computed(() => !!this.page?.value?.data?.isTemplate);
+  }
+  get isDataPage() {
+    return computed(() => {
+      return this.usesPageTemplate.value && !!this.pageDataIri.value;
+    });
+  }
+  get isDynamicPage() {
+    return computed(() => {
+      return this.usesPageTemplate.value && !this.pageDataIri.value;
+    });
+  }
+  get hasNewResources() {
+    return this.resourcesStore.hasNewResources;
+  }
+}

package/dist/runtime/route-middleware.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

package/dist/runtime/route-middleware.js

@@ -0,0 +1,86 @@
+import { v4 as uuidv4 } from "uuid";
+import { consola as logger } from "consola";
+import {
+  abortNavigation,
+  callWithNuxt,
+  createError,
+  defineNuxtRouteMiddleware,
+  navigateTo,
+  useNuxtApp
+} from "#app";
+import { useProcess } from "#cwa/runtime/composables/process";
+let middlewareToken = "";
+export default defineNuxtRouteMiddleware(async (to, from) => {
+  const { isClient } = useProcess();
+  middlewareToken = uuidv4();
+  const nuxtApp = useNuxtApp();
+  const adminRouteGuard = nuxtApp.$cwa.adminNavigationGuardFn(to);
+  if (adminRouteGuard === false) {
+    return abortNavigation();
+  }
+  const discardAddingSuccess = await nuxtApp.$cwa.resourcesManager.confirmDiscardAddingResource();
+  if (!discardAddingSuccess) {
+    return abortNavigation();
+  }
+  if (adminRouteGuard !== true) {
+    return navigateTo(adminRouteGuard);
+  }
+  if (isClient) {
+    await nuxtApp.$cwa.initClientSide();
+  }
+  if (to.meta.cwa?.disabled === true) {
+    nuxtApp.$cwa.clearPrimaryFetch();
+    return;
+  }
+  const waitForMiddleware = () => {
+    return new Promise((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (nuxtApp._processingMiddleware === void 0) {
+          resolve(true);
+          clearInterval(checkInterval);
+        }
+      }, 10);
+    });
+  };
+  const handleRouteRedirect = async (resource) => {
+    if (resource?.redirectPath) {
+      if (isClient && nuxtApp._processingMiddleware) {
+        await waitForMiddleware();
+      }
+      return callWithNuxt(nuxtApp, navigateTo, [resource.redirectPath, { redirectCode: 308 }]);
+    }
+  };
+  const isInternalPath = to.path.startsWith("/_/");
+  const throwInternalUnauthorisedError = () => {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorised",
+      message: "You are not authorised to load this resource"
+    });
+  };
+  if (!isClient) {
+    const resource = await nuxtApp.$cwa.fetchRoute(to);
+    return handleRouteRedirect(resource);
+  }
+  const isFirstClientSideRun = nuxtApp.isHydrating && nuxtApp.payload.serverRendered;
+  if (isFirstClientSideRun && !isInternalPath && from.fullPath === to.fullPath) {
+    return;
+  }
+  if (isInternalPath) {
+    await nuxtApp.$cwa.auth.init();
+    if (!nuxtApp.$cwa.auth.isAdmin.value) {
+      throwInternalUnauthorisedError();
+      return;
+    }
+  }
+  const startedMiddlewareToken = middlewareToken;
+  nuxtApp.$cwa.fetchRoute(to).then(async (resource) => {
+    if (startedMiddlewareToken !== middlewareToken && resource?.redirectPath) {
+      return;
+    }
+    const response = await handleRouteRedirect(resource);
+    if (response) {
+      logger.info("Redirect handler failed", response);
+    }
+  });
+});

package/dist/runtime/storage/storage.d.ts

@@ -0,0 +1,20 @@
+import { ResourcesStore } from './stores/resources/resources-store.js';
+import { FetcherStore } from './stores/fetcher/fetcher-store.js';
+import { MercureStore } from './stores/mercure/mercure-store.js';
+import { ApiDocumentationStore } from './stores/api-documentation/api-documentation-store.js';
+import { AuthStore } from './stores/auth/auth-store.js';
+import { AdminStore } from './stores/admin/admin-store.js';
+import { ErrorStore } from './stores/error/error-store.js';
+export interface CwaStores {
+    resources: ResourcesStore;
+    fetcher: FetcherStore;
+    mercure: MercureStore;
+    apiDocumentation: ApiDocumentationStore;
+    auth: AuthStore;
+    admin: AdminStore;
+    error: ErrorStore;
+}
+export declare class Storage {
+    readonly stores: CwaStores;
+    constructor(storeName: string);
+}

package/dist/runtime/storage/storage.js

@@ -0,0 +1,25 @@
+import {
+  ResourcesStore
+} from "./stores/resources/resources-store.js";
+import { FetcherStore } from "./stores/fetcher/fetcher-store.js";
+import { MercureStore } from "./stores/mercure/mercure-store.js";
+import {
+  ApiDocumentationStore
+} from "./stores/api-documentation/api-documentation-store.js";
+import { AuthStore } from "./stores/auth/auth-store.js";
+import { AdminStore } from "./stores/admin/admin-store.js";
+import { ErrorStore } from "./stores/error/error-store.js";
+export class Storage {
+  stores;
+  constructor(storeName) {
+    this.stores = {
+      resources: new ResourcesStore(storeName),
+      fetcher: new FetcherStore(storeName),
+      mercure: new MercureStore(storeName),
+      apiDocumentation: new ApiDocumentationStore(storeName),
+      auth: new AuthStore(storeName),
+      admin: new AdminStore(storeName),
+      error: new ErrorStore(storeName)
+    };
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { CwaAdminStateInterface } from './state.js';
+export interface CwaAdminActionsInterface {
+    toggleEdit(isEditing?: boolean): void;
+}
+export default function (adminState: CwaAdminStateInterface): CwaAdminActionsInterface;

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

@@ -0,0 +1,10 @@
+export default function(adminState) {
+  return {
+    toggleEdit(isEditing) {
+      adminState.state.isEditing = isEditing !== void 0 ? isEditing : !adminState.state.isEditing;
+      if (!adminState.state.isEditing) {
+        adminState.state.navigationGuardDisabled = false;
+      }
+    }
+  };
+}

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

@@ -0,0 +1,18 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaAdminStateInterface } from './state.js';
+import type { CwaAdminActionsInterface } from './actions.js';
+/**
+ * Interface Definitions
+ */
+export interface CwaAdminInterface extends CwaAdminStateInterface, CwaAdminActionsInterface {
+}
+export type CwaAdminStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.admin`, CwaAdminInterface>;
+export type CwaAdminStoreInterface = CwaPiniaStoreInterface<`${string}.admin`, CwaAdminInterface>;
+/**
+ * Main Store Class
+ */
+export declare class AdminStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaAdminStoreInterface;
+}

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

@@ -0,0 +1,20 @@
+import {
+  defineStore
+} from "pinia";
+import CwaAdminState from "./state.js";
+import CwaAdminActions from "./actions.js";
+export class AdminStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.admin`, () => {
+      const adminState = CwaAdminState();
+      return {
+        ...adminState,
+        ...CwaAdminActions(adminState)
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

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

@@ -0,0 +1,7 @@
+export interface CwaAdminStateInterface {
+    state: {
+        isEditing: boolean;
+        navigationGuardDisabled: boolean;
+    };
+}
+export default function (): CwaAdminStateInterface;

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

@@ -0,0 +1,9 @@
+import { reactive } from "vue";
+export default function() {
+  return {
+    state: reactive({
+      isEditing: false,
+      navigationGuardDisabled: false
+    })
+  };
+}

package/dist/runtime/storage/stores/api-documentation/api-documentation-store.d.ts

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

package/dist/runtime/storage/stores/api-documentation/api-documentation-store.js

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

package/dist/runtime/storage/stores/api-documentation/state.d.ts

@@ -0,0 +1,74 @@
+import type { Ref } from 'vue';
+import type { CwaResource } from '#cwa/runtime/resources/resource-utils';
+export interface PageDataMetadataResource extends CwaResource {
+    '@type': 'PageDataMetadata';
+    'resourceClass': string;
+    'properties': {
+        'property': string;
+        'componentShortName': string;
+        '@id': string;
+        '@type': 'PageDataPropertyMetadata';
+    }[];
+}
+export interface CwaApiDocumentationDataInterface {
+    entrypoint?: {
+        '@context': string;
+        '@id': string;
+        '@type': 'Entrypoint';
+        [key: string]: string;
+    };
+    docs?: {
+        '@context': any;
+        '@id': string;
+        '@type': 'hydra:ApiDocumentation';
+        'hydra:title': string;
+        'hydra:description': string;
+        'hydra:entrypoint': string;
+        'hydra:supportedClass': Array<{
+            '@id': string;
+            '@type': string;
+            'hydra:title': string;
+            'rdfs:label': string;
+            'hydra:description': string;
+            'hydra:supportedOperation': Array<{
+                '@type': Array<string> | string;
+                'hydra:method': string;
+                'hydra:title': string;
+                'rdfs:label': string;
+                'returns': string;
+            }>;
+            'hydra:supportedProperty': Array<{
+                '@type': 'hydra:SupportedProperty';
+                'hydra:title': string;
+                'hydra:required': boolean;
+                'hydra:readable': boolean;
+                'hydra:writeable': boolean;
+                'hydra:property': Array<{
+                    '@id': string;
+                    '@type': string;
+                    'rdfs:label': string;
+                    'domain': string;
+                    'range': string;
+                }>;
+            }>;
+        }>;
+        'info': {
+            version: string;
+        };
+    };
+    pageDataMetadata?: {
+        '@context': {
+            '@vocab': string;
+            'hydra': string;
+            'properties': 'PageDataMetadata/properties';
+        };
+        '@id': '/_/page_data_metadatas';
+        '@type': 'hydra:Collection';
+        'hydra:member': PageDataMetadataResource[];
+    };
+}
+export interface CwaApiDocumentationStateInterface {
+    docsPath: Ref<string | null>;
+    apiDocumentation?: CwaApiDocumentationDataInterface;
+}
+export default function (): CwaApiDocumentationStateInterface;

package/dist/runtime/storage/stores/api-documentation/state.js

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+import type { CwaResource } from '../../../resources/resource-utils.js';
+export declare enum CwaUserRoles {
+    SUPER_ADMIN = "ROLE_SUPER_ADMIN",
+    ADMIN = "ROLE_ADMIN",
+    ALLOWED_TO_SWITCH = "ROLE_ALLOWED_TO_SWITCH",
+    USER = "ROLE_USER"
+}
+interface CwaUser extends CwaResource {
+    emailAddress: string;
+    enabled: boolean;
+    roles: (string | CwaUserRoles)[];
+    username: string;
+}
+export interface CwaAuthStateInterface {
+    data: {
+        user?: CwaUser;
+    };
+}
+export default function (): CwaAuthStateInterface;
+export {};