@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

package/dist/runtime/composables/cwa-collection-pagination.js

@@ -0,0 +1,34 @@
+import { computed } from "vue";
+export const useCwaCollectionPagination = (props) => {
+  const pages = computed(() => {
+    if (!props.totalPages) {
+      return [];
+    }
+    const allPages = Array.from(Array(props.totalPages), (_, x) => x + 1);
+    const maxPagesToDisplay = props.maxPagesToDisplay || 7;
+    if (allPages.length < maxPagesToDisplay) {
+      return allPages;
+    }
+    const displayPages = [];
+    displayPages.push(props.currentPage);
+    let lowest = props.currentPage;
+    let highest = props.currentPage;
+    let displayCounter = 1;
+    while (displayCounter < maxPagesToDisplay) {
+      displayCounter++;
+      if ((displayCounter % 2 === 0 || highest >= props.totalPages) && lowest > 1) {
+        lowest--;
+        displayPages.unshift(lowest);
+        continue;
+      }
+      if (highest < props.totalPages) {
+        highest++;
+        displayPages.push(highest);
+      }
+    }
+    return displayPages;
+  });
+  return {
+    pages
+  };
+};

package/dist/runtime/composables/cwa-collection-resource.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from 'vue';
+import type { CwaResourceUtilsOps } from './cwa-resource.js';
+import type { CwaResource } from '#cwa/runtime/resources/resource-utils';
+export declare const useCwaCollectionResource: (iri: Ref<string>, ops?: CwaResourceUtilsOps) => {
+    resource: import("vue").ComputedRef<import("../storage/stores/resources/state.js").CwaCurrentResourceInterface | undefined>;
+    collectionItems: import("vue").ComputedRef<CwaResource[] | undefined>;
+    isLoadingCollection: Ref<boolean, boolean>;
+    pageModel: Ref<any, any>;
+    totalPages: Ref<number, number>;
+    goToNextPage: () => void;
+    goToPreviousPage: () => void;
+    changePage: (newPageNumber: number) => void;
+    $cwa: import("../cwa.js").default;
+    getResource: () => import("vue").ComputedRef<import("../storage/stores/resources/state.js").CwaCurrentResourceInterface | undefined>;
+    exposeMeta: import("#imports").CwaResourceMeta;
+};

package/dist/runtime/composables/cwa-collection-resource.js

@@ -0,0 +1,92 @@
+import { computed, ref, watch } from "vue";
+import { useRoute } from "vue-router";
+import { useCwa, useCwaResource, useQueryBoundModel } from "#imports";
+export const useCwaCollectionResource = (iri, ops) => {
+  const cwaResource = useCwaResource(iri, ops);
+  const resource = cwaResource.getResource();
+  const isLoadingCollection = ref(false);
+  const fetchedCollectionItems = ref();
+  const loadCounter = ref(0);
+  const $cwa = useCwa();
+  const route = useRoute();
+  const { model: pageModel } = useQueryBoundModel("page", { defaultValue: 1, asNumber: true });
+  const collectionItems = computed(() => {
+    return fetchedCollectionItems.value || resource.value?.data?.collection?.["hydra:member"];
+  });
+  const dataResourceIri = computed(() => {
+    return resource.value?.data?.resourceIri;
+  });
+  const totalPages = ref(1);
+  function populateCollectionData(resource2) {
+    if (resource2?.collection?.["hydra:member"]) {
+      fetchedCollectionItems.value = resource2?.collection?.["hydra:member"];
+      const lastPagePath = resource2?.collection?.["hydra:view"]?.["hydra:last"];
+      if (!lastPagePath) {
+        totalPages.value = 1;
+      } else {
+        const urlParams = new URLSearchParams(lastPagePath.split("?")[1]);
+        const pageQueryParam = urlParams.get("page");
+        totalPages.value = pageQueryParam ? parseInt(pageQueryParam) || 1 : 1;
+      }
+    }
+  }
+  async function reloadCollection() {
+    if (!dataResourceIri.value) {
+      return;
+    }
+    const currentLoadCounter = ++loadCounter.value;
+    isLoadingCollection.value = true;
+    const { response } = $cwa.fetch({ path: iri.value });
+    const { _data: resource2 } = await response;
+    if (currentLoadCounter === loadCounter.value) {
+      populateCollectionData(resource2);
+      isLoadingCollection.value = false;
+    }
+  }
+  function goToNextPage() {
+    if (pageModel.value >= totalPages.value) {
+      return;
+    }
+    changePage(pageModel.value + 1);
+  }
+  function goToPreviousPage() {
+    if (!pageModel.value || pageModel.value <= 1) {
+      return;
+    }
+    changePage(pageModel.value - 1);
+  }
+  function changePage(newPageNumber) {
+    pageModel.value = newPageNumber;
+  }
+  if (route) {
+    watch(() => route.query, async (newQuery, oldQuery) => {
+      const cleanPaginationFromQuery = (q) => {
+        const cleanQuery = { ...q };
+        delete cleanQuery.perPage;
+        delete cleanQuery.page;
+        return cleanQuery;
+      };
+      const cleanedOld = cleanPaginationFromQuery(oldQuery);
+      const cleanedNew = cleanPaginationFromQuery(newQuery);
+      if (JSON.stringify(cleanedOld) !== JSON.stringify(cleanedNew)) {
+        pageModel.value = 1;
+      }
+      if (JSON.stringify(oldQuery) === JSON.stringify(newQuery)) {
+        return;
+      }
+      await reloadCollection();
+    });
+  }
+  populateCollectionData(resource.value?.data);
+  return {
+    ...cwaResource,
+    resource,
+    collectionItems,
+    isLoadingCollection,
+    pageModel,
+    totalPages,
+    goToNextPage,
+    goToPreviousPage,
+    changePage
+  };
+};

