@mouseless/baked 0.19.0

package/dist/runtime/components/PageTitle.vue.d.ts

@@ -0,0 +1,22 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_base: import("vue").DefineComponent<{}, {
+    $props: Partial<typeof __VLS_props>;
+    schema: any;
+    data: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    actions?: ((props: {}) => any) | undefined;
+} & {
+    actions?: ((props: {}) => any) | undefined;
+} & {
+    extra?: ((props: {}) => any) | undefined;
+};
+declare const __VLS_props: {
+    readonly schema: any;
+    readonly data: any;
+};

package/dist/runtime/components/Parameters.d.vue.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $emit: typeof emit;
+    $props: Partial<typeof __VLS_props>;
+    parameters: unknown[];
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const emit: (event: "ready" | "changed", ...args: any[]) => void;
+declare const __VLS_props: {
+    readonly parameters: unknown[];
+};

package/dist/runtime/components/Parameters.vue

@@ -0,0 +1,60 @@
+<template>
+  <!--
+    [!NOTE]
+
+    unlike the usual way to pass model, `.model` is not enough here in below.
+    for some reason vue rewraps the model which is already a ref, causing a
+    double ref. that's why `.model.value` is passed instead of `.model`
+  -->
+  <div class="flex gap-2 max-md:flex-col max-md:min-w-24">
+    <Bake
+      v-for="parameter in parameters"
+      :key="parameter.name"
+      v-model="values[parameter.name].value"
+      :name="`parameters/${parameter.name}`"
+      :descriptor="parameter.component"
+      class="max-md:w-full"
+    />
+  </div>
+</template>
+
+<script setup>
+import { onMounted, ref, watch } from "vue";
+import { Bake } from "#components";
+import { useContext, useDataFetcher } from "#imports";
+const dataFetcher = useDataFetcher();
+const context = useContext();
+const { parameters } = defineProps({
+  parameters: { type: Array, required: true }
+});
+const emit = defineEmits(["ready", "changed"]);
+const injectedData = context.injectData();
+const values = {};
+for (const parameter of parameters) {
+  values[parameter.name] = ref(dataFetcher.get({ data: parameter.default, injectedData }));
+}
+onMounted(async () => {
+  for (const parameter of parameters) {
+    if (!dataFetcher.shouldLoad(parameter.default?.type)) {
+      continue;
+    }
+    values[parameter.name].value = await dataFetcher.fetch({ data: parameter.default, injectedData });
+  }
+});
+watch(Object.values(values), async () => {
+  emitChanged();
+  emitReady();
+}, { immediate: true });
+function emitReady() {
+  emit(
+    "ready",
+    parameters.filter((p) => p.required).reduce((result, p) => result && values[p.name].value?.length > 0, true)
+  );
+}
+function emitChanged() {
+  emit("changed", {
+    uniqueKey: Object.values(values).map((v) => v.value).filter((v) => v?.length > 0).join("-"),
+    values
+  });
+}
+</script>

package/dist/runtime/components/Parameters.vue.d.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $emit: typeof emit;
+    $props: Partial<typeof __VLS_props>;
+    parameters: unknown[];
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const emit: (event: "ready" | "changed", ...args: any[]) => void;
+declare const __VLS_props: {
+    readonly parameters: unknown[];
+};

package/dist/runtime/components/PersistentPopover.d.vue.ts

@@ -0,0 +1,46 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fixed: BooleanConstructor;
+}>, {}, {
+    visible: boolean;
+}, {}, {
+    toggle(event: any, target: any): void;
+    show(event: any, target: any): void;
+    hide(): void;
+    onContentClick(): void;
+    onEnter(el: any): void;
+    onLeave(): void;
+    onAfterLeave(el: any): void;
+    alignOverlay(): void;
+    fixPopoverPosition(container: any, target: any): void;
+    onContentKeydown(event: any): void;
+    onButtonKeydown(event: any): void;
+    focus(): void;
+    onKeyDown(event: any): void;
+    bindDocumentKeyDownListener(): void;
+    unbindDocumentKeyDownListener(): void;
+    bindOutsideClickListener(): void;
+    unbindOutsideClickListener(): void;
+    bindScrollListener(): void;
+    unbindScrollListener(): void;
+    bindResizeListener(): void;
+    unbindResizeListener(): void;
+    isTargetClicked(event: any): any;
+    containerRef(el: any): void;
+    createStyle(): void;
+    destroyStyle(): void;
+    onOverlayClick(event: any): void;
+}, import("vue").ComponentOptionsMixin, any, ("show" | "hide")[], "show" | "hide", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fixed: BooleanConstructor;
+}>> & Readonly<{
+    onShow?: ((...args: any[]) => any) | undefined;
+    onHide?: ((...args: any[]) => any) | undefined;
+}>, {
+    fixed: boolean;
+}, {}, {
+    Portal: import("@primevue/core").DefineComponent<import("primevue").PortalProps, import("primevue").PortalSlots, (e: string, ...args: any[]) => void>;
+}, {
+    focustrap: import("vue").ObjectDirective<any, any, string, any>;
+    ripple: import("vue").ObjectDirective<any, any, string, any>;
+}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/PersistentPopover.vue

