@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/api/fetcher/fetch-status-manager.js

@@ -0,0 +1,225 @@
+import { computed, watch, watchEffect } from "vue";
+import { consola as logger } from "consola";
+import { storeToRefs } from "pinia";
+import { createCwaResourceError } from "../../errors/cwa-resource-error.js";
+import { isCwaResource, ResourceTypeFromIri } from "../../resources/resource-utils.js";
+import { CwaResourceApiStatuses } from "../../storage/stores/resources/state.js";
+import { clearError, useError } from "#imports";
+export default class FetchStatusManager {
+  mercure;
+  apiDocumentation;
+  _fetcherStore;
+  _resourcesStore;
+  _iriToDepth = /* @__PURE__ */ new Map();
+  _depthPaths = /* @__PURE__ */ new Map();
+  constructor(fetcherStoreDefinition, mercure, apiDocumentation, resourcesStoreDefinition) {
+    this.mercure = mercure;
+    this.apiDocumentation = apiDocumentation;
+    this._fetcherStore = fetcherStoreDefinition.useStore();
+    this._resourcesStore = resourcesStoreDefinition.useStore();
+  }
+  async getFetchedCurrentResource(iri, timeout) {
+    const { current: { value: { byId: currentById } } } = storeToRefs(this.resourcesStore);
+    const currentResource = currentById[iri];
+    if (!currentResource) {
+      return;
+    }
+    timeout = timeout || 1e4;
+    let stopWatch;
+    const getResolvedResource = new Promise((resolve) => {
+      const tooLongTimeout = setTimeout(() => {
+        logger.warn(`Timed out ${timeout}ms waiting to fetch current resource '${iri}' in pending API state.`);
+        resolve(void 0);
+      }, timeout);
+      stopWatch = watchEffect(() => {
+        if (currentResource.apiState.status !== CwaResourceApiStatuses.IN_PROGRESS) {
+          clearTimeout(tooLongTimeout);
+          resolve(currentResource.data);
+        }
+      });
+    });
+    const resolvedResource = await getResolvedResource;
+    stopWatch();
+    return resolvedResource || currentResource.data;
+  }
+  startFetch(event) {
+    if (event.isPrimary) {
+      this._iriToDepth = /* @__PURE__ */ new Map();
+      this._depthPaths = /* @__PURE__ */ new Map();
+    }
+    const startFetchStatus = this.fetcherStore.startFetch({ ...event, isCurrentSuccessResourcesResolved: this.isCurrentSuccessResourcesResolved });
+    if (event.isPrimary) {
+      this.resourcesStore.resetCurrentResources(startFetchStatus.resources);
+    }
+    return startFetchStatus;
+  }
+  startFetchResource(event) {
+    const addedToFetcherResources = this.fetcherStore.addFetchResource(event);
+    if (addedToFetcherResources) {
+      this.resourcesStore.setResourceFetchStatus({ iri: event.resource, isComplete: false, path: event.path, headers: event.headers });
+    }
+    return addedToFetcherResources;
+  }
+  finishFetchResource(event) {
+    if (this.resourcesStore.current.byId?.[event.resource]?.apiState.status === CwaResourceApiStatuses.SUCCESS && this.resourcesStore.current.byId?.[event.resource]?.apiState.path === event.path) {
+      return this.resourcesStore.current.byId?.[event.resource]?.data;
+    }
+    const isCurrent = this.fetcherStore.isCurrentFetchingToken(event.token);
+    const fetchStatus = this.fetcherStore.fetches[event.token];
+    if (fetchStatus?.abort) {
+      this.resourcesStore.setResourceFetchError({
+        iri: event.resource,
+        error: createCwaResourceError(new Error(`Not Saved. Fetching token '${event.token}' has been aborted.`)),
+        isCurrent
+      });
+      return;
+    }
+    if (!isCurrent) {
+      this.resourcesStore.setResourceFetchError({
+        iri: event.resource,
+        error: createCwaResourceError(new Error(`Not Saved. Fetching token '${event.token}' is no longer current.`)),
+        isCurrent
+      });
+      return;
+    }
+    const showErrorPage = this.finishFetchShowError(fetchStatus, event.resource);
+    const setFinalResourceFetchError = (error) => {
+      this.resourcesStore.setResourceFetchError({
+        iri: event.resource,
+        error,
+        isCurrent,
+        showErrorPage
+      });
+    };
+    if (!event.success) {
+      setFinalResourceFetchError(event.error);
+      return;
+    }
+    const cwaResource = event.fetchResponse._data;
+    if (!isCwaResource(cwaResource)) {
+      const error = createCwaResourceError(new Error(`Not Saved. The response was not a valid CWA Resource. (${event.resource})`));
+      setFinalResourceFetchError(error);
+      logger.error("[CWA FETCH ERROR: Not a valid CWA resource]", event.resource, cwaResource);
+      return;
+    }
+    if (this.finishFetchShowError(fetchStatus, event.resource)) {
+      const currentError = useError();
+      if (currentError.value?.error) clearError();
+    }
+    const linkHeader = event.fetchResponse.headers.get("link");
+    if (linkHeader) {
+      this.mercure.setMercureHubFromLinkHeader(linkHeader);
+      this.apiDocumentation.setDocsPathFromLinkHeader(linkHeader);
+    }
+    if (!event.noSave) {
+      if (event.userProvidedIri) {
+        cwaResource["@id"] = event.userProvidedIri;
+      }
+      logger.debug(`Save resource with ID '${cwaResource["@id"]}'`, cwaResource);
+      this.resourcesStore.saveResource({
+        resource: cwaResource
+      });
+    }
+    this.resourcesStore.setResourceFetchStatus({
+      responseIri: cwaResource["@id"],
+      iri: event.resource,
+      isComplete: true,
+      headers: event.headers,
+      path: event.path
+    });
+    return cwaResource;
+  }
+  async finishFetch(event) {
+    await this.waitForFetchChainToComplete(event.token);
+    this.fetcherStore.finishFetch(event);
+  }
+  finishFetchShowError(fetchStatus, eventResource) {
+    return !!fetchStatus?.isPrimary && fetchStatus?.path === eventResource;
+  }
+  computedFetchChainComplete(token) {
+    return computed(() => {
+      const resolvingResponse = this.fetcherStore.isFetchResolving(token);
+      if (resolvingResponse.resolving) {
+        return false;
+      }
+      if (resolvingResponse.fetchStatus?.abort) {
+        return true;
+      }
+      const resources = resolvingResponse.fetchStatus?.resources;
+      if (!resources) {
+        return false;
+      }
+      return !this.resourcesStore.resourcesApiStateIsPending(resources);
+    });
+  }
+  async waitForFetchChainToComplete(token) {
+    let fetchChainCompletePromiseResolver;
+    const fetchChainCompletePromise = new Promise((resolve) => {
+      fetchChainCompletePromiseResolver = resolve;
+    });
+    const computedFetchChainComplete = this.computedFetchChainComplete(token);
+    const callback = (isFetchChainComplete) => {
+      if (isFetchChainComplete === true) {
+        fetchChainCompletePromiseResolver();
+      }
+    };
+    const stopWatch = watch(computedFetchChainComplete, callback, {
+      immediate: true
+    });
+    await fetchChainCompletePromise;
+    stopWatch();
+  }
+  setManifestIrisByDepth(event) {
+    this._iriToDepth = /* @__PURE__ */ new Map();
+    this._depthPaths = /* @__PURE__ */ new Map();
+    const prefix = ResourceTypeFromIri.getPathPrefix() || "";
+    const routePathPrefix = `${prefix}/_/routes/`;
+    for (let depth = 0; depth < event.irisByDepth.length; depth++) {
+      for (const iri of event.irisByDepth[depth]) {
+        this._iriToDepth.set(iri, depth);
+        if (!this._depthPaths.has(depth) && iri.startsWith(routePathPrefix)) {
+          this._depthPaths.set(depth, iri.substring(routePathPrefix.length));
+        }
+      }
+    }
+    this.fetcherStore.setManifestIrisByDepth(event);
+  }
+  getDepthForIri(iri) {
+    return this._iriToDepth.get(iri);
+  }
+  getPathForDepth(depth) {
+    return this._depthPaths.get(depth);
+  }
+  registerIriDepth(iri, depth) {
+    this._iriToDepth.set(iri, depth);
+  }
+  finishManifestFetch(event) {
+    this.fetcherStore.finishManifestFetch(event);
+  }
+  isCurrentFetchingToken(token) {
+    return this.fetcherStore.isCurrentFetchingToken(token);
+  }
+  abortFetch(token) {
+    return this.fetcherStore.abortFetch({ token });
+  }
+  // todo: test
+  clearPrimaryFetch() {
+    this.fetcherStore.primaryFetch.successToken = void 0;
+  }
+  get primaryFetchPath() {
+    return this.fetcherStore.primaryFetchPath;
+  }
+  get isCurrentSuccessResourcesResolved() {
+    const successFetchStatus = this.fetcherStore.resolvedSuccessFetchStatus;
+    if (!successFetchStatus) {
+      return false;
+    }
+    return this.resourcesStore.isFetchStatusResourcesResolved(successFetchStatus);
+  }
+  get fetcherStore() {
+    return this._fetcherStore;
+  }
+  get resourcesStore() {
+    return this._resourcesStore;
+  }
+}