package/dist/runtime/composables/cwa-image.d.ts

@@ -0,0 +1,19 @@
+import { type Ref } from 'vue';
+export declare const useCwaImage: (iri: Ref<string>, imagineFilterName?: string) => {
+    contentUrl: import("vue").ComputedRef<string | undefined>;
+    displayMedia: import("vue").ComputedRef<{
+        contentUrl: string;
+        fileSize: number;
+        mimeType: string;
+        formattedFileSize: string;
+        imagineFilter?: string;
+        width?: number;
+        height?: number;
+    } | undefined>;
+    handleLoad: () => void;
+    loaded: Ref<boolean, boolean>;
+    resource: import("vue").ComputedRef<import("../storage/stores/resources/state.js").CwaCurrentResourceInterface | undefined>;
+    $cwa: import("../cwa.js").default;
+    getResource: () => import("vue").ComputedRef<import("../storage/stores/resources/state.js").CwaCurrentResourceInterface | undefined>;
+    exposeMeta: import("#imports").CwaResourceMeta;
+};

package/dist/runtime/composables/cwa-image.js

@@ -0,0 +1,43 @@
+import { computed, onMounted, ref } from "vue";
+import { useCwaResourceEndpoint } from "#cwa/runtime/composables/cwa-resource-endpoint";
+import { useCwaResource } from "#imports";
+export const useCwaImage = (iri, imagineFilterName) => {
+  const cwaResource = useCwaResource(iri);
+  const { query } = useCwaResourceEndpoint(iri);
+  const resource = cwaResource.getResource();
+  const loaded = ref(false);
+  const image = ref();
+  function handleLoad() {
+    loaded.value = true;
+  }
+  const imageFileMediaObjects = computed(() => {
+    return resource.value?.data?._metadata.mediaObjects?.file;
+  });
+  const displayMedia = computed(() => {
+    if (!imageFileMediaObjects.value || !imageFileMediaObjects.value.length) {
+      return;
+    }
+    const thumbnail = imageFileMediaObjects.value.filter(({ imagineFilter }) => imagineFilter === imagineFilterName);
+    return thumbnail?.[0] || imageFileMediaObjects.value[0];
+  });
+  const contentUrl = computed(() => {
+    const mediaUrl = displayMedia.value?.contentUrl;
+    if (!mediaUrl) {
+      return;
+    }
+    return `${mediaUrl}${query.value}`;
+  });
+  onMounted(() => {
+    if (image.value?.complete || image.value?.naturalHeight !== 0) {
+      handleLoad();
+    }
+  });
+  return {
+    ...cwaResource,
+    contentUrl,
+    displayMedia,
+    handleLoad,
+    loaded,
+    resource
+  };
+};

package/dist/runtime/composables/cwa-query-bound-model.d.ts

