@toaster-builder/site-runtime 0.1.0

package/dist/runtime/components/PageRegionRenderer.vue

@@ -0,0 +1,50 @@
+<script setup>
+import { computed } from "vue";
+import BlockEditorFrame from "#toaster-site-runtime/components/BlockEditorFrame.vue";
+import BlockPlacementProvider from "#toaster-site-runtime/components/BlockPlacementProvider.vue";
+const props = defineProps({
+  builderReady: { type: Boolean, required: true },
+  isPlacementEnabled: { type: Function, required: true },
+  pagePlacements: { type: Function, required: true },
+  placementKey: { type: Function, required: true },
+  region: { type: null, required: true },
+  resolveBlock: { type: Function, required: true },
+  resolveBlockOptions: { type: Function, required: true }
+});
+const placements = computed(() => props.pagePlacements(props.region));
+</script>
+
+<template>
+  <component :is="region">
+    <template
+      v-for="(placement, index) in placements"
+      :key="placementKey(region, placement)"
+    >
+      <DevOnly>
+        <BlockEditorFrame
+          v-if="isPlacementEnabled(placement) || builderReady"
+          :block-component="resolveBlock(placement.id)"
+          :block-id="placement.id"
+          :block-index="index"
+          :builder-ready="builderReady"
+          :enabled="isPlacementEnabled(placement)"
+          :options="resolveBlockOptions(placement)"
+          :placement-id="placement.placementId"
+          :placement-count="placements.length"
+          :region="region"
+        />
+        <template #fallback>
+          <BlockPlacementProvider
+            v-if="isPlacementEnabled(placement)"
+            :placement-id="placement.placementId"
+          >
+            <component
+              :is="resolveBlock(placement.id)"
+              :options="resolveBlockOptions(placement)"
+            />
+          </BlockPlacementProvider>
+        </template>
+      </DevOnly>
+    </template>
+  </component>
+</template>

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

