@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

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/runtime/composables/cwa-resource-endpoint";
+import { useCwa } from "#cwa/runtime/composables/cwa";
+import ConfirmDialog from "#cwa/runtime/templates/components/core/ConfirmDialog.vue";
+export const useCwaResourceUpload = (iri) => {
+  const $cwa = useCwa();
+  const resource = computed(() => iri.value ? $cwa.resources.getResource(iri.value).value : void 0);
+  function getFilename() {
+    return fileData.value ? `Existing Image (${fileData.value.formattedFileSize})` : "";
+  }
+  const fileData = computed(() => resource.value?.data?._metadata.mediaObjects?.file[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("file", 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 image?",
+      content: "<p>Are you sure you want to permanently delete this image?</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: {
+        file: 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,24 @@
+import type { Ref } from 'vue';
+import type { StyleOptions } from '#cwa/runtime/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;
+};

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

@@ -0,0 +1,22 @@
+import { computed, onMounted } from "vue";
+import { useCwa } from "./cwa.js";
+export const useCwaResource = (iri, ops) => {
+  const $cwa = useCwa();
+  const disableManager = !!ops?.manager?.disabled;
+  onMounted(() => {
+    $cwa.admin.eventBus.emit(disableManager ? "componentMounted" : "manageableComponentMounted", iri.value);
+  });
+  const exposeMeta = {
+    cwaResource: {
+      name: ops?.name,
+      styles: ops?.styles
+    },
+    disableManager
+  };
+  return {
+    $cwa,
+    // this needs to be a function so useCwa is not called early - would get issues from ComponentPosition and more
+    getResource: () => computed(() => $cwa.resources.getResource(iri.value).value),
+    exposeMeta
+  };
+};

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

@@ -0,0 +1,21 @@
+import { type ComputedRef } from 'vue';
+import type { PopperOptions } from '#cwa/runtime/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>;
+    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 {};

package/dist/runtime/composables/cwa-select-input.js

@@ -0,0 +1,37 @@
+import { computed } from "vue";
+import { isEqual } from "lodash-es";
+import { defu } from "defu";
+import { usePopper } from "#cwa/runtime/composables/popper";
+export const useCwaSelectInput = (inputProps, emit) => {
+  const value = computed({
+    get() {
+      return inputProps.value.modelValue;
+    },
+    set(value2) {
+      emit("update:modelValue", value2);
+    }
+  });
+  const ops = {
+    popper: {
+      placement: "bottom-start"
+    }
+  };
+  const selectedOption = computed(() => {
+    return inputProps.value.options.find(({ value: value2 }) => isEqual(value2, inputProps.value.modelValue)) || inputProps.value.options[0] || null;
+  });
+  const popperOps = computed(() => defu({}, inputProps.value.popper, ops.popper));
+  const [trigger, container] = usePopper(popperOps.value);
+  function compareOptions(a, b) {
+    if (a === void 0 && b === null) {
+      return true;
+    }
+    return isEqual(a, b);
+  }
+  return {
+    value,
+    compareOptions,
+    selectedOption,
+    trigger,
+    container
+  };
+};

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

@@ -0,0 +1,15 @@
+import { type Ref } from 'vue';
+import type { SelectOption } from './cwa-select-input.js';
+import type { ModelValue } from '#cwa/runtime/templates/components/ui/form/Button.vue';
+export declare const useCwaSelect: (model: Ref<ModelValue>, ops?: SelectOption[]) => {
+    model: Ref<ModelValue, ModelValue>;
+    options: Ref<{
+        label: string;
+        value: string | number | boolean | object | (string | number | boolean | object)[] | null | undefined;
+        disabled?: boolean | undefined;
+    }[], SelectOption[] | {
+        label: string;
+        value: string | number | boolean | object | (string | number | boolean | object)[] | null | undefined;
+        disabled?: boolean | undefined;
+    }[]>;
+};

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

@@ -0,0 +1,24 @@
+import { ref, watch } from "vue";
+import { isEqual } from "lodash-es";
+export const useCwaSelect = (model, ops = []) => {
+  const selectModel = ref(model.value);
+  const options = ref(ops);
+  watch(options, (newOptions) => {
+    const selectOption = newOptions.find((op) => {
+      return isEqual(op.value, model.value);
+    });
+    selectModel.value = selectOption?.value;
+  });
+  watch(selectModel, () => {
+    if (selectModel.value !== model.value) {
+      model.value = selectModel.value;
+    }
+  });
+  watch(model, (newModelValue) => {
+    selectModel.value = newModelValue;
+  });
+  return {
+    model: selectModel,
+    options
+  };
+};

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

@@ -0,0 +1,2 @@
+import type Cwa from '#cwa/runtime/cwa';
+export declare const useCwa: () => Cwa;

package/dist/runtime/composables/cwa.js

@@ -0,0 +1,2 @@
+import { useNuxtApp } from "#imports";
+export const useCwa = () => useNuxtApp().$cwa;

package/dist/runtime/composables/forgot-password.d.ts

@@ -0,0 +1,9 @@
+export declare const useForgotPassword: () => {
+    doSubmit: () => Promise<void>;
+    credentials: {
+        username: string;
+    };
+    error: import("vue").Ref<string | undefined, string | undefined>;
+    submitting: import("vue").Ref<boolean, boolean>;
+    success: import("vue").Ref<boolean, boolean>;
+};

package/dist/runtime/composables/forgot-password.js

@@ -0,0 +1,45 @@
+import { reactive, ref } from "vue";
+import { FetchError } from "ofetch";
+import { navigateTo } from "#app";
+import { useCwa } from "#cwa/runtime/composables/cwa";
+export const useForgotPassword = () => {
+  const $cwa = useCwa();
+  const credentials = reactive({
+    username: ""
+  });
+  const error = ref();
+  const submitting = ref(false);
+  const success = ref(false);
+  function handleResetError(fetchError) {
+    if (fetchError.status === 404) {
+      error.value = "Username not found";
+    } else {
+      error.value = fetchError.data?.message || fetchError.statusMessage || "Unexpected error";
+    }
+  }
+  async function doSubmit() {
+    if (success.value) {
+      navigateTo("/login");
+    }
+    if (!credentials.username) {
+      error.value = "Please enter a username";
+      return;
+    }
+    submitting.value = true;
+    error.value = void 0;
+    const response = await $cwa.auth.forgotPassword(credentials.username);
+    if (response instanceof FetchError) {
+      handleResetError(response);
+    } else {
+      success.value = true;
+    }
+    submitting.value = false;
+  }
+  return {
+    doSubmit,
+    credentials,
+    error,
+    submitting,
+    success
+  };
+};

package/dist/runtime/composables/login.d.ts

@@ -0,0 +1,9 @@
+export declare const useLogin: () => {
+    credentials: {
+        username: string;
+        password: string;
+    };
+    error: import("vue").Ref<any, any>;
+    submitting: import("vue").Ref<boolean, boolean>;
+    signIn: () => Promise<void>;
+};

package/dist/runtime/composables/login.js

@@ -0,0 +1,30 @@
+import { reactive, ref } from "vue";
+import { FetchError } from "ofetch";
+import { navigateTo } from "#app";
+import { useCwa } from "#cwa/runtime/composables/cwa";
+export const useLogin = () => {
+  const $cwa = useCwa();
+  const credentials = reactive({
+    username: "",
+    password: ""
+  });
+  const error = ref();
+  const submitting = ref(false);
+  async function signIn() {
+    submitting.value = true;
+    error.value = void 0;
+    const user = await $cwa.auth.signIn(credentials);
+    if (user instanceof FetchError) {
+      error.value = user.data?.message || user.statusMessage || "Unknown/Network Error";
+    } else {
+      navigateTo("/");
+    }
+    submitting.value = false;
+  }
+  return {
+    credentials,
+    error,
+    submitting,
+    signIn
+  };
+};