@@ -0,0 +1,335 @@
+<template>
+  <Portal :append-to="appendTo">
+    <transition
+      name="p-popover"
+      v-bind="ptm('transition')"
+      @enter="onEnter"
+      @leave="onLeave"
+      @after-leave="onAfterLeave"
+    >
+      <div
+        v-show="visible"
+        :ref="containerRef"
+        v-focustrap
+        role="dialog"
+        :aria-modal="visible"
+        :class="cx('root')"
+        v-bind="ptmi('root')"
+        @click="onOverlayClick"
+      >
+        <slot
+          v-if="$slots.container"
+          name="container"
+          :close-callback="hide"
+          :keydown-callback="(event) => onButtonKeydown(event)"
+        />
+        <template v-else>
+          <div
+            :class="cx('content')"
+            v-bind="ptm('content')"
+            @click="onContentClick"
+            @mousedown="onContentClick"
+            @keydown="onContentKeydown"
+          >
+            <slot />
+          </div>
+        </template>
+      </div>
+    </transition>
+  </Portal>
+</template>
+
+<script>
+import { $dt } from "@primeuix/styled";
+import { absolutePosition, addClass, addStyle, focus, getOffset, isClient, isTouchDevice, setAttribute } from "@primeuix/utils/dom";
+import { ZIndex } from "@primeuix/utils/zindex";
+import { ConnectedOverlayScrollHandler } from "@primevue/core/utils";
+import FocusTrap from "primevue/focustrap";
+import OverlayEventBus from "primevue/overlayeventbus";
+import Portal from "primevue/portal";
+import Ripple from "primevue/ripple";
+import { BasePersistentPopover } from "#components";
+export default {
+  name: "PersistentPopover",
+  directives: {
+    focustrap: FocusTrap,
+    ripple: Ripple
+  },
+  components: {
+    Portal
+  },
+  extends: BasePersistentPopover,
+  inheritAttrs: false,
+  props: {
+    fixed: Boolean
+  },
+  emits: ["show", "hide"],
+  data() {
+    return {
+      visible: false
+    };
+  },
+  watch: {
+    dismissable: {
+      immediate: true,
+      handler(newValue) {
+        if (newValue) {
+          this.bindOutsideClickListener();
+        } else {
+          this.unbindOutsideClickListener();
+        }
+      }
+    }
+  },
+  selfClick: false,
+  target: null,
+  eventTarget: null,
+  outsideClickListener: null,
+  scrollHandler: null,
+  resizeListener: null,
+  container: null,
+  styleElement: null,
+  overlayEventListener: null,
+  documentKeydownListener: null,
+  beforeUnmount() {
+    if (this.dismissable) {
+      this.unbindOutsideClickListener();
+    }
+    if (this.scrollHandler) {
+      this.scrollHandler.destroy();
+      this.scrollHandler = null;
+    }
+    this.destroyStyle();
+    this.unbindResizeListener();
+    this.target = null;
+    if (this.container && this.autoZIndex) {
+      ZIndex.clear(this.container);
+    }
+    if (this.overlayEventListener) {
+      OverlayEventBus.off("overlay-click", this.overlayEventListener);
+      this.overlayEventListener = null;
+    }
+    this.container = null;
+  },
+  mounted() {
+    if (this.breakpoints) {
+      this.createStyle();
+    }
+  },
+  methods: {
+    toggle(event, target) {
+      if (this.visible) this.hide();
+      else this.show(event, target);
+    },
+    show(event, target) {
+      this.visible = true;
+      this.eventTarget = event.currentTarget;
+      this.target = target || event.currentTarget;
+    },
+    hide() {
+      this.visible = false;
+    },
+    onContentClick() {
+      this.selfClick = true;
+    },
+    onEnter(el) {
+      addStyle(el, { position: "absolute", top: "0" });
+      this.alignOverlay();
+      if (this.dismissable) {
+        this.bindOutsideClickListener();
+      }
+      this.bindScrollListener();
+      this.bindResizeListener();
+      if (this.autoZIndex) {
+        ZIndex.set("overlay", el, this.baseZIndex + this.$primevue.config.zIndex.overlay);
+      }
+      this.overlayEventListener = (e) => {
+        if (this.container.contains(e.target)) {
+          this.selfClick = true;
+        }
+      };
+      this.focus();
+      OverlayEventBus.on("overlay-click", this.overlayEventListener);
+      this.$emit("show");
+      if (this.closeOnEscape) {
+        this.bindDocumentKeyDownListener();
+      }
+    },
+    onLeave() {
+      this.unbindOutsideClickListener();
+      this.unbindScrollListener();
+      this.unbindResizeListener();
+      this.unbindDocumentKeyDownListener();
+      OverlayEventBus.off("overlay-click", this.overlayEventListener);
+      this.overlayEventListener = null;
+      this.$emit("hide");
+    },
+    onAfterLeave(el) {
+      if (this.autoZIndex) {
+        ZIndex.clear(el);
+      }
+    },
+    alignOverlay() {
+      absolutePosition(this.container, this.target, false);
+      if (this.fixed) {
+        this.fixPopoverPosition(this.container, this.target);
+      }
+      const containerOffset = getOffset(this.container);
+      const targetOffset = getOffset(this.target);
+      let arrowLeft = 0;
+      if (containerOffset.left < targetOffset.left) {
+        arrowLeft = targetOffset.left - containerOffset.left;
+      }
+      this.container.style.setProperty($dt("popover.arrow.left").name, `${arrowLeft}px`);
+      if (containerOffset.top < targetOffset.top) {
+        this.container.setAttribute("data-p-popover-flipped", "true");
+        !this.isUnstyled && addClass(this.container, "p-popover-flipped");
+      }
+    },
+    fixPopoverPosition(container, target) {
+      const rect = target.getBoundingClientRect();
+      const vw = window.innerWidth, vh = window.innerHeight;
+      const w = container.offsetWidth, h = container.offsetHeight;
+      let top = rect.bottom;
+      let left = rect.left;
+      if (rect.bottom + h > vh) {
+        top = Math.max(0, rect.top - h);
+      }
+      if (rect.left + w > vw) {
+        left = Math.max(0, rect.right - w);
+      }
+      Object.assign(container.style, {
+        position: "fixed",
+        top: `${top}px`,
+        left: `${left}px`
+      });
+    },
+    onContentKeydown(event) {
+      if (event.code === "Escape" && this.closeOnEscape) {
+        this.hide();
+        focus(this.target);
+      }
+    },
+    onButtonKeydown(event) {
+      switch (event.code) {
+        case "ArrowDown":
+        case "ArrowUp":
+        case "ArrowLeft":
+        case "ArrowRight":
+          event.preventDefault();
+        default:
+          break;
+      }
+    },
+    focus() {
+      const focusTarget = this.container.querySelector("[autofocus]");
+      if (focusTarget) {
+        focusTarget.focus();
+      }
+    },
+    onKeyDown(event) {
+      if (event.code === "Escape" && this.closeOnEscape) {
+        this.visible = false;
+      }
+    },
+    bindDocumentKeyDownListener() {
+      if (!this.documentKeydownListener) {
+        this.documentKeydownListener = this.onKeyDown.bind(this);
+        window.document.addEventListener("keydown", this.documentKeydownListener);
+      }
+    },
+    unbindDocumentKeyDownListener() {
+      if (this.documentKeydownListener) {
+        window.document.removeEventListener("keydown", this.documentKeydownListener);
+        this.documentKeydownListener = null;
+      }
+    },
+    bindOutsideClickListener() {
+      if (!this.outsideClickListener && isClient()) {
+        this.outsideClickListener = (event) => {
+          if (this.visible && !this.selfClick && !this.isTargetClicked(event)) {
+            this.visible = false;
+          }
+          this.selfClick = false;
+        };
+        document.addEventListener("click", this.outsideClickListener);
+      }
+    },
+    unbindOutsideClickListener() {
+      if (this.outsideClickListener) {
+        document.removeEventListener("click", this.outsideClickListener);
+        this.outsideClickListener = null;
+        this.selfClick = false;
+      }
+    },
+    bindScrollListener() {
+      if (!this.scrollHandler) {
+        this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, () => {
+          if (this.visible) {
+            this.visible = false;
+          }
+        });
+      }
+      this.scrollHandler.bindScrollListener();
+    },
+    unbindScrollListener() {
+      if (this.scrollHandler) {
+        this.scrollHandler.unbindScrollListener();
+      }
+    },
+    bindResizeListener() {
+      if (!this.resizeListener) {
+        this.resizeListener = () => {
+          if (this.visible && !isTouchDevice()) {
+            this.visible = false;
+          }
+        };
+        window.addEventListener("resize", this.resizeListener);
+      }
+    },
+    unbindResizeListener() {
+      if (this.resizeListener) {
+        window.removeEventListener("resize", this.resizeListener);
+        this.resizeListener = null;
+      }
+    },
+    isTargetClicked(event) {
+      return this.eventTarget && (this.eventTarget === event.target || this.eventTarget.contains(event.target));
+    },
+    containerRef(el) {
+      this.container = el;
+    },
+    createStyle() {
+      if (!this.styleElement && !this.isUnstyled) {
+        this.styleElement = document.createElement("style");
+        this.styleElement.type = "text/css";
+        setAttribute(this.styleElement, "nonce", this.$primevue?.config?.csp?.nonce);
+        document.head.appendChild(this.styleElement);
+        let innerHTML = "";
+        for (const breakpoint in this.breakpoints) {
+          innerHTML += `
+            @media screen and (max-width: ${breakpoint}) {
+              .p-popover[${this.$attrSelector}] {
+                width: ${this.breakpoints[breakpoint]} !important;
+              }
+            }
+          `;
+        }
+        this.styleElement.innerHTML = innerHTML;
+      }
+    },
+    destroyStyle() {
+      if (this.styleElement) {
+        document.head.removeChild(this.styleElement);
+        this.styleElement = null;
+      }
+    },
+    onOverlayClick(event) {
+      OverlayEventBus.emit("overlay-click", {
+        originalEvent: event,
+        target: this.target
+      });
+    }
+  }
+};
+</script>