package/dist/runtime/api/fetcher/fetcher.d.ts

@@ -0,0 +1,57 @@
+import type { RouteLocationNormalizedLoaded, Router } from 'vue-router';
+import type { FetchResponse } from 'ofetch';
+import type { CwaResource } from '../../resources/resource-utils.js';
+import type { ResourcesStore } from '../../storage/stores/resources/resources-store.js';
+import type CwaFetch from './cwa-fetch.js';
+import type FetchStatusManager from './fetch-status-manager.js';
+export interface FetchResourceEvent {
+    path: string;
+    token?: string;
+    manifestPath?: string;
+    preload?: string[];
+    shallowFetch?: boolean | 'noexist';
+    noSave?: boolean;
+    isPrimary?: boolean;
+    iri?: string;
+}
+export interface FetchManifestEvent {
+    manifestPath: string;
+    token: string;
+}
+export interface FetchEvent {
+    path: string;
+    noQuery?: boolean;
+    preload?: string[];
+}
+export interface CwaFetchRequestHeaders {
+    path?: string;
+    preload?: string;
+}
+export type CwaFetchResponse = FetchResponse<CwaResource | undefined>;
+export interface CwaFetchResponseRaw {
+    response: Promise<CwaFetchResponse>;
+    headers: CwaFetchRequestHeaders;
+}
+interface FetchBatchEvent {
+    paths: string[];
+    token?: string;
+    noSave?: boolean;
+    shallowFetch?: boolean | 'noexist';
+}
+export default class Fetcher {
+    private readonly cwaFetch;
+    private fetchStatusManager;
+    private router;
+    private readonly _store;
+    constructor(cwaFetch: CwaFetch, fetchStatusManager: FetchStatusManager, router: Router, resourcesStoreDefinition: ResourcesStore);
+    fetchRoute(route: RouteLocationNormalizedLoaded): Promise<CwaResource | undefined>;
+    fetchResource({ path, token, manifestPath, preload, shallowFetch, noSave, isPrimary, iri: userProvidedIri }: FetchResourceEvent): Promise<CwaResource | undefined>;
+    private fetchManifest;
+    private fetchAssociatedResources;
+    fetchBatch({ paths, token, noSave, shallowFetch }: FetchBatchEvent): Promise<(CwaResource | undefined)[]>;
+    fetch(event: FetchEvent): CwaFetchResponseRaw;
+    private appendQueryToPath;
+    private createRequestHeaders;
+    private get resourcesStore();
+}
+export {};

