@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/plugin.js

@@ -0,0 +1,20 @@
+import { addRouteMiddleware, defineNuxtPlugin, useRouter } from "#imports";
+import CwaRouteMiddleware from "#cwa/route-middleware";
+import Cwa from "#cwa/cwa";
+import { options, currentModulePackageInfo } from "#build/cwa-options";
+export default defineNuxtPlugin({
+  name: "cwa-plugin",
+  enforce: "post",
+  dependsOn: ["pinia"],
+  setup() {
+    const router = useRouter();
+    const cwa = new Cwa(router, options, currentModulePackageInfo);
+    addRouteMiddleware("cwa-route-middleware", CwaRouteMiddleware, { global: true });
+    return {
+      provide: {
+        cwa
+      }
+    };
+  },
+  hooks: {}
+});

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

@@ -0,0 +1,52 @@
+import type { CwaCurrentResourceInterface } from '#cwa/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 TypeToAssociatedPropertiesMap = {
+    [T in CwaResourceTypes]: Array<string>;
+};
+export declare class ResourceTypeFromIriCls extends Function {
+    private pathPrefix;
+    setPathPrefix(prefix?: string): void;
+    getPathPrefix(): string | undefined;
+    _call(iri: string): CwaResourceTypes | undefined;
+}
+export declare const ResourceTypeFromIri: ResourceTypeFromIriCls;
+export declare const 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 parentResourceProperties: string[];
+export declare const resourceTypeToAssociatedResourceProperties: TypeToAssociatedPropertiesMap;
+export {};

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

@@ -0,0 +1,86 @@
+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 class ResourceTypeFromIriCls extends Function {
+  pathPrefix;
+  setPathPrefix(prefix) {
+    this.pathPrefix = prefix;
+  }
+  getPathPrefix() {
+    return this.pathPrefix;
+  }
+  _call(iri) {
+    const iriToCompare = this.pathPrefix ? iri.replace(this.pathPrefix, "") : iri;
+    for (const type of Object.values(CwaResourceTypes)) {
+      const prefix = resourceTypeToIriPrefix[type];
+      if (iriToCompare.startsWith(prefix) || iriToCompare === prefix.slice(0, -1)) {
+        return type;
+      }
+    }
+  }
+}
+export const ResourceTypeFromIri = new ResourceTypeFromIriCls();
+export const getResourceTypeFromIri = ResourceTypeFromIri._call.bind(ResourceTypeFromIri);
+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 parentResourceProperties = ["parentPage", "parentPageData"];
+export const resourceTypeToAssociatedResourceProperties = {
+  ["ROUTE" /* ROUTE */]: ["pageData", "page"],
+  ["PAGE" /* PAGE */]: ["layout", "componentGroups", "parentPage", "parentPageData"],
+  ["PAGE_DATA" /* PAGE_DATA */]: ["page", "parentPage", "parentPageData"],
+  ["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, 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/api/fetcher/fetcher';
+import type { AddResourceEvent, ResourceStackItem } from '#cwa/admin/resource-stack-manager';
+import type Admin from '#cwa/admin/admin';
+import type { Resources } from '#cwa/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 fetchStatusManager;
+    private requestsInProgress;
+    private readonly reqCount;
+    private readonly _addResourceEvent;
+    private _requestCount?;
+    private readonly _resourcesStore;
+    private readonly _errorStore;
+    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 {};