@@ -0,0 +1,9 @@
+type ModelOps = {
+    defaultValue?: any;
+    delay?: number;
+    asNumber?: boolean;
+};
+export declare const useQueryBoundModel: (queryParam: string | string[], ops?: ModelOps) => {
+    model: import("vue").Ref<any, any>;
+};
+export {};

package/dist/runtime/composables/cwa-query-bound-model.js

@@ -0,0 +1,108 @@
+import { useRouter, useRoute } from "vue-router";
+import { computed, ref, watch } from "vue";
+import { debounce } from "lodash-es";
+export const useQueryBoundModel = (queryParam, ops) => {
+  const route = useRoute();
+  const router = useRouter();
+  let debounced;
+  const exp = new RegExp(`^${queryParam}\\[([a-zA-Z0-9]+)]$`, "i");
+  const matchingQueryParams = computed(() => {
+    if (!route) {
+      return [];
+    }
+    if (Array.isArray(queryParam)) {
+      const foundParams = [];
+      for (const p of queryParam) {
+        route.query[p] && foundParams.push(p);
+      }
+      return foundParams;
+    }
+    if (route.query[queryParam]) {
+      return [queryParam];
+    }
+    const allQueryParams = Object.keys(route.query);
+    return allQueryParams.filter((param) => exp.test(param));
+  });
+  const matchedQueryParamValue = computed(() => {
+    const matchingParams = matchingQueryParams.value;
+    if (!matchingParams || !matchingParams.length || !route) {
+      return null;
+    }
+    const normalizeValueAsArray = (valueIsArray, value) => {
+      if (Array.isArray(value)) {
+        return value;
+      }
+      if (valueIsArray) {
+        return [value];
+      }
+      return ops?.asNumber && value !== null ? Number(value) : value;
+    };
+    if (Array.isArray(queryParam)) {
+      for (const p of queryParam) {
+        const valueIsArray = p.endsWith("[]");
+        if (route.query[p]) {
+          return normalizeValueAsArray(valueIsArray, route.query[p]);
+        }
+      }
+    } else if (route.query[queryParam]) {
+      const valueIsArray = queryParam.endsWith("[]");
+      return normalizeValueAsArray(valueIsArray, route.query[queryParam]);
+    }
+    const matches = matchingParams[0].match(exp);
+    if (!matches || matches.length < 2) {
+      return null;
+    }
+    const matchingObjectKey = matches[1];
+    if (matchingParams.length && matchingObjectKey) {
+      return { [matchingObjectKey]: route.query[matchingParams[0]] };
+    }
+    return null;
+  });
+  const model = ref(matchedQueryParamValue.value !== null ? matchedQueryParamValue.value : ops?.defaultValue);
+  watch(matchedQueryParamValue, (newValue) => {
+    model.value = newValue;
+  });
+  watch(model, async (newValue) => {
+    if (debounced) {
+      debounced.cancel();
+    }
+    if (!route) {
+      return;
+    }
+    const filteredKeys = Object.keys(route.query).filter((key) => !matchingQueryParams.value.includes(key));
+    const newQuery = {};
+    for (const retainedKey of filteredKeys) {
+      newQuery[retainedKey] = route.query[retainedKey];
+    }
+    const isObj = Object.prototype.toString.call(newValue) === "[object Object]";
+    if (isObj) {
+      for (const newValueKey of Object.keys(newValue)) {
+        if (!newValue[newValueKey]) {
+          continue;
+        }
+        if (Array.isArray(queryParam)) {
+          for (const p of queryParam) {
+            newQuery[`${p}[${newValueKey}]`] = newValue[newValueKey];
+          }
+        } else {
+          newQuery[`${queryParam}[${newValueKey}]`] = newValue[newValueKey];
+        }
+      }
+    } else if (newValue && (!Array.isArray(newValue) || newValue.length)) {
+      if (Array.isArray(queryParam)) {
+        for (const p of queryParam) {
+          newQuery[p] = newValue;
+        }
+      } else {
+        newQuery[queryParam] = newValue;
+      }
+    }
+    debounced = debounce(async () => {
+      await router.replace({ query: newQuery });
+    }, ops?.delay || 10);
+    await debounced();
+  });
+  return {
+    model
+  };
+};

package/dist/runtime/composables/cwa-resource-endpoint.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from 'vue';
+export declare const useCwaResourceEndpoint: (iri: Ref<string | undefined>, postfix?: string) => {
+    endpoint: import("vue").ComputedRef<string>;
+    query: Ref<string, string>;
+};