package/dist/runtime/api/fetcher/fetcher.js

@@ -0,0 +1,263 @@
+import {
+  CwaResourceTypes,
+  getResourceTypeFromIri,
+  ResourceTypeFromIri,
+  resourceTypeToAssociatedResourceProperties
+} from "../../resources/resource-utils.js";
+import { FinishFetchManifestType } from "../../storage/stores/fetcher/actions.js";
+import { createCwaResourceError } from "../../errors/cwa-resource-error.js";
+import preloadHeaders from "./preload-headers.js";
+export default class Fetcher {
+  constructor(cwaFetch, fetchStatusManager, router, resourcesStoreDefinition) {
+    this.cwaFetch = cwaFetch;
+    this.fetchStatusManager = fetchStatusManager;
+    this.router = router;
+    this._store = resourcesStoreDefinition.useStore();
+  }
+  cwaFetch;
+  fetchStatusManager;
+  router;
+  _store;
+  async fetchRoute(route) {
+    if (route.meta.cwa?.disabled === true) {
+      this.fetchStatusManager.clearPrimaryFetch();
+      return;
+    }
+    let iri;
+    let manifestPath;
+    if (route.meta.cwa?.fetch?.iri) {
+      iri = route.meta.cwa.fetch.iri;
+      manifestPath = route.meta.cwa.fetch.manifestPath;
+    } else {
+      const routeParam = route.params.cwaPage0 || "";
+      iri = Array.isArray(routeParam) ? `/${routeParam.join("/")}` : routeParam;
+      const resourceType = iri ? getResourceTypeFromIri(iri) : void 0;
+      const prefix = ResourceTypeFromIri.getPathPrefix() || "";
+      if (!resourceType || ![CwaResourceTypes.PAGE, CwaResourceTypes.PAGE_DATA].includes(resourceType)) {
+        iri = `${prefix}/_/routes/${route.path}`;
+        manifestPath = `${prefix}/_/resource_manifest/${route.path}`;
+      } else {
+        const id = iri.split("/").pop();
+        manifestPath = `${prefix}/_/resource_manifest/${id}`;
+      }
+    }
+    return await this.fetchResource({
+      path: iri,
+      isPrimary: true,
+      manifestPath
+    });
+  }
+  async fetchResource({ path, token, manifestPath, preload, shallowFetch, noSave, isPrimary, iri: userProvidedIri }) {
+    const iri = userProvidedIri || path.split("?")[0];
+    const startFetchResult = this.fetchStatusManager.startFetch({
+      path,
+      token,
+      isPrimary,
+      manifestPath
+    });
+    if (!startFetchResult.continue) {
+      return this.fetchStatusManager.getFetchedCurrentResource(path);
+    }
+    if (manifestPath) {
+      this.fetchManifest({ token: startFetchResult.token, manifestPath }).then(() => {
+      });
+    }
+    const fetchEvent = {
+      path,
+      preload
+    };
+    const continueToFetchResource = this.fetchStatusManager.startFetchResource({
+      resource: iri,
+      token: startFetchResult.token,
+      path,
+      headers: this.createRequestHeaders(fetchEvent)
+    });
+    if (!continueToFetchResource) {
+      return this.fetchStatusManager.getFetchedCurrentResource(path);
+    }
+    const finishFetchResourceEvent = {
+      resource: iri,
+      userProvidedIri,
+      token: startFetchResult.token
+    };
+    let cwaFetchRaw;
+    let resource;
+    try {
+      cwaFetchRaw = this.fetch(fetchEvent);
+      const fetchResponse = await cwaFetchRaw.response;
+      resource = this.fetchStatusManager.finishFetchResource({
+        ...finishFetchResourceEvent,
+        success: true,
+        fetchResponse,
+        headers: cwaFetchRaw.headers,
+        noSave,
+        path
+      });
+    } catch (error) {
+      const cwaError = createCwaResourceError(error);
+      this.fetchStatusManager.finishFetchResource({
+        ...finishFetchResourceEvent,
+        success: false,
+        error: cwaError,
+        path
+      });
+    }
+    const doRedirect = this.fetchStatusManager.primaryFetchPath === path && getResourceTypeFromIri(iri) === CwaResourceTypes.ROUTE && resource?.redirectPath;
+    if (doRedirect) {
+      this.fetchStatusManager.abortFetch(startFetchResult.token);
+    } else if (resource && shallowFetch !== true) {
+      await this.fetchAssociatedResources({ resource, token: startFetchResult.token, noSave: !!noSave, onlyIfNoExist: shallowFetch === "noexist" });
+    }
+    if (!token) {
+      await this.fetchStatusManager.finishFetch({
+        token: startFetchResult.token
+      });
+    }
+    return resource;
+  }
+  async fetchManifest(event) {
+    let resources = [];
+    try {
+      const result = this.fetch({
+        path: event.manifestPath
+      });
+      const response = await result.response;
+      resources = response._data?.resource_iris || [];
+      this.fetchStatusManager.setManifestIrisByDepth({ token: event.token, irisByDepth: resources });
+      const flatPaths = resources.flat();
+      if (flatPaths.length && this.fetchStatusManager.isCurrentFetchingToken(event.token)) {
+        await this.fetchBatch({ paths: flatPaths, token: event.token });
+      }
+      this.fetchStatusManager.finishManifestFetch({
+        type: FinishFetchManifestType.SUCCESS,
+        token: event.token
+      });
+    } catch (error) {
+      this.fetchStatusManager.finishManifestFetch({
+        type: FinishFetchManifestType.ERROR,
+        token: event.token,
+        error: createCwaResourceError(error)
+      });
+    }
+  }
+  fetchAssociatedResources({ resource, token, noSave, onlyIfNoExist }) {
+    const iri = resource["@id"];
+    const type = getResourceTypeFromIri(iri);
+    if (!type) {
+      return;
+    }
+    let nestedIris = [];
+    const associatedPropertiesToFetch = resourceTypeToAssociatedResourceProperties[type];
+    for (const prop of associatedPropertiesToFetch) {
+      let propIris = resource[prop];
+      if (!propIris) {
+        continue;
+      }
+      if (Array.isArray(propIris)) {
+        for (const value of propIris) {
+          const iri2 = typeof value === "string" ? value : value?.["@id"];
+          if (iri2) nestedIris.push(iri2);
+        }
+      } else {
+        if (prop === "publishedResource") {
+          propIris += "?published=true";
+        }
+        nestedIris.push(propIris);
+      }
+    }
+    if (onlyIfNoExist) {
+      nestedIris = nestedIris.filter((iri2) => !this.resourcesStore.current.currentIds.includes(iri2));
+      if (!nestedIris.length) {
+        return;
+      }
+    }
+    const parentDepth = this.fetchStatusManager.getDepthForIri(iri);
+    if (parentDepth !== void 0) {
+      for (const nestedIri of nestedIris) {
+        this.fetchStatusManager.registerIriDepth(nestedIri, parentDepth);
+      }
+    }
+    return this.fetchBatch({ paths: nestedIris, token, noSave });
+  }
+  fetchBatch({ paths, token, noSave, shallowFetch }) {
+    const promises = [];
+    for (const path of paths) {
+      const pathPromise = new Promise((resolve) => {
+        this.fetchResource({ path, token, noSave, shallowFetch }).then((resource) => {
+          resolve(resource);
+        }).catch(() => {
+          resolve(void 0);
+        });
+      });
+      promises.push(pathPromise);
+    }
+    return Promise.all(promises);
+  }
+  fetch(event) {
+    const url = event.noQuery ? event.path : this.appendQueryToPath(event.path);
+    const headers = this.createRequestHeaders(event);
+    const response = this.cwaFetch.fetch.raw(url, {
+      headers
+    });
+    return {
+      response,
+      headers
+    };
+  }
+  appendQueryToPath(path) {
+    const queryObj = this.router.currentRoute.value?.query;
+    if (!queryObj) {
+      return path;
+    }
+    const queryKeys = Object.keys(queryObj);
+    if (!queryKeys.length) {
+      return path;
+    }
+    const queryString = queryKeys.reduce((accumulator, key) => {
+      if (key.endsWith("[]") && Array.isArray(queryObj[key])) {
+        for (const arrValue of queryObj[key]) {
+          accumulator.push(key + "=" + arrValue);
+        }
+      } else {
+        accumulator.push(key + "=" + queryObj[key]);
+      }
+      return accumulator;
+    }, []).join("&");
+    const delimiter = path.includes("?") ? "&" : "?";
+    return `${path}${delimiter}${queryString}`;
+  }
+  createRequestHeaders(event) {
+    let preload = event.preload;
+    if (!preload) {
+      const resourceType = getResourceTypeFromIri(event.path);
+      if (resourceType) {
+        preload = preloadHeaders[resourceType];
+      }
+    }
+    const requestHeaders = {};
+    if (this.fetchStatusManager.primaryFetchPath) {
+      const prefix = ResourceTypeFromIri.getPathPrefix() || "";
+      const routePathPrefix = `${prefix}/_/routes/`;
+      const iri = event.path.split("?")[0] ?? event.path;
+      const depth = this.fetchStatusManager.getDepthForIri(iri);
+      const depthPath = depth !== void 0 ? this.fetchStatusManager.getPathForDepth(depth) : void 0;
+      if (depthPath !== void 0) {
+        requestHeaders.path = depthPath;
+      } else {
+        const primaryFetchPath = this.fetchStatusManager.primaryFetchPath;
+        if (primaryFetchPath.indexOf(routePathPrefix) === 0) {
+          requestHeaders.path = primaryFetchPath.substring(routePathPrefix.length);
+        } else {
+          requestHeaders.path = primaryFetchPath;
+        }
+      }
+    }
+    if (preload) {
+      requestHeaders.preload = preload.join(",");
+    }
+    return requestHeaders;
+  }
+  get resourcesStore() {
+    return this._store;
+  }
+}

