@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

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

@@ -0,0 +1,54 @@
+import type { CwaResource } from '../../../resources/resource-utils.js';
+import type { CwaResourceError } from '../../../errors/cwa-resource-error.js';
+import type { CwaFetchRequestHeaders } from '../../../api/fetcher/fetcher.js';
+import type { CwaResourcesStateInterface } from './state.js';
+import type { CwaResourcesGettersInterface } from './getters.js';
+import type { AddResourceEvent } from '#cwa/runtime/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;
+    isComplete: false;
+}
+export interface SetResourceCompletedStatusEvent {
+    iri: string;
+    isComplete: true;
+    headers: CwaFetchRequestHeaders;
+}
+export interface SetResourceResetStatusEvent {
+    iri: string;
+    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 {};

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

@@ -0,0 +1,390 @@
+import {
+  CwaResourceTypes,
+  getPublishedResourceState,
+  getResourceTypeFromIri,
+  isCwaResourceSame
+} from "../../../resources/resource-utils.js";
+import {
+  CwaResourceApiStatuses,
+  NEW_RESOURCE_IRI
+} from "./state.js";
+import { showError } from "#app";
+export default function(resourcesState, resourcesGetters) {
+  function initResource({ iri, resourcesState: resourcesState2, isCurrent }) {
+    if (!resourcesState2.current.byId[iri]) {
+      resourcesState2.current.byId[iri] = {
+        apiState: {
+          status: void 0
+        }
+      };
+    }
+    if (!resourcesState2.current.allIds.includes(iri)) {
+      resourcesState2.current.allIds.push(iri);
+    }
+    if (isCurrent && !resourcesState2.current.currentIds.includes(iri)) {
+      resourcesState2.current.currentIds.push(iri);
+    }
+    return resourcesState2.current.byId[iri];
+  }
+  function deleteResource(event) {
+    const resource = resourcesState.current.byId[event.resource];
+    if (!resource) {
+      return;
+    }
+    const resourceType = getResourceTypeFromIri(event.resource);
+    switch (resourceType) {
+      case CwaResourceTypes.COMPONENT_POSITION: {
+        if (event.noCascade) {
+          break;
+        }
+        const componentGroups = resourcesGetters.resourcesByType.value[CwaResourceTypes.COMPONENT_GROUP];
+        for (const componentGroup of Object.values(componentGroups)) {
+          const componentPositions = componentGroup.data?.componentPositions;
+          const positionIndex = componentPositions.indexOf(event.resource);
+          if (positionIndex !== -1) {
+            componentPositions.splice(positionIndex, 1);
+          }
+        }
+        clearPositionToComponentMapping(event.resource);
+        break;
+      }
+      case CwaResourceTypes.COMPONENT: {
+        if (!resource.data || event.noCascade) {
+          break;
+        }
+        const hasAlternativeVersion = resourcesGetters.findAllPublishableIris.value(event.resource).length > 1;
+        if (!hasAlternativeVersion) {
+          const mappedPositions = [...resource.data.componentPositions || [], ...resourcesState.current.positionsByComponent[event.resource] || []];
+          for (const positionIri of mappedPositions) {
+            const positionResource = resourcesState.current.byId[positionIri];
+            if (!positionResource?.data) {
+              continue;
+            }
+            if (!positionResource.data.pageDataProperty) {
+              deleteResource({
+                resource: positionIri
+              });
+            } else if (positionResource.data.component === event.resource) {
+              delete positionResource.data.component;
+            }
+          }
+        }
+        clearPublishableMapping(event.resource);
+        clearPositionToComponentMapping(event.resource);
+        break;
+      }
+    }
+    const allIdsIndex = resourcesState.current.allIds.indexOf(event.resource);
+    allIdsIndex !== -1 && resourcesState.current.allIds.splice(allIdsIndex, 1);
+    const currentIdsIndex = resourcesState.current.currentIds.indexOf(event.resource);
+    currentIdsIndex !== -1 && resourcesState.current.currentIds.splice(currentIdsIndex, 1);
+    delete resourcesState.current.byId[event.resource];
+  }
+  function clearPublishableMapping(iri) {
+    resourcesState.current.publishableMapping = resourcesState.current.publishableMapping.filter((mapping) => {
+      return ![mapping.publishedIri, mapping.draftIri].includes(iri);
+    });
+  }
+  function mapPublishableResource(resource) {
+    if (!resource["@id"] || getResourceTypeFromIri(resource["@id"]) !== CwaResourceTypes.COMPONENT) {
+      return;
+    }
+    const isPublished = getPublishedResourceState({ data: resource });
+    if (isPublished === void 0) {
+      return;
+    }
+    clearPublishableMapping(resource["@id"]);
+    if (isPublished) {
+      if (!resource.draftResource) {
+        return;
+      }
+      clearPublishableMapping(resource.draftResource);
+      resourcesState.current.publishableMapping.push({
+        publishedIri: resource["@id"],
+        draftIri: resource.draftResource
+      });
+      return;
+    }
+    if (!resource.publishedResource) {
+      return;
+    }
+    clearPublishableMapping(resource.publishedResource);
+    resourcesState.current.publishableMapping.push({
+      publishedIri: resource.publishedResource,
+      draftIri: resource["@id"]
+    });
+  }
+  function mapPositionToComponent(resource) {
+    if (!resource["@id"] || getResourceTypeFromIri(resource["@id"]) !== CwaResourceTypes.COMPONENT_POSITION || !resource.component) {
+      return;
+    }
+    const existingPositions = resourcesState.current.positionsByComponent[resource.component] || [];
+    existingPositions.includes(resource["@id"]) === false && existingPositions.push(resource["@id"]);
+    resourcesState.current.positionsByComponent[resource.component] = existingPositions;
+  }
+  function clearPositionToComponentMapping(iri) {
+    const resourceType = getResourceTypeFromIri(iri);
+    if (resourceType === CwaResourceTypes.COMPONENT_POSITION) {
+      const entries = Object.entries(resourcesState.current.positionsByComponent);
+      for (const [componentIri, positionIris] of entries) {
+        resourcesState.current.positionsByComponent[componentIri] = positionIris.filter((pIri) => iri !== pIri);
+      }
+      return;
+    }
+    if (resourceType === CwaResourceTypes.COMPONENT) {
+      if (resourcesState.current.positionsByComponent[iri]) {
+        delete resourcesState.current.positionsByComponent[iri];
+      }
+    }
+  }
+  function saveResource(event) {
+    const clearExistingNewResource = () => {
+      const allIdsIndex = resourcesState.new.allIds.indexOf(iri);
+      if (allIdsIndex !== -1) {
+        resourcesState.new.allIds.splice(allIdsIndex, 1);
+        delete resourcesState.new.byId[iri];
+      }
+    };
+    const iri = event.resource["@id"];
+    if (event.isNew) {
+      const existingResource = resourcesState.current.byId[iri];
+      if (existingResource?.data && isCwaResourceSame(existingResource.data, event.resource)) {
+        clearExistingNewResource();
+        return;
+      }
+      resourcesState.new.byId[iri] = {
+        path: event.path,
+        resource: event.resource
+      };
+      if (!resourcesState.new.allIds.includes(iri)) {
+        resourcesState.new.allIds.push(iri);
+      }
+      return;
+    }
+    const data = initResource({
+      resourcesState,
+      iri,
+      isCurrent: true
+    });
+    data.data = event.resource;
+    clearExistingNewResource();
+    mapPublishableResource(event.resource);
+    mapPositionToComponent(event.resource);
+  }
+  return {
+    resetNewResource() {
+      if (!resourcesState.adding.value) {
+        return;
+      }
+      function clearPositionFromGroup(positionIri) {
+        const positionResource = resourcesGetters.getResource.value(positionIri);
+        if (!positionResource?.data) {
+          return;
+        }
+        const groupIri = positionResource.data.componentGroup;
+        if (!groupIri) {
+          return;
+        }
+        const componentGroup = resourcesGetters.getResource.value(groupIri);
+        if (!componentGroup?.data) {
+          return;
+        }
+        const positions = [...componentGroup.data.componentPositions];
+        const posIndex = positions.indexOf(positionIri);
+        if (posIndex !== -1) {
+          positions.splice(posIndex, 1);
+        }
+        saveResource({
+          resource: {
+            ...componentGroup.data,
+            componentPositions: positions
+          }
+        });
+      }
+      if (resourcesState.adding.value.position) {
+        clearPositionFromGroup(resourcesState.adding.value.position);
+        deleteResource({ resource: resourcesState.adding.value.position });
+      } else {
+        clearPositionFromGroup(resourcesState.adding.value.resource);
+      }
+      deleteResource({ resource: resourcesState.adding.value.resource });
+      resourcesState.adding.value = void 0;
+    },
+    initNewResource(addResourceEvent, resourceType, endpoint, isPublishable, instantAdd, defaultData) {
+      const closestGroup = addResourceEvent.closest.group;
+      const closestPosition = addResourceEvent.closest.position;
+      const addingToGroup = addResourceEvent.targetIri === addResourceEvent.closest.group;
+      const newResource = {
+        ...defaultData,
+        "@id": NEW_RESOURCE_IRI,
+        "@type": resourceType,
+        "_metadata": {
+          adding: {
+            instantAdd,
+            endpoint,
+            isPublishable
+          },
+          persisted: false
+        }
+      };
+      let position;
+      let positionResource;
+      if (resourceType === "ComponentPosition") {
+        newResource.componentGroup = closestGroup;
+      } else if (addResourceEvent.addAfter !== null) {
+        position = `/_/component_positions/${NEW_RESOURCE_IRI}`;
+        newResource.componentPositions = [position];
+        positionResource = {
+          "@id": position,
+          "@type": "ComponentPosition",
+          "component": NEW_RESOURCE_IRI,
+          "componentGroup": closestGroup,
+          "_metadata": {
+            persisted: false
+          }
+        };
+        saveResource({
+          resource: positionResource
+        });
+      } else if (!addResourceEvent.pageDataProperty) {
+        newResource.componentPositions = [addResourceEvent.closest.position];
+      }
+      const newPosition = positionResource || (newResource["@type"] === "ComponentPosition" ? newResource : void 0);
+      if (!addingToGroup && closestPosition && newPosition) {
+        const positionSortValue = resourcesGetters.getPositionSortDisplayNumber.value(closestPosition);
+        if (positionSortValue !== void 0) {
+          newPosition._metadata.sortDisplayNumber = addResourceEvent?.addAfter ? positionSortValue + 1 : positionSortValue;
+        }
+      }
+      saveResource({
+        resource: newResource
+      });
+      resourcesState.adding.value = {
+        resource: NEW_RESOURCE_IRI,
+        position
+      };
+      if (closestGroup && newPosition) {
+        const groupResource = resourcesGetters.getResource.value(closestGroup);
+        if (groupResource?.data) {
+          const existingPositionIris = groupResource.data.componentPositions;
+          if (addingToGroup && existingPositionIris) {
+            newPosition._metadata.sortDisplayNumber = addResourceEvent?.addAfter ? existingPositionIris.length + 1 : 1;
+          }
+          const updatedGroupResource = {
+            ...groupResource.data,
+            componentPositions: [...existingPositionIris || [], position || NEW_RESOURCE_IRI]
+          };
+          saveResource({
+            resource: updatedGroupResource
+          });
+        }
+      }
+    },
+    deleteResource,
+    mergeNewResources() {
+      for (const newId of resourcesState.new.allIds) {
+        const newResource = resourcesState.new.byId[newId];
+        if (Object.keys(newResource.resource).length === 1 && newResource.resource["@id"]) {
+          deleteResource({
+            resource: newId
+          });
+          clearPublishableMapping(newId);
+          clearPositionToComponentMapping(newId);
+          continue;
+        }
+        resourcesState.current.byId[newId] = {
+          apiState: {
+            status: CwaResourceApiStatuses.SUCCESS,
+            headers: {
+              path: newResource.path
+            },
+            fetchedAt: (/* @__PURE__ */ new Date()).getTime()
+          },
+          data: newResource.resource
+        };
+        if (!resourcesState.current.allIds.includes(newId)) {
+          resourcesState.current.allIds.push(newId);
+        }
+        if (!resourcesState.current.currentIds.includes(newId)) {
+          resourcesState.current.currentIds.push(newId);
+        }
+        mapPublishableResource(newResource.resource);
+      }
+      resourcesState.new.allIds = [];
+      resourcesState.new.byId = {};
+    },
+    resetCurrentResources(currentIds) {
+      if (currentIds) {
+        for (const currentId of currentIds) {
+          if (!resourcesState.current.byId[currentId]) {
+            throw new Error(`Cannot set current resource ID '${currentId}'. It does not exist.`);
+          }
+          const currentState = resourcesState.current.byId[currentId].apiState;
+          if (currentState.status !== CwaResourceApiStatuses.ERROR && currentState.headers) {
+            resourcesState.current.byId[currentId].apiState = {
+              status: CwaResourceApiStatuses.SUCCESS,
+              headers: currentState.headers,
+              ssr: currentState.ssr,
+              fetchedAt: currentState.status === CwaResourceApiStatuses.SUCCESS ? currentState.fetchedAt : (/* @__PURE__ */ new Date()).getTime()
+            };
+          }
+        }
+      }
+      resourcesState.new.byId = {};
+      resourcesState.new.allIds = [];
+      resourcesState.current.currentIds = currentIds || [];
+    },
+    clearResources() {
+      resourcesState.current.byId = {};
+      resourcesState.current.allIds = [];
+      resourcesState.current.currentIds = [];
+      resourcesState.current.publishableMapping = [];
+      resourcesState.current.positionsByComponent = {};
+      resourcesState.new.byId = {};
+      resourcesState.new.allIds = [];
+    },
+    setResourceFetchStatus(event) {
+      const data = initResource({
+        resourcesState,
+        iri: event.iri,
+        isCurrent: true
+      });
+      if (event.isComplete) {
+        data.apiState = {
+          status: CwaResourceApiStatuses.SUCCESS,
+          headers: event.headers,
+          // todo: test we reset the ssr state and do not reuse from previous when resource loader re-fetches
+          ssr: import.meta.server,
+          fetchedAt: (/* @__PURE__ */ new Date()).getTime()
+        };
+        return;
+      }
+      const newApiState = {
+        status: CwaResourceApiStatuses.IN_PROGRESS,
+        ssr: import.meta.server
+      };
+      if (data.apiState.status === CwaResourceApiStatuses.SUCCESS) {
+        newApiState.headers = data.apiState.headers;
+        newApiState.ssr = data.apiState.ssr;
+      }
+      data.apiState = newApiState;
+    },
+    setResourceFetchError({ iri, error, isCurrent, showErrorPage }) {
+      const data = initResource({
+        resourcesState,
+        iri,
+        isCurrent: isCurrent === void 0 ? true : isCurrent
+      });
+      data.apiState = {
+        status: CwaResourceApiStatuses.ERROR,
+        error: error?.asObject,
+        ssr: import.meta.server,
+        fetchedAt: (/* @__PURE__ */ new Date()).getTime()
+      };
+      if (showErrorPage && error) {
+        showError({ statusCode: error.statusCode, statusMessage: error.statusMessage, message: error.message });
+      }
+    },
+    saveResource
+  };
+}

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

@@ -0,0 +1,7 @@
+import type { CwaResourcesStateInterface } from './state.js';
+export declare class ResourcesGetterUtils {
+    private readonly resourcesState;
+    constructor(resourcesState: CwaResourcesStateInterface);
+    resourcesApiStateIsPending(resources: string[]): boolean;
+    get totalResourcesPending(): number;
+}

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

@@ -0,0 +1,27 @@
+import { CwaResourceApiStatuses } from "./state.js";
+export class ResourcesGetterUtils {
+  resourcesState;
+  constructor(resourcesState) {
+    this.resourcesState = resourcesState;
+  }
+  resourcesApiStateIsPending(resources) {
+    for (const resource of resources) {
+      const resourceData = this.resourcesState.current.byId[resource];
+      if (!resourceData) {
+        throw new Error(`The resource '${resource}' does not exist.`);
+      }
+      if (resourceData.apiState.status === CwaResourceApiStatuses.IN_PROGRESS) {
+        return true;
+      }
+    }
+    return false;
+  }
+  get totalResourcesPending() {
+    return this.resourcesState.current.currentIds.reduce((count, id) => {
+      if (this.resourcesState.current.byId[id].apiState.status === CwaResourceApiStatuses.IN_PROGRESS) {
+        return ++count;
+      }
+      return count;
+    }, 0);
+  }
+}

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

@@ -0,0 +1,38 @@
+import type { ComputedRef } from 'vue';
+import { CwaResourceTypes } from '../../../resources/resource-utils.js';
+import type { FetchStatus } from '../fetcher/state.js';
+import { type CwaCurrentResourceInterface, type CwaResourcesStateInterface } from './state.js';
+import type { AddResourceEvent } from '#cwa/runtime/admin/resource-stack-manager';
+export interface ResourcesLoadStatusInterface {
+    pending: number;
+    complete: number;
+    total: number;
+    percent: number;
+}
+type ResourcesByTypeInterface = {
+    [T in CwaResourceTypes]: CwaCurrentResourceInterface[];
+};
+interface PublishableMapping {
+    [key: string]: string;
+}
+export interface CwaResourcesGettersInterface {
+    getOrderedPositionsForGroup: ComputedRef<(groupIri: string, includeNewIri?: boolean) => string[] | undefined>;
+    getPositionSortDisplayNumber: ComputedRef<(groupIri: string, includeNewIri?: boolean) => number | undefined>;
+    getResource: ComputedRef<(iri: string) => CwaCurrentResourceInterface | undefined>;
+    getChildIris: ComputedRef<(iri: string, addResourceEvent: undefined | AddResourceEvent) => string[]>;
+    hasNewResources: ComputedRef<boolean>;
+    findPublishedComponentIri: ComputedRef<(iri: string) => string | undefined>;
+    findDraftComponentIri: ComputedRef<(iri: string) => string | undefined>;
+    publishedToDraftIris: ComputedRef<PublishableMapping>;
+    draftToPublishedIris: ComputedRef<PublishableMapping>;
+    isIriPublishableEquivalent: ComputedRef<(oldIri: string, newIri: string) => boolean>;
+    findAllPublishableIris: ComputedRef<(iri: string) => string[]>;
+    resourcesByType: ComputedRef<ResourcesByTypeInterface>;
+    totalResourcesPending: ComputedRef<number>;
+    currentResourcesApiStateIsPending: ComputedRef<boolean>;
+    resourcesApiStateIsPending: ComputedRef<(resources: string[]) => boolean>;
+    isFetchStatusResourcesResolved: ComputedRef<(fetchStatus: FetchStatus) => boolean>;
+    resourceLoadStatus: ComputedRef<ResourcesLoadStatusInterface>;
+}
+export default function (resourcesState: CwaResourcesStateInterface): CwaResourcesGettersInterface;
+export {};