package/dist/runtime/components/PersistentPopover.vue.d.ts

@@ -0,0 +1,46 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fixed: BooleanConstructor;
+}>, {}, {
+    visible: boolean;
+}, {}, {
+    toggle(event: any, target: any): void;
+    show(event: any, target: any): void;
+    hide(): void;
+    onContentClick(): void;
+    onEnter(el: any): void;
+    onLeave(): void;
+    onAfterLeave(el: any): void;
+    alignOverlay(): void;
+    fixPopoverPosition(container: any, target: any): void;
+    onContentKeydown(event: any): void;
+    onButtonKeydown(event: any): void;
+    focus(): void;
+    onKeyDown(event: any): void;
+    bindDocumentKeyDownListener(): void;
+    unbindDocumentKeyDownListener(): void;
+    bindOutsideClickListener(): void;
+    unbindOutsideClickListener(): void;
+    bindScrollListener(): void;
+    unbindScrollListener(): void;
+    bindResizeListener(): void;
+    unbindResizeListener(): void;
+    isTargetClicked(event: any): any;
+    containerRef(el: any): void;
+    createStyle(): void;
+    destroyStyle(): void;
+    onOverlayClick(event: any): void;
+}, import("vue").ComponentOptionsMixin, any, ("show" | "hide")[], "show" | "hide", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fixed: BooleanConstructor;
+}>> & Readonly<{
+    onShow?: ((...args: any[]) => any) | undefined;
+    onHide?: ((...args: any[]) => any) | undefined;
+}>, {
+    fixed: boolean;
+}, {}, {
+    Portal: import("@primevue/core").DefineComponent<import("primevue").PortalProps, import("primevue").PortalSlots, (e: string, ...args: any[]) => void>;
+}, {
+    focustrap: import("vue").ObjectDirective<any, any, string, any>;
+    ripple: import("vue").ObjectDirective<any, any, string, any>;
+}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/QueryParameters.d.vue.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $emit: typeof emit;
+    $props: Partial<typeof __VLS_props>;
+    parameters: unknown[];
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const emit: (event: "ready" | "changed", ...args: any[]) => void;
+declare const __VLS_props: {
+    readonly parameters: unknown[];
+};