package/dist/runtime/api/fetcher/preload-headers.d.ts

@@ -0,0 +1,6 @@
+import { CwaResourceTypes } from '../../resources/resource-utils.js';
+type PreloadMap = {
+    [T in CwaResourceTypes]: Array<string>;
+};
+declare const preloadHeaders: PreloadMap;
+export default preloadHeaders;

package/dist/runtime/api/fetcher/preload-headers.js

@@ -0,0 +1,31 @@
+import { CwaResourceTypes } from "../../resources/resource-utils.js";
+const preloadToNextComponent = "/componentGroups/*/componentPositions/*/component";
+const preloadHeaders = {
+  [CwaResourceTypes.ROUTE]: [
+    `/page/layout${preloadToNextComponent}${preloadToNextComponent}`,
+    `/page${preloadToNextComponent}${preloadToNextComponent}`,
+    `/pageData/page/layout${preloadToNextComponent}${preloadToNextComponent}`,
+    `/pageData/page${preloadToNextComponent}${preloadToNextComponent}`
+  ],
+  [CwaResourceTypes.PAGE]: [
+    `/layout${preloadToNextComponent}${preloadToNextComponent}`,
+    `${preloadToNextComponent}${preloadToNextComponent}`
+  ],
+  [CwaResourceTypes.LAYOUT]: [
+    `${preloadToNextComponent}${preloadToNextComponent}`
+  ],
+  [CwaResourceTypes.PAGE_DATA]: [
+    `/page/layout${preloadToNextComponent}${preloadToNextComponent}`,
+    `/page${preloadToNextComponent}${preloadToNextComponent}`
+  ],
+  [CwaResourceTypes.COMPONENT_GROUP]: [
+    `/componentPositions/*/component${preloadToNextComponent}${preloadToNextComponent}`
+  ],
+  [CwaResourceTypes.COMPONENT_POSITION]: [
+    `/component${preloadToNextComponent}${preloadToNextComponent}`
+  ],
+  [CwaResourceTypes.COMPONENT]: [
+    preloadToNextComponent
+  ]
+};
+export default preloadHeaders;