@@ -0,0 +1,16 @@
+import { type Component } from 'vue';
+import type { BlockOptions, BlockPlacement, PageRegion } from '#toaster-site-runtime/types/page';
+type __VLS_Props = {
+    builderReady: boolean;
+    isPlacementEnabled: (placement: BlockPlacement) => boolean;
+    pagePlacements: (region: PageRegion) => BlockPlacement[];
+    placementKey: (region: PageRegion, placement: BlockPlacement) => string;
+    region: PageRegion;
+    resolveBlock: (id: string) => Component;
+    resolveBlockOptions: (placement: BlockPlacement & {
+        options?: BlockOptions;
+    }) => BlockOptions;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

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

package/dist/runtime/components/PageRenderer.vue

@@ -0,0 +1,65 @@
+<script setup>
+import { onBeforeUnmount } from "vue";
+import { useRoute, useSeoMeta } from "#imports";
+import PageRegionRenderer from "#toaster-site-runtime/components/PageRegionRenderer.vue";
+import { useBuilderEventService } from "#toaster-site-runtime/composables/useBuilderEventService";
+import { useBuilderState } from "#toaster-site-runtime/composables/useBuilderState";
+import { usePageRegistry } from "#toaster-site-runtime/composables/usePageRegistry";
+import { usePageSettings } from "#toaster-site-runtime/composables/usePageSettings";
+import { normalizePagePath } from "#toaster-site-runtime/utils/page-options";
+import { pageRegions } from "#toaster-site-runtime/types/page";
+const route = useRoute();
+const currentPath = () => normalizePagePath(route.path);
+const { blockDefaultOptionsRegistry, blockRegistry } = usePageRegistry();
+const {
+  builderReady,
+  formPreviewToken,
+  pageRuntimeState,
+  siteOptions
+} = useBuilderState();
+const {
+  getDescription,
+  getTitle,
+  isPlacementEnabled,
+  pagePlacements,
+  placementKey,
+  resolveBlock,
+  resolveBlockOptions
+} = usePageSettings({
+  blockDefaultOptionsRegistry,
+  blockRegistry,
+  currentPath,
+  pageRuntimeState,
+  siteOptions
+});
+if (import.meta.dev) {
+  const builderEvents = useBuilderEventService();
+  const clearPageContext = builderEvents.setPageContext({
+    currentPath,
+    formPreviewToken,
+    isKnownBlock: (blockId) => blockRegistry.has(blockId),
+    pageRuntimeState
+  });
+  onBeforeUnmount(clearPageContext);
+}
+useSeoMeta({
+  title: getTitle,
+  description: getDescription
+});
+</script>
+
+<template>
+  <div class="site-shell">
+    <PageRegionRenderer
+      v-for="region in pageRegions"
+      :key="region"
+      :builder-ready="builderReady"
+      :is-placement-enabled="isPlacementEnabled"
+      :page-placements="pagePlacements"
+      :placement-key="placementKey"
+      :region="region"
+      :resolve-block="resolveBlock"
+      :resolve-block-options="resolveBlockOptions"
+    />
+  </div>
+</template>

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

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

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

@@ -0,0 +1,15 @@
+import type { BlockOptions } from '#toaster-site-runtime/types/page';
+interface SiteControl {
+    id: string;
+    type: string;
+}
+interface UseBuilderOptions {
+    siteControls: readonly SiteControl[];
+    siteOptions: BlockOptions;
+}
+export declare function useBuilder(options: UseBuilderOptions): {
+    siteCssVariables: import("vue").ComputedRef<Record<string, string>>;
+    siteFontFacesCss: import("vue").ComputedRef<string>;
+    siteFontStyleSheets: import("vue").ComputedRef<string[]>;
+};
+export {};

package/dist/runtime/composables/useBuilder.js

@@ -0,0 +1,27 @@
+import { computed, onBeforeUnmount, onMounted } from "vue";
+import { BuilderEventService } from "#toaster-site-runtime/services/builder-event-service";
+import { collectCssVariables } from "#toaster-site-runtime/utils/css-variables";
+import { collectFontFacesCss, collectFontStyleSheets } from "#toaster-site-runtime/utils/fonts";
+import { provideBuilderEventService } from "./useBuilderEventService.js";
+import { useBuilderState } from "./useBuilderState.js";
+export function useBuilder(options) {
+  const { builderOrigin, builderReady, siteOptions } = useBuilderState(options.siteOptions);
+  if (import.meta.dev) {
+    const builderEvents = new BuilderEventService({
+      builderOrigin,
+      builderReady,
+      siteOptions
+    });
+    provideBuilderEventService(builderEvents);
+    onMounted(() => window.addEventListener("message", builderEvents.handleMessage));
+    onBeforeUnmount(() => window.removeEventListener("message", builderEvents.handleMessage));
+  }
+  const siteCssVariables = computed(() => collectCssVariables(options.siteControls, siteOptions.value));
+  const siteFontStyleSheets = computed(() => collectFontStyleSheets(options.siteControls, siteOptions.value));
+  const siteFontFacesCss = computed(() => collectFontFacesCss(options.siteControls, siteOptions.value));
+  return {
+    siteCssVariables,
+    siteFontFacesCss,
+    siteFontStyleSheets
+  };
+}

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

@@ -0,0 +1,3 @@
+import type { BuilderEventService } from '#toaster-site-runtime/services/builder-event-service';
+export declare function provideBuilderEventService(service: BuilderEventService): void;
+export declare function useBuilderEventService(): BuilderEventService;

package/dist/runtime/composables/useBuilderEventService.js

@@ -0,0 +1,14 @@
+import { inject, provide } from "vue";
+const builderEventServiceKey = Symbol(
+  "toaster-builder-event-service"
+);
+export function provideBuilderEventService(service) {
+  provide(builderEventServiceKey, service);
+}
+export function useBuilderEventService() {
+  const service = inject(builderEventServiceKey);
+  if (!service) {
+    throw new Error("BuilderEventService was not provided by the application root.");
+  }
+  return service;
+}

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

@@ -0,0 +1,8 @@
+import type { BlockOptions, PageRuntimeState } from '#toaster-site-runtime/types/page';
+export declare function useBuilderState(initialSiteOptions?: BlockOptions): {
+    builderOrigin: import("vue").Ref<string | null, string | null>;
+    builderReady: import("vue").Ref<boolean, boolean>;
+    formPreviewToken: import("vue").Ref<string | null, string | null>;
+    pageRuntimeState: import("vue").Ref<PageRuntimeState | null, PageRuntimeState | null>;
+    siteOptions: import("vue").Ref<BlockOptions, BlockOptions>;
+};

package/dist/runtime/composables/useBuilderState.js

@@ -0,0 +1,21 @@
+import { ref } from "vue";
+import { useState } from "#imports";
+export function useBuilderState(initialSiteOptions = {}) {
+  const siteOptions = useState("toaster-site-options", () => ({
+    ...initialSiteOptions
+  }));
+  const builderOrigin = import.meta.dev ? useState("toaster-builder-origin", () => null) : ref(null);
+  const builderReady = import.meta.dev ? useState("toaster-builder-ready", () => false) : ref(false);
+  const formPreviewToken = useState("toaster-form-preview-token", () => null);
+  const pageRuntimeState = useState(
+    "toaster-page-runtime-state",
+    () => null
+  );
+  return {
+    builderOrigin,
+    builderReady,
+    formPreviewToken,
+    pageRuntimeState,
+    siteOptions
+  };
+}

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

@@ -0,0 +1,6 @@
+import type { Component } from 'vue';
+import { type BlockOptions } from '#toaster-site-runtime/types/page';
+export declare function usePageRegistry(): {
+    blockDefaultOptionsRegistry: Map<string, BlockOptions>;
+    blockRegistry: Map<string, Component>;
+};

package/dist/runtime/composables/usePageRegistry.js

@@ -0,0 +1,76 @@
+import { isBlockId } from "#toaster-site-runtime/types/page";
+import { isRecord } from "#toaster-site-runtime/utils/common";
+const blockModules = import.meta.glob("/blocks/*/*/*.vue", {
+  eager: true,
+  import: "default"
+});
+const blockConfigModules = import.meta.glob("/blocks/*/*/config.json", {
+  eager: true,
+  import: "default"
+});
+const blockSchemaModules = import.meta.glob("/blocks/*/*/schema.json", {
+  eager: true,
+  import: "default"
+});
+function blockIdFromSource(source) {
+  const pathParts = source.split("/");
+  const blockName = pathParts.at(-3);
+  const variantName = pathParts.at(-2);
+  return blockName && variantName ? `${blockName}/${variantName}` : null;
+}
+export function usePageRegistry() {
+  const blockRegistry = /* @__PURE__ */ new Map();
+  const blockDefaultOptionsRegistry = /* @__PURE__ */ new Map();
+  const blockSchemaRegistry = /* @__PURE__ */ new Set();
+  for (const [source, component] of Object.entries(blockModules)) {
+    const pathParts = source.split("/");
+    const blockName = pathParts.at(-3);
+    const fileName = pathParts.at(-1)?.replace(/\.vue$/, "");
+    const blockId = blockIdFromSource(source);
+    if (!blockId || !isBlockId(blockId) || blockName !== fileName) {
+      throw new Error(`Block path must follow blocks/<Block>/<variant>/<Block>.vue: ${source}`);
+    }
+    if (blockRegistry.has(blockId)) {
+      throw new Error(`Duplicate Block id "${blockId}"`);
+    }
+    blockRegistry.set(blockId, component);
+  }
+  for (const [source, value] of Object.entries(blockConfigModules)) {
+    const blockId = blockIdFromSource(source);
+    if (!blockId || !isBlockId(blockId) || !blockRegistry.has(blockId)) {
+      throw new Error(`Block config has no matching component: ${source}`);
+    }
+    if (!isRecord(value) || value.version !== 1 || !isRecord(value.options)) {
+      throw new Error(`Invalid Block config in ${source}`);
+    }
+    if (blockDefaultOptionsRegistry.has(blockId)) {
+      throw new Error(`Duplicate config for Block "${blockId}"`);
+    }
+    blockDefaultOptionsRegistry.set(blockId, value.options);
+  }
+  for (const [source, value] of Object.entries(blockSchemaModules)) {
+    const blockId = blockIdFromSource(source);
+    if (!blockId || !isBlockId(blockId) || !blockRegistry.has(blockId)) {
+      throw new Error(`Block schema has no matching component: ${source}`);
+    }
+    if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.tabs) || !Array.isArray(value.controls)) {
+      throw new Error(`Invalid Block schema in ${source}`);
+    }
+    if (blockSchemaRegistry.has(blockId)) {
+      throw new Error(`Duplicate schema for Block "${blockId}"`);
+    }
+    blockSchemaRegistry.add(blockId);
+  }
+  for (const blockId of blockRegistry.keys()) {
+    if (!blockDefaultOptionsRegistry.has(blockId)) {
+      throw new Error(`Missing config for Block "${blockId}"`);
+    }
+    if (!blockSchemaRegistry.has(blockId)) {
+      throw new Error(`Missing schema for Block "${blockId}"`);
+    }
+  }
+  return {
+    blockDefaultOptionsRegistry,
+    blockRegistry
+  };
+}

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

