@cwa/nuxt-edge 0.0.0-29696494.72f11a4

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

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

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,109 @@
+import { useRouter, useRoute } from "vue-router";
+import { computed, ref, watch } from "vue";
+import debounce from "lodash-es/debounce";
+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 matchedParam = matchingParams[0];
+    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 = matchedParam.match(exp);
+    if (!matches || matches.length < 2) {
+      return null;
+    }
+    const matchingObjectKey = matches[1];
+    if (matchingParams.length && matchingObjectKey) {
+      return { [matchingObjectKey]: route.query[matchedParam] };
+    }
+    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/resources/resource-utils";
+import { useCwa } from "#cwa/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, 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,53 @@
+import {
+  getCurrentInstance,
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  watch
+} 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({}));
+  const isAdmin = $cwa.auth.isAdmin;
+  const onManageableComponentMounted = (iriMounted) => {
+    if (iriMounted === iri.value) {
+      manageableResource.initNewIri();
+      $cwa.admin.eventBus.emit("componentMounted", iri.value);
+    }
+  };
+  const initAdmin = () => {
+    manageableResource.init(iri);
+    iri.value && $cwa.admin.eventBus.emit("componentMounted", iri.value);
+    $cwa.admin.eventBus.on("manageableComponentMounted", onManageableComponentMounted);
+  };
+  const clearAdmin = () => {
+    $cwa.admin.eventBus.off("manageableComponentMounted", onManageableComponentMounted);
+    manageableResource.clear();
+  };
+  let stopAdminWatch;
+  onMounted(() => {
+    if (isAdmin.value) {
+      initAdmin();
+    }
+    stopAdminWatch = watch(isAdmin, (isAdminValue, wasAdmin) => {
+      if (isAdminValue && !wasAdmin) {
+        initAdmin();
+      } else if (!isAdminValue && wasAdmin) {
+        clearAdmin();
+      }
+    });
+  });
+  onBeforeUnmount(() => {
+    stopAdminWatch?.();
+    clearAdmin();
+  });
+  return {
+    manager: manageableResource
+  };
+};

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

@@ -0,0 +1,16 @@
+import type { Ref } from 'vue';
+export interface CwaResourceManagerTabOptions {
+    name: string;
+    order?: number;
+    disabled?: boolean;
+}
+export 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>;
+};

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

@@ -0,0 +1,30 @@
+import { computed, ref } from "vue";
+import { useCwa } from "#cwa/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,156 @@
+import { computed, getCurrentInstance, onBeforeUnmount, ref, watch } from "vue";
+import debounce from "lodash-es/debounce";
+import get from "lodash-es/get";
+import isObject from "lodash-es/isObject";
+import set from "lodash-es/set";
+import { useCwa } from "#cwa/composables/cwa";
+import { useCwaResourceEndpoint } from "#cwa/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
+    });
+    isSubmitting.value = false;
+    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;
+      }
+      if (storeValue.value === void 0) {
+        return null;
+      }
+      return storeValue.value;
+    },
+    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>, filename?: string, fileDisplayType?: string) => {
+    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>;
+};

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

@@ -0,0 +1,70 @@
+import { computed, ref } from "vue";
+import { createConfirmDialog } from "vuejs-confirm-dialog";
+import { useCwaResourceEndpoint } from "#cwa/composables/cwa-resource-endpoint";
+import { useCwa } from "#cwa/composables/cwa";
+import ConfirmDialog from "#cwa/templates/components/core/ConfirmDialog.vue";
+export const useCwaResourceUpload = (iri, filename = "file", fileDisplayType = "Image") => {
+  const $cwa = useCwa();
+  const resource = computed(() => iri.value ? $cwa.resources.getResource(iri.value).value : void 0);
+  function getFilename() {
+    return fileData.value ? `Existing ${fileDisplayType} (${fileData.value.formattedFileSize})` : "";
+  }
+  const fileData = computed(() => resource.value?.data?._metadata.mediaObjects?.[filename]?.[0]);
+  const filenameInputModel = ref(getFilename());
+  const fileExists = ref(true);
+  const updating = ref(false);
+  const { endpoint: updateEndpoint } = useCwaResourceEndpoint(iri, "/upload");
+  const { endpoint: deleteEndpoint } = useCwaResourceEndpoint(iri);
+  async function handleInputChangeFile(newFile) {
+    if (!newFile || !iri.value) {
+      return;
+    }
+    updating.value = true;
+    const formData = new FormData();
+    formData.append(filename, newFile);
+    await $cwa.resourcesManager.updateResource({
+      iri: iri.value,
+      endpoint: updateEndpoint.value,
+      data: formData,
+      headers: {
+        accept: "*/*"
+      }
+    });
+    filenameInputModel.value = getFilename();
+    updating.value = false;
+  }
+  async function confirmDelete() {
+    const alertData = {
+      title: `Delete this ${fileDisplayType.toLowerCase()}?`,
+      content: `<p>Are you sure you want to permanently delete this ${fileDisplayType.toLowerCase()}?</p>`
+    };
+    const dialog = createConfirmDialog(ConfirmDialog);
+    const { isCanceled } = await dialog.reveal(alertData);
+    return !isCanceled;
+  }
+  async function handleInputDeleteFile() {
+    if (!fileExists.value || !iri.value) {
+      return;
+    }
+    if (!await confirmDelete()) {
+      return;
+    }
+    updating.value = true;
+    await $cwa.resourcesManager.updateResource({
+      endpoint: deleteEndpoint.value,
+      data: {
+        [filename]: null
+      }
+    });
+    fileExists.value = false;
+    filenameInputModel.value = "";
+    updating.value = false;
+  }
+  return {
+    filenameInputModel,
+    updating,
+    fileExists,
+    handleInputChangeFile,
+    handleInputDeleteFile
+  };
+};

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