package/dist/runtime/components/QueryParameters.vue

@@ -0,0 +1,103 @@
+<template>
+  <!--
+    [!NOTE]
+
+    unlike usual model passing, `.model` is not enough here in below. for
+    some reason vue rewraps the model which is already a ref, causing a
+    double ref. that's why `.model.value` is passed instead of `.model`
+  -->
+  <Bake
+    v-for="parameter in parameters"
+    :key="parameter.name"
+    v-model="values[parameter.name].model.value"
+    :name="`query-parameters/${parameter.name}`"
+    :descriptor="parameter.component"
+  />
+</template>
+
+<script setup>
+import { computed, ref, onMounted, watch, watchEffect } from "vue";
+import { useRoute, useRouter } from "#app";
+import { Bake } from "#components";
+import { useContext, useDataFetcher } from "#imports";
+const route = useRoute();
+const router = useRouter();
+const dataFetcher = useDataFetcher();
+const context = useContext();
+const { parameters } = defineProps({
+  parameters: { type: Array, required: true }
+});
+const emit = defineEmits(["ready", "changed"]);
+const injectedData = context.injectData();
+const values = {};
+for (const parameter of parameters) {
+  const query = computed(() => route.query[parameter.name]);
+  const model = ref(query.value);
+  values[parameter.name] = { query, model };
+}
+onMounted(async () => await setDefaults());
+watchEffect(() => {
+  const queryValues = Object.values(values).map((p) => p.query.value);
+  const isReady = parameters.filter((p) => p.required).every((p) => values[p.name].query.value?.length > 0);
+  const uniqueKey = queryValues.filter((v) => v?.length > 0).join("-");
+  emit("ready", isReady);
+  emit("changed", uniqueKey);
+});
+watch(
+  Object.values(values).map((p) => p.query),
+  async (newValues, oldValues) => {
+    if (JSON.stringify(newValues) === JSON.stringify(oldValues)) {
+      return;
+    }
+    await setDefaults();
+    parameters.forEach((param, i) => {
+      if (!values[param.name]) {
+        return;
+      }
+      values[param.name].model.value = newValues[i] || void 0;
+    });
+  },
+  { deep: true }
+);
+watch(
+  Object.values(values).map((p) => p.model),
+  async (newValues, oldValues) => {
+    if (JSON.stringify(newValues) === JSON.stringify(oldValues)) {
+      return;
+    }
+    const shouldReplace = parameters.filter((p) => p.required && (p.default || p.defaultSelfManaged)).some((p) => !values[p.name].query.value);
+    const query = parameters.reduce((result, param, i) => {
+      const value = newValues[i];
+      if (value) {
+        result[param.name] = value;
+      }
+      return result;
+    }, {});
+    await router[shouldReplace ? "replace" : "push"]({
+      path: route.path,
+      query
+    });
+  },
+  { deep: true }
+);
+async function setDefaults() {
+  const query = {};
+  for (const p of parameters) {
+    const currentValue = values[p.name].query.value;
+    if (currentValue || p.default) {
+      if (!currentValue && p.default) {
+        query[p.name] = await dataFetcher.fetch({ data: p.default, injectedData });
+      } else {
+        query[p.name] = currentValue;
+      }
+    }
+    if (query[p.name] === null || query[p.name] === "") {
+      query[p.name] = void 0;
+    }
+  }
+  await router.replace({
+    path: route.path,
+    query
+  });
+}
+</script>

package/dist/runtime/components/QueryParameters.vue.d.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $emit: typeof emit;
+    $props: Partial<typeof __VLS_props>;
+    parameters: unknown[];
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const emit: (event: "ready" | "changed", ...args: any[]) => void;
+declare const __VLS_props: {
+    readonly parameters: unknown[];
+};

package/dist/runtime/components/Rate.d.vue.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $props: Partial<typeof __VLS_props>;
+    schema: any;
+    data: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_props: {
+    readonly schema: any;
+    readonly data: any;
+};