package/dist/runtime/composables/cwa-resource-endpoint.js

@@ -0,0 +1,36 @@
+import { computed, onBeforeUnmount, ref, watch, watchEffect } from "vue";
+import { getPublishedResourceState } from "#cwa/runtime/resources/resource-utils";
+import { useCwa } from "#cwa/runtime/composables/cwa";
+export const useCwaResourceEndpoint = (iri, postfix) => {
+  const $cwa = useCwa();
+  const resource = computed(() => iri.value ? $cwa.resources.getResource(iri.value).value : void 0);
+  const forcePublishedVersion = $cwa.admin.resourceStackManager.forcePublishedVersion;
+  const applyPostfix = ref(false);
+  const query = ref("");
+  const unwatchEffect = watchEffect(() => {
+    if (!resource.value) {
+      applyPostfix.value = false;
+      return;
+    }
+    const publishableState = getPublishedResourceState(resource.value);
+    applyPostfix.value = (forcePublishedVersion.value !== void 0 || !$cwa.admin.isEditing) && publishableState === true;
+  });
+  const unwatchApplyPostfix = watch(applyPostfix, (newApplyPostfix) => {
+    if (!newApplyPostfix) {
+      query.value = "";
+      return;
+    }
+    query.value = forcePublishedVersion.value || !$cwa.admin.isEditing ? "?published=true" : "?published=false";
+  }, {
+    immediate: true
+  });
+  const endpoint = computed(() => `${iri.value}${postfix || ""}${query.value}`);
+  onBeforeUnmount(() => {
+    unwatchEffect();
+    unwatchApplyPostfix();
+  });
+  return {
+    endpoint,
+    query
+  };
+};

package/dist/runtime/composables/cwa-resource-manageable.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentPublicInstance, type Ref } from 'vue';
+import type { ManageableResourceOps } from '../admin/manageable-resource.js';
+import ManageableResource from '../admin/manageable-resource.js';
+/**
+ * @internal
+ * @description Advanced usage - usually this composable will be initialised from useCwaResource where disableManager does not equal true. Primarily separated for the ComponentGroup component
+ */
+export declare const useCwaResourceManageable: (iri: Ref<string | undefined>, ops?: ManageableResourceOps, proxy?: ComponentPublicInstance) => {
+    manager: ManageableResource;
+};

package/dist/runtime/composables/cwa-resource-manageable.js

@@ -0,0 +1,32 @@
+import {
+  getCurrentInstance,
+  onBeforeUnmount,
+  onMounted,
+  ref
+} from "vue";
+import ManageableResource from "../admin/manageable-resource.js";
+import { useCwa } from "./cwa.js";
+export const useCwaResourceManageable = (iri, ops, proxy) => {
+  const useProxy = proxy || getCurrentInstance()?.proxy;
+  if (!useProxy) {
+    throw new Error(`Cannot initialise manager for resource. Instance is not defined with iri '${iri.value}'`);
+  }
+  const $cwa = useCwa();
+  const manageableResource = new ManageableResource(useProxy, $cwa, ops || ref({}));
+  onMounted(() => {
+    manageableResource.init(iri);
+    iri.value && $cwa.admin.eventBus.emit("componentMounted", iri.value);
+    $cwa.admin.eventBus.on("manageableComponentMounted", (iriMounted) => {
+      if (iriMounted === iri.value) {
+        manageableResource.initNewIri();
+        $cwa.admin.eventBus.emit("componentMounted", iri.value);
+      }
+    });
+  });
+  onBeforeUnmount(() => {
+    manageableResource.clear();
+  });
+  return {
+    manager: manageableResource
+  };
+};

package/dist/runtime/composables/cwa-resource-manager-tab.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from 'vue';
+export interface CwaResourceManagerTabOptions {
+    name: string;
+    order?: number;
+    disabled?: boolean;
+}
+interface CwaResourceManagerTabMeta extends Pick<CwaResourceManagerTabOptions, 'name' | 'order'> {
+    disabled: Ref<boolean>;
+}
+export declare const useCwaResourceManagerTab: (options: CwaResourceManagerTabOptions) => {
+    $cwa: import("../cwa.js").default;
+    iri: import("vue").ComputedRef<string | undefined>;
+    resource: import("vue").ComputedRef<import("../storage/stores/resources/state.js").CwaCurrentResourceInterface | undefined>;
+    exposeMeta: CwaResourceManagerTabMeta;
+    createComputedState: <T = any>(propName: string, initialValue?: T) => import("vue").WritableComputedRef<T, T>;
+};
+export {};