@@ -0,0 +1,26 @@
+import type { CwaResource } from '#cwa/resources/resource-utils';
+import type { Ref } from 'vue';
+import type { StyleOptions } from '#cwa/admin/manageable-resource';
+export type IriProp = {
+    iri: string;
+};
+export interface CwaResourceUtilsOps {
+    name?: string;
+    styles?: StyleOptions;
+    manager?: {
+        disabled?: boolean;
+    };
+}
+export interface CwaResourceMeta {
+    cwaResource: {
+        name?: string;
+        styles?: StyleOptions;
+    };
+    disableManager: boolean;
+}
+export declare const useCwaResource: (iri: Ref<string>, ops?: CwaResourceUtilsOps) => {
+    $cwa: import("../cwa.js").default;
+    getResource: () => import("vue").ComputedRef<import("../storage/stores/resources/state.js").CwaCurrentResourceInterface | undefined>;
+    exposeMeta: CwaResourceMeta;
+    getCurrentStyleName: (resource: CwaResource) => string | undefined;
+};

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

@@ -0,0 +1,42 @@
+import isEqual from "lodash-es/isEqual";
+import { computed, getCurrentInstance, onMounted } from "vue";
+import { useCwa } from "./cwa.js";
+export const useCwaResource = (iri, ops) => {
+  const $cwa = useCwa();
+  const instance = getCurrentInstance();
+  const disableManager = !!ops?.manager?.disabled;
+  onMounted(() => {
+    const el = instance?.proxy?.$el;
+    if (el && !el.isConnected) {
+      return;
+    }
+    $cwa.admin.eventBus.emit(disableManager ? "componentMounted" : "manageableComponentMounted", iri.value);
+  });
+  const uiStyles = ops?.styles;
+  const exposeMeta = {
+    cwaResource: {
+      name: ops?.name,
+      styles: uiStyles
+    },
+    disableManager
+  };
+  const getResource = () => {
+    return computed(() => $cwa.resources.getResource(iri.value).value);
+  };
+  const getCurrentStyleName = (resource) => {
+    if (!uiStyles?.classes) return;
+    const currentClassNames = resource.uiClassNames;
+    for (const [name, classes] of Object.entries(uiStyles.classes)) {
+      if (isEqual(currentClassNames, classes)) {
+        return name;
+      }
+    }
+  };
+  return {
+    $cwa,
+    // this needs to be a function so useCwa is not called early - would get issues from ComponentPosition and more
+    getResource,
+    exposeMeta,
+    getCurrentStyleName
+  };
+};

package/dist/runtime/composables/cwa-select-input.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef } from 'vue';
+import type { PopperOptions } from '#cwa/types/popper';
+type ModelValue = undefined | string | number | boolean | object | null | (string | number | boolean | object)[];
+export interface SelectOption {
+    label: string;
+    value: ModelValue;
+    disabled?: boolean;
+}
+export type SelectInputProps = {
+    options: SelectOption[];
+    modelValue: ModelValue;
+    popper?: PopperOptions;
+};
+export declare const useCwaSelectInput: (inputProps: ComputedRef<SelectInputProps>, emit: (event: "update:modelValue", ...args: any[]) => void) => {
+    value: import("vue").WritableComputedRef<ModelValue, ModelValue>;
+    compareOptions: (a: ModelValue, b: ModelValue) => boolean;
+    selectedOption: ComputedRef<SelectOption | null>;
+    trigger: import("vue").Ref<import("@vueuse/core").MaybeElement, import("@vueuse/core").MaybeElement>;
+    container: import("vue").Ref<import("@vueuse/core").MaybeElement, import("@vueuse/core").MaybeElement>;
+};
+export {};