@@ -0,0 +1,21 @@
+import { type Component, type Ref } from 'vue';
+import { type BlockOptions, type BlockPlacement, type PageRegion, type PageRuntimeState } from '#toaster-site-runtime/types/page';
+interface UsePageSettingsOptions {
+    blockDefaultOptionsRegistry: ReadonlyMap<string, BlockOptions>;
+    blockRegistry: ReadonlyMap<string, Component>;
+    currentPath: () => string;
+    pageRuntimeState: Ref<PageRuntimeState | null>;
+    siteOptions: Ref<BlockOptions>;
+}
+export declare function usePageSettings(options: UsePageSettingsOptions): {
+    getDescription: () => string | undefined;
+    getTitle: () => string | undefined;
+    isPlacementEnabled: (placement: BlockPlacement) => boolean;
+    pagePlacements: (region: PageRegion) => BlockPlacement[];
+    placementKey: (region: PageRegion, placement: BlockPlacement) => string;
+    resolveBlock: (id: string) => Component;
+    resolveBlockOptions: (placement: BlockPlacement & {
+        options?: BlockOptions;
+    }) => BlockOptions;
+};
+export {};

package/dist/runtime/composables/usePageSettings.js

@@ -0,0 +1,90 @@
+import { computed, watch } from "vue";
+import { createError } from "#imports";
+import {
+  pageRegions
+} from "#toaster-site-runtime/types/page";
+import { getBlockElementId } from "#toaster-site-runtime/utils/block-options";
+import { getBlockPlacementOptions, getPageConfig } from "#toaster-site-runtime/utils/page-config";
+export function usePageSettings(options) {
+  watch(options.currentPath, () => {
+    options.pageRuntimeState.value = null;
+  });
+  const pageConfig = computed(() => {
+    const currentPath = options.currentPath();
+    const persistedConfig = getPageConfig(currentPath);
+    const config = options.pageRuntimeState.value?.page.options.path === currentPath ? options.pageRuntimeState.value.page : persistedConfig;
+    if (!config) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: `Page config not found for path "${currentPath}"`
+      });
+    }
+    const elementIds = /* @__PURE__ */ new Map();
+    for (const region of pageRegions) {
+      for (const placement of config.blocks[region]) {
+        const blockId = placement.id;
+        if (!options.blockRegistry.has(blockId)) {
+          throw createError({
+            statusCode: 500,
+            statusMessage: `Unknown Block "${blockId}" used by page "${config.options.path}"`
+          });
+        }
+        const elementId = getBlockElementId(resolveBlockOptions(placement), blockId);
+        const duplicateBlock = elementIds.get(elementId);
+        if (duplicateBlock !== void 0) {
+          throw createError({
+            statusCode: 500,
+            statusMessage: `Duplicate element-id "${elementId}" in Blocks "${duplicateBlock}" and "${placement.id}"`
+          });
+        }
+        elementIds.set(elementId, blockId);
+      }
+    }
+    return config;
+  });
+  function resolveBlockOptions(placement) {
+    if (placement.options) return placement.options;
+    return {
+      ...options.blockDefaultOptionsRegistry.get(placement.id),
+      ...getBlockPlacementOptions(placement)
+    };
+  }
+  function resolveBlock(id) {
+    const component = options.blockRegistry.get(id);
+    if (!component) {
+      throw createError({
+        statusCode: 500,
+        statusMessage: `Unknown Block "${id}" used by page "${pageConfig.value.options.path}"`
+      });
+    }
+    return component;
+  }
+  function pagePlacements(region) {
+    return pageConfig.value.blocks[region];
+  }
+  function placementKey(region, placement) {
+    return `${region}:${placement.placementId}`;
+  }
+  function isPlacementEnabled(placement) {
+    return placement.enable;
+  }
+  function getSiteStringOption(optionId) {
+    const value = options.siteOptions.value[optionId];
+    return typeof value === "string" ? value : void 0;
+  }
+  function getTitle() {
+    return pageConfig.value.options.seoTitle ?? getSiteStringOption("name");
+  }
+  function getDescription() {
+    return pageConfig.value.options.seoDescription ?? getSiteStringOption("description");
+  }
+  return {
+    getDescription,
+    getTitle,
+    isPlacementEnabled,
+    pagePlacements,
+    placementKey,
+    resolveBlock,
+    resolveBlockOptions
+  };
+}