package/dist/runtime/composables/cwa-resource-manager-tab.js

@@ -0,0 +1,30 @@
+import { computed, ref } from "vue";
+import { useCwa } from "#cwa/runtime/composables/cwa";
+export const useCwaResourceManagerTab = (options) => {
+  const $cwa = useCwa();
+  const iri = $cwa.admin.resourceStackManager.currentIri;
+  const resource = computed(() => iri.value ? $cwa.resources.getResource(iri.value).value : void 0);
+  const exposeMeta = {
+    name: options.name,
+    order: options.order,
+    disabled: ref(options.disabled || false)
+  };
+  function createComputedState(propName, initialValue) {
+    initialValue !== void 0 && $cwa.admin.resourceStackManager.getState(propName) === void 0 && $cwa.admin.resourceStackManager.setState(propName, initialValue);
+    return computed({
+      get() {
+        return $cwa.admin.resourceStackManager.getState(propName);
+      },
+      set(val) {
+        $cwa.admin.resourceStackManager.setState(propName, val);
+      }
+    });
+  }
+  return {
+    $cwa,
+    iri,
+    resource,
+    exposeMeta,
+    createComputedState
+  };
+};

package/dist/runtime/composables/cwa-resource-model.d.ts

@@ -0,0 +1,21 @@
+import type { Ref } from 'vue';
+interface ResourceModelOps {
+    longWaitThreshold?: number;
+    debounceTime?: number;
+}
+export declare const useCwaResourceModel: <T>(iri: Ref<string | undefined>, property: string | string[], ops?: ResourceModelOps) => {
+    states: {
+        pendingSubmit: Ref<boolean, boolean>;
+        submitting: Ref<boolean, boolean>;
+        isBusy: import("vue").ComputedRef<boolean>;
+        isLongWait: Ref<boolean, boolean>;
+    };
+    resetValue: (resetIri?: string) => void;
+    model: import("vue").WritableComputedRef<T | null | undefined, T | null | undefined>;
+    localValueWithIri: Ref<{
+        [iri: string]: T | null | undefined;
+    }, {
+        [iri: string]: T | null | undefined;
+    }>;
+};
+export {};

package/dist/runtime/composables/cwa-resource-model.js

