@mouseless/baked 1.0.2 → 1.1.0

package/dist/module.d.mts

@@ -2,6 +2,7 @@ import * as _nuxt_schema from '@nuxt/schema';
 import { NuxtI18nOptions } from '@nuxtjs/i18n';
 
 interface ModuleOptions {
+    apiBaseURL: String;
     components?: Components;
     composables: Composables;
     primevue: PrimeVueOptions;
@@ -23,7 +24,6 @@ interface Composables {
     useFormat?: UseFormatOptions;
 }
 interface UseDataFetcherOptions {
-    baseURL: String;
     retry?: RetryOptions | Boolean;
 }
 interface RetryOptions {

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@mouseless/baked",
   "configKey": "baked",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,8 +1,9 @@
 import { createResolver, defineNuxtModule, addComponentsDir, addImportsDir, addPlugin } from '@nuxt/kit';
 import { pathToFileURL } from 'url';
+import { join } from 'path';
 
-const resolver = createResolver(import.meta.url);
-const module = defineNuxtModule({
+const metaUrlResolver = createResolver(import.meta.url);
+const module$1 = defineNuxtModule({
   meta: {
     name: "@mouseless/baked",
     configKey: "baked"
@@ -10,7 +11,7 @@ const module = defineNuxtModule({
   defaults: {},
   moduleDependencies: {
     "@nuxtjs/i18n": {
-      version: "10.1.1",
+      version: "10.2.1",
       defaults: {
         strategy: "no_prefix",
         detectBrowserLanguage: {
@@ -23,12 +24,12 @@ const module = defineNuxtModule({
       version: "6.14.0",
       defaults: {
         exposeConfig: true,
-        cssPath: resolver.resolve("./runtime/assets/tailwind.css"),
+        cssPath: metaUrlResolver.resolve("./runtime/assets/tailwind.css"),
         config: {
           content: {
             files: [
-              resolver.resolve("./runtime/components/**/*.{vue,mjs,ts}"),
-              resolver.resolve("./runtime/*.{mjs,js,ts}")
+              metaUrlResolver.resolve("./runtime/components/**/*.{vue,mjs,ts}"),
+              metaUrlResolver.resolve("./runtime/*.{mjs,js,ts}")
             ]
           }
         }
@@ -45,8 +46,11 @@ const module = defineNuxtModule({
     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 resolver = {
+      metaUrl: metaUrlResolver,
+      rootDir: createResolver(_nuxt.options.rootDir)
+    };
+    const appJsonPath = pathToFileURL(resolver.rootDir.resolve("./.baked/app.json"));
     const app = (await import(appJsonPath.href, { with: { type: 'json' } })).default;
     _options.composables.useBreakpoints ||= {};
     _options.composables.useBreakpoints.screens ||= {
@@ -63,33 +67,34 @@ const module = defineNuxtModule({
     _nuxt.options.runtimeConfig.public.primevue = _options.primevue;
     _nuxt.options.runtimeConfig.public.components = _options.components;
     _nuxt.options.runtimeConfig.public.composables = _options.composables;
+    _nuxt.options.runtimeConfig.public.apiBaseURL = _options.apiBaseURL;
     _nuxt.options.css.push("primeicons/primeicons.css");
-    _nuxt.options.css.push(resolver.resolve("./runtime/assets/overrides.css"));
+    _nuxt.options.css.push(resolver.metaUrl.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"));
+    addComponentsDir({ path: resolver.metaUrl.resolve("./runtime/components") });
+    addImportsDir(resolver.metaUrl.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[camelize(plugin.resolver ?? "MetaUrl")].resolve(join(plugin.basePath, 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"), {});
+    addPlugin(resolver.metaUrl.resolve("./runtime/plugins/mutex"));
+    addPlugin(resolver.metaUrl.resolve("./runtime/plugins/toast"));
+    addPlugin(resolver.metaUrl.resolve("./runtime/plugins/trailingSlash"));
+    addPlugin(resolver.metaUrl.resolve("./runtime/plugins/baked"));
+    addPlugin(resolver.metaUrl.resolve("./runtime/plugins/primeVue"));
+    addPlugin(resolver.metaUrl.resolve("./runtime/plugins/fetch"), {});
     _nuxt.options.vite.optimizeDeps ||= {};
     _nuxt.options.vite.optimizeDeps.noDiscovery = true;
     _nuxt.options.i18n = {
-      vueI18n: entryProjectResolver.resolve("./i18n.config.ts"),
-      langDir: entryProjectResolver.resolve("./"),
+      vueI18n: resolver.rootDir.resolve("./i18n.config.ts"),
+      langDir: resolver.rootDir.resolve("./"),
       locales: app?.i18n?.supportedLanguages?.map((i) => {
         const files = [
-          entryProjectResolver.resolve(`./.baked/locale.${i.code}.json`),
-          entryProjectResolver.resolve(`./locales/locale.${i.code}.json`)
+          resolver.rootDir.resolve(`./.baked/locale.${i.code}.json`),
+          resolver.rootDir.resolve(`./locales/locale.${i.code}.json`)
         ];
         return {
           code: i.code,
@@ -115,5 +120,11 @@ const module = defineNuxtModule({
     };
   }
 });
+function camelize(str) {
+  if (!str) {
+    return str;
+  }
+  return `${str.charAt(0).toLowerCase()}${str.slice(1)}`;
+}
 
-export { module as default };
+export { module$1 as default };

package/dist/runtime/components/AwaitLoading.d.ts

@@ -0,0 +1,14 @@
+declare namespace _default {
+    namespace props {
+        namespace skeleton {
+            export let type: ObjectConstructor;
+            export let required: boolean;
+            function _default(): void;
+            export { _default as default };
+        }
+    }
+    function setup(): (props: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | undefined;
+}
+export default _default;

package/dist/runtime/components/AwaitLoading.js

@@ -0,0 +1,27 @@
+import { h, useSlots } from "vue";
+import { Skeleton } from "primevue";
+import { useContext } from "#imports";
+
+export default {
+  props: {
+    skeleton: { type: Object, required: false, default: () => { } }
+  },
+  setup() {
+    const context = useContext();
+    const slots = useSlots();
+
+    const loading = context.injectLoading();
+
+    return props => {
+      if(loading.value) {
+        if(slots.loading) {
+          return slots.loading()[0];
+        }
+
+        return h(Skeleton, props.skeleton);
+      }
+
+      return slots.default()[0];
+    };
+  }
+};

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

@@ -4,17 +4,31 @@ 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>;
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    descriptor: {
+        type: null;
+        required: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<any>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    descriptor: {
+        type: null;
+        required: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<any>;
+    };
+}>> & 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

@@ -1,10 +1,8 @@
 <template>
   <component
-    :is="is"
+    :is="render()"
+    v-if="visible"
     :key="loading"
-    v-model="model"
-    :schema="descriptor.schema"
-    :data
     :class="classes"
   >
     <slot v-if="$slots.default" />
@@ -12,39 +10,112 @@
 </template>
 
 <script setup>
-import { onMounted, ref } from "vue";
-import { useComponentResolver, useContext, useDataFetcher, useFormat } from "#imports";
+import { h, nextTick, onBeforeUnmount, onMounted, ref } from "vue";
+import { useActionExecuter, useComponentResolver, useContext, useDataFetcher, useFormat, useReactionHandler } from "#imports";
+const actionExecuter = useActionExecuter();
 const componentResolver = useComponentResolver();
 const context = useContext();
 const dataFetcher = useDataFetcher();
 const { asClasses } = useFormat();
+const reactionHandler = useReactionHandler();
 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 parentPath = context.injectPath();
+const path = parentPath && parentPath !== "" ? `${parentPath}/${name}` : name;
+const events = context.injectEvents();
+const contextData = context.injectContextData();
+const component = componentResolver.resolve(descriptor.type, "MissingComponent");
+const componentProps = buildComponentProps();
+const data = ref(dataFetcher.get({ data: descriptor.data, contextData }));
 const shouldLoad = dataFetcher.shouldLoad(descriptor.data?.type);
 const loading = ref(shouldLoad);
+const executing = ref(false);
+const visible = ref(true);
 const classes = [`b-component--${descriptor.type}`, ...asClasses(name)];
-context.provideData(data, "ParentData");
+let reactions = null;
+context.providePath(path);
+context.provideDataDescriptor(descriptor.data);
+context.provideParentContext({ ...contextData.parent, data });
+context.provideExecuting(executing);
 if (shouldLoad) {
   context.provideLoading(loading);
 }
+if (descriptor.reactions) {
+  reactions = reactionHandler.create(`${path}:bake`, {
+    reload(success) {
+      if (!success) {
+        return;
+      }
+      load();
+    },
+    show(success) {
+      visible.value = success;
+    }
+  });
+  reactions.bind(descriptor.reactions);
+}
 onMounted(async () => {
-  if (!shouldLoad) {
-    return;
+  if (shouldLoad) {
+    await load();
   }
+});
+onBeforeUnmount(() => {
+  if (descriptor.reactions) {
+    reactions.unbind();
+  }
+});
+async function load() {
+  loading.value = true;
   data.value = await dataFetcher.fetch({
     data: descriptor.data,
-    injectedData
+    contextData
   });
   loading.value = false;
   emit("loaded");
-});
+}
+function buildComponentProps() {
+  const result = {};
+  if (descriptor.schema) {
+    result.schema = descriptor.schema;
+  }
+  if (component.emits?.includes("submit")) {
+    result.onSubmit = onModelUpdate;
+  }
+  if (component.props?.modelValue) {
+    result["onUpdate:modelValue"] = onModelUpdate;
+    nextTick(() => onModelUpdate(model.value));
+  }
+  return result;
+}
+function render() {
+  if (descriptor.data) {
+    componentProps.data = data.value;
+  }
+  if (component.props?.modelValue) {
+    componentProps.modelValue = model.value;
+  }
+  return h(component, componentProps);
+}
+async function onModelUpdate(newModel) {
+  if (component.props?.modelValue) {
+    model.value = newModel;
+  }
+  if (!descriptor.action) {
+    return;
+  }
+  try {
+    executing.value = true;
+    await actionExecuter.execute({
+      action: descriptor.action,
+      contextData: { ...contextData, model: newModel },
+      events
+    });
+  } finally {
+    executing.value = false;
+  }
+}
 </script>

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

@@ -4,17 +4,31 @@ 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>;
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    descriptor: {
+        type: null;
+        required: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<any>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    descriptor: {
+        type: null;
+        required: true;
+    };
+    modelValue: {
+        type: import("vue").PropType<any>;
+    };
+}>> & 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/Button.d.vue.ts

@@ -0,0 +1,27 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+    ready: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+    ready: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSubmit?: ((...args: any[]) => any) | undefined;
+}>, {
+    ready: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/Button.vue

@@ -0,0 +1,26 @@
+<template>
+  <Button
+    :disabled="!ready || executing"
+    :loading="executing"
+    :icon
+    :label="l(label)"
+    :rounded
+    :severity
+    :variant
+    @click="$emit('submit')"
+  />
+</template>
+
+<script setup>
+import { useContext, useLocalization } from "#imports";
+import { Button } from "primevue";
+const context = useContext();
+const { localize: l } = useLocalization();
+const { schema } = defineProps({
+  schema: { type: null, required: true },
+  ready: { type: Boolean, default: true }
+});
+defineEmits(["submit"]);
+const { icon, label, rounded, severity = "secondary", variant } = schema;
+const executing = context.injectExecuting();
+</script>

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

@@ -0,0 +1,27 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+    ready: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+    ready: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSubmit?: ((...args: any[]) => any) | undefined;
+}>, {
+    ready: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -1,11 +1,13 @@
 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;
-};
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/CardLink.vue

@@ -43,8 +43,7 @@ import { Button, Tag } from "primevue";
 import { useLocalization } from "#imports";
 const { localize: l } = useLocalization();
 const { schema } = defineProps({
-  schema: { type: null, required: true },
-  data: { type: null, default: null }
+  schema: { type: null, required: true }
 });
 const {
   route,

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

@@ -1,11 +1,13 @@
 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;
-};
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,13 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    schema: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/Composite.vue

@@ -0,0 +1,17 @@
+<template>
+  <Bake
+    v-for="(part, i) in parts"
+    v-bind="$attrs"
+    :key="`part-${i}`"
+    :name="`parts/${i}`"
+    :descriptor="part"
+  />
+</template>
+
+<script setup>
+import { Bake } from "#components";
+const { schema } = defineProps({
+  schema: { type: Object, required: true }
+});
+const { parts } = schema;
+</script>

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

@@ -0,0 +1,13 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    schema: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,23 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+    data: {
+        type: null;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    schema: {
+        type: null;
+        required: true;
+    };
+    data: {
+        type: null;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    data: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/Conditional.vue

@@ -0,0 +1,31 @@
+<template>
+  <AwaitLoading>
+    <Bake
+      v-if="data"
+      :name="`${path}/${component.type}`"
+      :descriptor="component"
+    />
+  </AwaitLoading>
+</template>
+
+<script setup>
+import { computed, useContext } from "#imports";
+import { AwaitLoading, Bake } from "#components";
+const context = useContext();
+const { data, schema } = defineProps({
+  schema: { type: null, required: true },
+  data: { type: null, default: null }
+});
+const path = context.injectPath();
+const { conditions, fallback } = schema;
+const component = computed(() => {
+  if (!conditions) {
+    return fallback;
+  }
+  const successConditions = conditions.filter((condition) => condition.prop && data[condition.prop] === condition.value);
+  if (successConditions.length <= 0) {
+    return fallback;
+  }
+  return successConditions[0].component;
+});
+</script>