package/dist/runtime/events/builder-event.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class BuilderEvent {
+    readonly origin: string;
+    protected constructor(origin: string);
+}
+export declare abstract class BuilderMutationEvent extends BuilderEvent {
+    readonly mutationId: string;
+    protected constructor(origin: string, mutationId: string);
+}
+export declare function parseMutationId(payload: Record<string, unknown>): string | null;

package/dist/runtime/events/builder-event.js

@@ -0,0 +1,14 @@
+export class BuilderEvent {
+  constructor(origin) {
+    this.origin = origin;
+  }
+}
+export class BuilderMutationEvent extends BuilderEvent {
+  constructor(origin, mutationId) {
+    super(origin);
+    this.mutationId = mutationId;
+  }
+}
+export function parseMutationId(payload) {
+  return typeof payload.mutationId === "string" && payload.mutationId.trim() !== "" ? payload.mutationId : null;
+}

package/dist/runtime/events/builder-form-preview-token-event.d.ts

@@ -0,0 +1,7 @@
+import { BuilderMutationEvent } from './builder-event.js';
+export declare class BuilderFormPreviewTokenEvent extends BuilderMutationEvent {
+    readonly token: string;
+    static readonly event = "builder-form-preview-token";
+    private constructor();
+    static fromPayload(payload: Record<string, unknown>, origin: string): BuilderFormPreviewTokenEvent | null;
+}