@@ -0,0 +1,149 @@
+import { computed, getCurrentInstance, onBeforeUnmount, ref, watch } from "vue";
+import { debounce, get, isObject, set } from "lodash-es";
+import { useCwa } from "#cwa/runtime/composables/cwa";
+import { useCwaResourceEndpoint } from "#cwa/runtime/composables/cwa-resource-endpoint";
+export const useCwaResourceModel = (iri, property, ops) => {
+  const proxy = getCurrentInstance()?.proxy;
+  const source = `input_${proxy?.$?.uid}`;
+  const $cwa = useCwa();
+  const resource = computed(() => iri.value ? $cwa.resources.getResource(iri.value).value : void 0);
+  const { endpoint } = useCwaResourceEndpoint(iri);
+  const storeValue = computed(() => resource.value?.data ? get(resource.value.data, property) : void 0);
+  const rootProperty = computed(() => {
+    if (Array.isArray(property)) {
+      return property[0];
+    }
+    return property.split(".")[0].split("[")[0];
+  });
+  const rootStoreValue = computed(() => resource.value?.data ? get(resource.value.data, rootProperty.value) : void 0);
+  const localValueWithIri = ref({});
+  const localValue = computed({
+    get() {
+      if (!iri.value) {
+        return void 0;
+      }
+      return localValueWithIri.value[iri.value];
+    },
+    set(newValue) {
+      if (!iri.value) {
+        return;
+      }
+      localValueWithIri.value[iri.value] = newValue;
+    }
+  });
+  const pendingSubmit = ref(false);
+  const isLongWait = ref(false);
+  const longWaitThreshold = ops?.longWaitThreshold || 5e3;
+  const debounceTime = ops?.debounceTime !== void 0 ? ops.debounceTime : 250;
+  let debounced;
+  const isBusy = computed(() => pendingSubmit.value || isSubmitting.value);
+  const isSubmitting = ref(false);
+  const lastSubmittedValueInProgress = ref();
+  function isEqual(value1, value2) {
+    function requiresNormalizing(value) {
+      const type = typeof value;
+      return value !== void 0 && value !== null && (type === "object" || Array.isArray(value));
+    }
+    function getNormalizedValue(value) {
+      return requiresNormalizing(value) ? JSON.stringify(value) : value;
+    }
+    return getNormalizedValue(value1) === getNormalizedValue(value2);
+  }
+  async function updateResource(newLocalValue) {
+    const submittingIri = iri.value;
+    if (!submittingIri) {
+      return;
+    }
+    const isNewValueObject = isObject(newLocalValue);
+    isNewValueObject && await $cwa.resourcesManager.getWaitForRequestPromise(endpoint.value, rootProperty.value, source);
+    if (resource.value === void 0 || isSubmitting.value && isEqual(lastSubmittedValueInProgress.value, newLocalValue)) {
+      resetValue();
+      return;
+    }
+    if (!isSubmitting.value && isEqual(storeValue.value, newLocalValue)) {
+      pendingSubmit.value = false;
+      resetValue();
+      return;
+    }
+    isSubmitting.value = true;
+    let submittingValue;
+    if (isNewValueObject) {
+      const newObject = set({ [rootProperty.value]: { ...rootStoreValue.value } }, property, newLocalValue);
+      submittingValue = newObject[rootProperty.value];
+    } else {
+      submittingValue = newLocalValue;
+    }
+    lastSubmittedValueInProgress.value = submittingValue;
+    pendingSubmit.value = false;
+    const newResource = await $cwa.resourcesManager.updateResource({
+      endpoint: endpoint.value,
+      data: {
+        [rootProperty.value]: submittingValue
+      },
+      source
+    });
+    const newIriReturned = newResource?.["@id"] && newResource["@id"] !== submittingIri;
+    if (newIriReturned) {
+      localValueWithIri.value[newResource["@id"]] = localValueWithIri.value[submittingIri];
+      resetValue(submittingIri);
+    }
+    isEqual(storeValue.value, submittingValue) && isEqual(storeValue.value, localValue.value) && resetValue();
+  }
+  function resetValue(resetIri) {
+    const useIri = resetIri || iri.value;
+    if (!useIri) {
+      return;
+    }
+    localValueWithIri.value[useIri] = void 0;
+  }
+  const unwatchLocalValue = watch(localValue, (newLocalValue) => {
+    if (newLocalValue === void 0) {
+      return;
+    }
+    if (debounced) {
+      debounced.cancel();
+    }
+    pendingSubmit.value = true;
+    debounced = debounce(() => updateResource(newLocalValue), debounceTime);
+    debounced();
+  });
+  let longWaitTimeoutFn;
+  const unwatchIsBusy = watch(isBusy, (newBusy) => {
+    if (!newBusy) {
+      isLongWait.value = false;
+      if (longWaitTimeoutFn) {
+        clearTimeout(longWaitTimeoutFn);
+      }
+      return;
+    }
+    longWaitTimeoutFn = setTimeout(() => {
+      isLongWait.value = true;
+    }, longWaitThreshold);
+  });
+  const model = computed({
+    get() {
+      if (localValue.value !== void 0) {
+        return localValue.value;
+      }
+      return storeValue.value || null;
+    },
+    set(value) {
+      localValue.value = value;
+    }
+  });
+  onBeforeUnmount(() => {
+    unwatchLocalValue();
+    unwatchIsBusy();
+  });
+  return {
+    states: {
+      pendingSubmit,
+      submitting: isSubmitting,
+      isBusy,
+      isLongWait
+    },
+    resetValue,
+    model,
+    localValueWithIri
+  };
+};

package/dist/runtime/composables/cwa-resource-upload.d.ts

@@ -0,0 +1,8 @@
+import { type ComputedRef } from 'vue';
+export declare const useCwaResourceUpload: (iri: ComputedRef<string | undefined>) => {
+    filenameInputModel: import("vue").Ref<string, string>;
+    updating: import("vue").Ref<boolean, boolean>;
+    fileExists: import("vue").Ref<boolean, boolean>;
+    handleInputChangeFile: (newFile: File | undefined) => Promise<void>;
+    handleInputDeleteFile: () => Promise<void>;
+};