@mouseless/baked 0.19.0

package/README.md

@@ -0,0 +1,11 @@
+![](https://raw.githubusercontent.com/mouseless/baked/main/docs/.theme/public/logo-readme.png)
+
+Baked is an opinionated framework for .NET and Vue.
+
+It proposes well designed conventions to help you express your application
+logic with ease. It doesn't reinvent libraries that already exists, but brings
+them together with built-in configurations.
+
+Check out our documentation site for more information: [baked.mouseless.codes][]
+
+[baked.mouseless.codes]: https://baked.mouseless.codes

package/dist/module.d.mts

@@ -0,0 +1,45 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { NuxtI18nOptions } from '@nuxtjs/i18n';
+
+interface ModuleOptions {
+    components?: Components;
+    composables: Composables;
+    primevue: PrimeVueOptions;
+    i18n: NuxtI18nOptions;
+}
+interface Components {
+    Page?: PageOptions;
+}
+interface PageOptions {
+    title?: String;
+}
+interface PrimeVueOptions {
+    theme: any;
+    locale?: any;
+}
+interface Composables {
+    useBreakpoints?: UseBreakpointsOptions;
+    useDataFetcher: UseDataFetcherOptions;
+    useFormat?: UseFormatOptions;
+}
+interface UseDataFetcherOptions {
+    baseURL: String;
+    retry?: RetryOptions | Boolean;
+}
+interface RetryOptions {
+    maxRetry?: Number;
+    delay?: Number;
+}
+interface UseFormatOptions {
+    currency?: String;
+}
+interface UseBreakpointsOptions {
+    screens?: ScreenOptions;
+}
+interface ScreenOptions {
+    [key: string]: string;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { Components, Composables, ModuleOptions, PageOptions, PrimeVueOptions, RetryOptions, ScreenOptions, UseBreakpointsOptions, UseDataFetcherOptions, UseFormatOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@mouseless/baked",
+  "configKey": "baked",
+  "version": "0.19.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,110 @@
+import { createResolver, defineNuxtModule, addComponentsDir, addImportsDir, addPlugin } from '@nuxt/kit';
+import { pathToFileURL } from 'url';
+
+const resolver = createResolver(import.meta.url);
+const module = defineNuxtModule({
+  meta: {
+    name: "@mouseless/baked",
+    configKey: "baked"
+  },
+  defaults: {},
+  moduleDependencies: {
+    "@nuxtjs/i18n": {
+      version: "10.1.1",
+      defaults: {
+        strategy: "no_prefix",
+        detectBrowserLanguage: {
+          useCookie: true,
+          cookieKey: "i18n_cookie"
+        }
+      }
+    },
+    "@nuxtjs/tailwindcss": {
+      version: "6.14.0",
+      defaults: {
+        exposeConfig: true,
+        cssPath: resolver.resolve("./runtime/assets/tailwind.css"),
+        config: {
+          content: {
+            files: [
+              resolver.resolve("./runtime/components/**/*.{vue,mjs,ts}"),
+              resolver.resolve("./runtime/*.{mjs,js,ts}")
+            ]
+          }
+        }
+      }
+    }
+  },
+  onInstall() {
+  },
+  onUpgrade() {
+  },
+  // this setup runs after `defineNuxtConfig` so it should set default values
+  // carefully.
+  async setup(_options, _nuxt) {
+    if (process.env.npm_lifecycle_script?.includes("nuxt-module-build")) {
+      return;
+    }
+    const entryProjectResolver = createResolver(_nuxt.options.rootDir);
+    const appJsonPath = pathToFileURL(entryProjectResolver.resolve("./.baked/app.json"));
+    const app = (await import(appJsonPath.href, { with: { type: 'json' } })).default;
+    _options.composables.useBreakpoints ||= {};
+    _options.composables.useBreakpoints.screens ||= {
+      "2xs": "340px",
+      "xs": "480px",
+      "sm": "640px",
+      "md": "768px",
+      "lg": "1024px",
+      "xl": "1280px",
+      "2xl": "1536px",
+      "3xl": "1920px"
+    };
+    _nuxt.options.runtimeConfig.public.error = app?.error;
+    _nuxt.options.runtimeConfig.public.primevue = _options.primevue;
+    _nuxt.options.runtimeConfig.public.components = _options.components;
+    _nuxt.options.runtimeConfig.public.composables = _options.composables;
+    _nuxt.options.css.push("primeicons/primeicons.css");
+    _nuxt.options.css.push(resolver.resolve("./runtime/assets/overrides.css"));
+    _nuxt.options.devtools = { enabled: false };
+    _nuxt.options.experimental.payloadExtraction = false;
+    _nuxt.options.features.inlineStyles = false;
+    _nuxt.options.ssr = false;
+    addComponentsDir({ path: resolver.resolve("./runtime/components") });
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    for (const plugin of app?.plugins ?? []) {
+      _nuxt.options.runtimeConfig.public[plugin.name] = plugin;
+      addPlugin(resolver.resolve(`./runtime/plugins/${plugin.name}`));
+    }
+    addPlugin(resolver.resolve("./runtime/plugins/mutex"));
+    addPlugin(resolver.resolve("./runtime/plugins/toast"));
+    addPlugin(resolver.resolve("./runtime/plugins/trailingSlash"));
+    addPlugin(resolver.resolve("./runtime/plugins/baked"));
+    addPlugin(resolver.resolve("./runtime/plugins/primeVue"));
+    addPlugin(resolver.resolve("./runtime/plugins/fetch"), {});
+    _nuxt.options.i18n = {
+      vueI18n: entryProjectResolver.resolve("./i18n.config.ts"),
+      langDir: entryProjectResolver.resolve("./"),
+      locales: app?.i18n?.supportedLanguages?.map((i) => {
+        const files = [
+          entryProjectResolver.resolve(`./.baked/locale.${i.code}.json`),
+          entryProjectResolver.resolve(`./locales/locale.${i.code}.json`)
+        ];
+        return {
+          code: i.code,
+          name: i.name,
+          files
+        };
+      }),
+      defaultLocale: app?.i18n?.defaultLanguage?.code
+    };
+    _nuxt.options.tailwindcss = {
+      config: {
+        theme: {
+          screens: _options.composables.useBreakpoints.screens
+        }
+      }
+    };
+  }
+});
+
+export { module as default };

package/dist/runtime/assets/overrides.css

@@ -0,0 +1 @@
+html{@apply max-xs:text-[smaller]}.bg-body{background-color:#fff}.p-datatable-tbody td.p-datatable-frozen-column{background:inherit}.p-popover-content>div{@apply max-sm:p-0}@media (prefers-color-scheme:dark){.bg-body{background-color:#121212}}

package/dist/runtime/assets/tailwind.css

@@ -0,0 +1 @@
+@layer tailwind-base{@tailwind base}@layer tailwind-utilities{@tailwind components;@tailwind utilities;@tailwind variants}

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

@@ -0,0 +1,10 @@
+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<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};

package/dist/runtime/components/AuthorizedContent.vue

@@ -0,0 +1,14 @@
+<template>
+  <slot v-if="authorized" />
+</template>
+
+<script setup>
+import { onMounted, ref } from "vue";
+import { useToken } from "#imports";
+const token = useToken();
+const authorized = ref(false);
+onMounted(async () => {
+  const result = await token.current(false);
+  authorized.value = result !== null;
+});
+</script>

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

@@ -0,0 +1,10 @@
+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<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};

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

@@ -0,0 +1,20 @@
+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<{}, {
+    $emit: typeof emit;
+    $props: Partial<typeof __VLS_props>;
+    name: string;
+    descriptor: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};
+declare const emit: (event: "loaded", ...args: any[]) => void;
+declare const __VLS_props: {
+    readonly name: string;
+    readonly descriptor: any;
+};

package/dist/runtime/components/Bake.vue

@@ -0,0 +1,50 @@
+<template>
+  <component
+    :is="is"
+    :key="loading"
+    v-model="model"
+    :schema="descriptor.schema"
+    :data
+    :class="classes"
+  >
+    <slot v-if="$slots.default" />
+  </component>
+</template>
+
+<script setup>
+import { onMounted, ref } from "vue";
+import { useComponentResolver, useContext, useDataFetcher, useFormat } from "#imports";
+const componentResolver = useComponentResolver();
+const context = useContext();
+const dataFetcher = useDataFetcher();
+const { asClasses } = useFormat();
+const { name, descriptor } = defineProps({
+  name: { type: String, required: true },
+  descriptor: { type: null, required: true }
+});
+const model = defineModel({ type: null });
+const emit = defineEmits(["loaded"]);
+context.providePath(name);
+context.provideDataDescriptor(descriptor.data);
+const is = componentResolver.resolve(descriptor.type, "None");
+const injectedData = context.injectData();
+const data = ref(dataFetcher.get({ data: descriptor.data, injectedData }));
+const shouldLoad = dataFetcher.shouldLoad(descriptor.data?.type);
+const loading = ref(shouldLoad);
+const classes = [`b-component--${descriptor.type}`, ...asClasses(name)];
+context.provideData(data, "ParentData");
+if (shouldLoad) {
+  context.provideLoading(loading);
+}
+onMounted(async () => {
+  if (!shouldLoad) {
+    return;
+  }
+  data.value = await dataFetcher.fetch({
+    data: descriptor.data,
+    injectedData
+  });
+  loading.value = false;
+  emit("loaded");
+});
+</script>

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

@@ -0,0 +1,20 @@
+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<{}, {
+    $emit: typeof emit;
+    $props: Partial<typeof __VLS_props>;
+    name: string;
+    descriptor: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};
+declare const emit: (event: "loaded", ...args: any[]) => void;
+declare const __VLS_props: {
+    readonly name: string;
+    readonly descriptor: any;
+};

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

@@ -0,0 +1,178 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    appendTo: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: string;
+    };
+    baseZIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    autoZIndex: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    breakpoints: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, typeof BaseComponent, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    appendTo: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: string;
+    };
+    baseZIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    autoZIndex: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    breakpoints: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    dismissable: boolean;
+    appendTo: string | Record<string, any>;
+    baseZIndex: number;
+    autoZIndex: boolean;
+    breakpoints: Record<string, any>;
+    closeOnEscape: boolean;
+}, {}, {}, {}, string, () => {
+    $pcPopover: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        dismissable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        appendTo: {
+            type: (StringConstructor | ObjectConstructor)[];
+            default: string;
+        };
+        baseZIndex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        autoZIndex: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        breakpoints: {
+            type: ObjectConstructor;
+            default: null;
+        };
+        closeOnEscape: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, typeof BaseComponent, {}, {}, {}, false, {}, {}, {}, {}, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        dismissable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        appendTo: {
+            type: (StringConstructor | ObjectConstructor)[];
+            default: string;
+        };
+        baseZIndex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        autoZIndex: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        breakpoints: {
+            type: ObjectConstructor;
+            default: null;
+        };
+        closeOnEscape: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    $parentInstance: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        dismissable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        appendTo: {
+            type: (StringConstructor | ObjectConstructor)[];
+            default: string;
+        };
+        baseZIndex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        autoZIndex: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        breakpoints: {
+            type: ObjectConstructor;
+            default: null;
+        };
+        closeOnEscape: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, typeof BaseComponent, {}, {}, {}, false, {}, {}, {}, {}, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        dismissable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        appendTo: {
+            type: (StringConstructor | ObjectConstructor)[];
+            default: string;
+        };
+        baseZIndex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        autoZIndex: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        breakpoints: {
+            type: ObjectConstructor;
+            default: null;
+        };
+        closeOnEscape: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {}>;
+}, true, {}, any>;
+import BaseComponent from "@primevue/core/basecomponent";

package/dist/runtime/components/BasePersistentPopover.vue

@@ -0,0 +1,41 @@
+<script>
+import BaseComponent from "@primevue/core/basecomponent";
+import PopoverStyle from "primevue/popover/style";
+export default {
+  name: "BasePopover",
+  extends: BaseComponent,
+  provide() {
+    return {
+      $pcPopover: this,
+      $parentInstance: this
+    };
+  },
+  props: {
+    dismissable: {
+      type: Boolean,
+      default: true
+    },
+    appendTo: {
+      type: [String, Object],
+      default: "body"
+    },
+    baseZIndex: {
+      type: Number,
+      default: 0
+    },
+    autoZIndex: {
+      type: Boolean,
+      default: true
+    },
+    breakpoints: {
+      type: Object,
+      default: null
+    },
+    closeOnEscape: {
+      type: Boolean,
+      default: true
+    }
+  },
+  style: PopoverStyle
+};
+</script>