package/dist/runtime/events/builder-form-preview-token-event.js

@@ -0,0 +1,19 @@
+import { BuilderMutationEvent, parseMutationId } from "./builder-event.js";
+export class BuilderFormPreviewTokenEvent extends BuilderMutationEvent {
+  constructor(token, mutationId, origin) {
+    super(origin, mutationId);
+    this.token = token;
+  }
+  static event = "builder-form-preview-token";
+  static fromPayload(payload, origin) {
+    const mutationId = parseMutationId(payload);
+    if (typeof payload.token !== "string" || payload.token === "" || mutationId === null) {
+      return null;
+    }
+    return new BuilderFormPreviewTokenEvent(
+      payload.token,
+      mutationId,
+      origin
+    );
+  }
+}

package/dist/runtime/events/builder-page-state-event.d.ts

@@ -0,0 +1,9 @@
+import { type PageRuntimeState } from '#toaster-site-runtime/types/page';
+import { BuilderMutationEvent } from './builder-event.js';
+export declare class BuilderPageStateEvent extends BuilderMutationEvent {
+    readonly state: PageRuntimeState;
+    static readonly event = "builder-page-state";
+    private constructor();
+    static fromPayload(payload: Record<string, unknown>, origin: string, isKnownBlock: (blockId: string) => boolean): BuilderPageStateEvent | null;
+    private static parseState;
+}

package/dist/runtime/events/builder-page-state-event.js