package/dist/runtime/api/forms.d.ts

@@ -0,0 +1,40 @@
+import type { ComputedRef } from 'vue';
+import type { ResourcesStore } from '../storage/stores/resources/resources-store.js';
+interface ViewVars {
+    full_name: string;
+    name: string;
+    id: string;
+    unique_block_prefix: string;
+    valid: boolean;
+    submitted: boolean;
+    required: boolean;
+    value: any;
+    errors: string[];
+    action?: string;
+    block_prefixes: string[];
+    disabled: boolean;
+    checked?: boolean;
+    multiple?: boolean;
+    attr: {
+        [key: string]: any;
+    };
+    label?: string;
+    label_attr: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+interface FormView {
+    vars: ViewVars;
+}
+interface KeyedFormView {
+    [key: string]: FormView;
+}
+export default class Forms {
+    private readonly _resourcesStore;
+    constructor(resourcesStoreDefinition: ResourcesStore);
+    getForm(iri: string): ComputedRef<KeyedFormView | undefined>;
+    getFormViewErrors(formIri: string, field: string): ComputedRef<string[] | undefined>;
+    private get resourcesStore();
+}
+export {};

package/dist/runtime/api/forms.js

@@ -0,0 +1,40 @@
+import { computed } from "vue";
+export default class Forms {
+  _resourcesStore;
+  constructor(resourcesStoreDefinition) {
+    this._resourcesStore = resourcesStoreDefinition.useStore();
+  }
+  getForm(iri) {
+    return computed(() => {
+      const resource = this.resourcesStore.current.byId[iri];
+      if (resource?.data?.["@type"] !== "Form") {
+        return;
+      }
+      const createFormViewObject = (apiFormView) => {
+        const structuredFormView = {
+          vars: Object.assign({}, apiFormView.vars)
+        };
+        let data = {
+          [apiFormView.vars.full_name]: structuredFormView
+        };
+        if (apiFormView.children) {
+          for (const child of apiFormView.children) {
+            data = { ...data, ...createFormViewObject(child) };
+          }
+        }
+        return data;
+      };
+      return createFormViewObject(resource.data.formView);
+    });
+  }
+  getFormViewErrors(formIri, field) {
+    return computed(() => {
+      const form = this.getForm(formIri);
+      const errors = form.value?.[field]?.vars.errors;
+      return errors && errors.length ? errors : void 0;
+    });
+  }
+  get resourcesStore() {
+    return this._resourcesStore;
+  }
+}

package/dist/runtime/api/mercure.d.ts

@@ -0,0 +1,32 @@
+import type { ComputedRef } from 'vue';
+import type { MercureStore } from '../storage/stores/mercure/mercure-store.js';
+import type { ResourcesStore } from '../storage/stores/resources/resources-store.js';
+import type { FetcherStore } from '../storage/stores/fetcher/fetcher-store.js';
+import type Fetcher from './fetcher/fetcher.js';
+export default class Mercure {
+    private eventSource?;
+    private lastEventId?;
+    private mercureMessageQueue;
+    private fetcher?;
+    private requestCount?;
+    private readonly _mercureStore;
+    private readonly _resourcesStore;
+    private readonly _fetcherStore;
+    constructor(mercureStoreDefinition: MercureStore, resourcesStoreDefinition: ResourcesStore, fetcherStoreDefinition: FetcherStore);
+    setFetcher(fetcher: Fetcher): void;
+    setRequestCount(requestCount: ComputedRef<number>): void;
+    setMercureHubFromLinkHeader(linkHeader: string): void;
+    init(forceRestart?: boolean): void;
+    closeMercure(): void;
+    private get requestsInProgress();
+    private handleMercureMessage;
+    private isMessageForCurrentResource;
+    private addMercureMessageToQueue;
+    private processMessageQueue;
+    private collectResourceActions;
+    private fetch;
+    private get hubUrl();
+    private get hub();
+    private get mercureStore();
+    private get resourcesStore();
+}