@@ -0,0 +1,62 @@
+import {
+  isBlockId,
+  isPlacementId,
+  pageRegions
+} from "#toaster-site-runtime/types/page";
+import { isRecord } from "#toaster-site-runtime/utils/common";
+import { parsePageOptions } from "#toaster-site-runtime/utils/page-options";
+import { BuilderMutationEvent, parseMutationId } from "./builder-event.js";
+export class BuilderPageStateEvent extends BuilderMutationEvent {
+  constructor(state, mutationId, origin) {
+    super(origin, mutationId);
+    this.state = state;
+  }
+  static event = "builder-page-state";
+  static fromPayload(payload, origin, isKnownBlock) {
+    const state = this.parseState(payload.state, isKnownBlock);
+    const mutationId = parseMutationId(payload);
+    if (!state || mutationId === null) return null;
+    return new BuilderPageStateEvent(
+      state,
+      mutationId,
+      origin
+    );
+  }
+  static parseState(value, isKnownBlock) {
+    if (!isRecord(value) || typeof value.revision !== "string" || !/^[a-f0-9]{64}$/.test(value.revision) || !isRecord(value.page) || value.page.version !== 1 || !isRecord(value.page.blocks)) return null;
+    let pageOptions;
+    try {
+      pageOptions = parsePageOptions(value.page.options, "builder-page-state");
+    } catch {
+      return null;
+    }
+    const placementIds = /* @__PURE__ */ new Set();
+    const blocks = {
+      header: [],
+      main: [],
+      footer: []
+    };
+    for (const region of pageRegions) {
+      const placements = value.page.blocks[region];
+      if (!Array.isArray(placements)) return null;
+      for (const placement of placements) {
+        if (!isRecord(placement) || typeof placement.id !== "string" || !isBlockId(placement.id) || !isKnownBlock(placement.id) || typeof placement.enable !== "boolean" || typeof placement.placementId !== "string" || !isPlacementId(placement.placementId) || placementIds.has(placement.placementId) || !isRecord(placement.options)) return null;
+        placementIds.add(placement.placementId);
+        blocks[region].push({
+          id: placement.id,
+          enable: placement.enable,
+          placementId: placement.placementId,
+          options: { ...placement.options }
+        });
+      }
+    }
+    return {
+      revision: value.revision,
+      page: {
+        version: 1,
+        options: pageOptions,
+        blocks
+      }
+    };
+  }
+}

package/dist/runtime/events/builder-ready-ping-event.d.ts

@@ -0,0 +1,6 @@
+import { BuilderEvent } from './builder-event.js';
+export declare class BuilderReadyPingEvent extends BuilderEvent {
+    static readonly event = "builder-ready-ping";
+    private constructor();
+    static fromOrigin(origin: string): BuilderReadyPingEvent;
+}

package/dist/runtime/events/builder-ready-ping-event.js

@@ -0,0 +1,10 @@
+import { BuilderEvent } from "./builder-event.js";
+export class BuilderReadyPingEvent extends BuilderEvent {
+  static event = "builder-ready-ping";
+  constructor(origin) {
+    super(origin);
+  }
+  static fromOrigin(origin) {
+    return new BuilderReadyPingEvent(origin);
+  }
+}

package/dist/runtime/events/site-options-updated-event.d.ts

@@ -0,0 +1,8 @@
+import type { BlockOptions } from '#toaster-site-runtime/types/page';
+import { BuilderMutationEvent } from './builder-event.js';
+export declare class SiteOptionsUpdatedEvent extends BuilderMutationEvent {
+    readonly options: BlockOptions;
+    static readonly event = "site-options-updated";
+    private constructor();
+    static fromPayload(payload: Record<string, unknown>, origin: string): SiteOptionsUpdatedEvent | null;
+}

package/dist/runtime/events/site-options-updated-event.js

@@ -0,0 +1,18 @@
+import { isRecord } from "#toaster-site-runtime/utils/common";
+import { BuilderMutationEvent, parseMutationId } from "./builder-event.js";
+export class SiteOptionsUpdatedEvent extends BuilderMutationEvent {
+  constructor(options, mutationId, origin) {
+    super(origin, mutationId);
+    this.options = options;
+  }
+  static event = "site-options-updated";
+  static fromPayload(payload, origin) {
+    const mutationId = parseMutationId(payload);
+    if (!isRecord(payload.options) || mutationId === null) return null;
+    return new SiteOptionsUpdatedEvent(
+      { ...payload.options },
+      mutationId,
+      origin
+    );
+  }
+}

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("#app").Plugin<{
+    toasterSiteRuntime: {
+        protocolVersion: number;
+    };
+}> & import("#app").ObjectPlugin<{
+    toasterSiteRuntime: {
+        protocolVersion: number;
+    };
+}>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,10 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((_nuxtApp) => {
+  return {
+    provide: {
+      toasterSiteRuntime: {
+        protocolVersion: 1
+      }
+    }
+  };
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}