@toaster-builder/site-runtime 0.1.0

package/dist/runtime/services/builder-event-service.d.ts

@@ -0,0 +1,37 @@
+import type { Ref } from 'vue';
+import type { BlockOptions, PageRegion, PageRuntimeState } from '#toaster-site-runtime/types/page';
+export type BuilderBlockEvent = 'add-block' | 'change-block-version' | 'copy-block' | 'delete-block' | 'hide-block' | 'move-block' | 'open-assistant-block' | 'open-create-block-assistant' | 'open-setting-block';
+interface BuilderBlockEventTarget {
+    blockId: string;
+    placementId: string;
+    region: PageRegion;
+}
+interface BuilderEventServiceOptions {
+    builderOrigin: Ref<string | null>;
+    builderReady: Ref<boolean>;
+    siteOptions: Ref<BlockOptions>;
+}
+export interface BuilderPageContext {
+    currentPath: () => string;
+    formPreviewToken: Ref<string | null>;
+    isKnownBlock: (blockId: string) => boolean;
+    pageRuntimeState: Ref<PageRuntimeState | null>;
+}
+export declare class BuilderEventService {
+    private readonly options;
+    private static readonly processedMutationLimit;
+    private readonly handlers;
+    private readonly processedMutationIds;
+    private pageContext;
+    constructor(options: BuilderEventServiceOptions);
+    setPageContext(context: BuilderPageContext): () => void;
+    readonly handleMessage: (messageEvent: MessageEvent<unknown>) => void;
+    sendBlockEvent(event: BuilderBlockEvent, target: BuilderBlockEventTarget, payload?: Record<string, unknown>): void;
+    private readonly handleBuilderReadyPing;
+    private readonly handleSiteOptionsUpdated;
+    private readonly handleFormPreviewToken;
+    private readonly handlePageState;
+    private applyMutation;
+    private acknowledgeMutation;
+}
+export {};

package/dist/runtime/services/builder-event-service.js

@@ -0,0 +1,104 @@
+import { BuilderFormPreviewTokenEvent } from "#toaster-site-runtime/events/builder-form-preview-token-event";
+import { BuilderPageStateEvent } from "#toaster-site-runtime/events/builder-page-state-event";
+import { BuilderReadyPingEvent } from "#toaster-site-runtime/events/builder-ready-ping-event";
+import { SiteOptionsUpdatedEvent } from "#toaster-site-runtime/events/site-options-updated-event";
+import { isRecord } from "#toaster-site-runtime/utils/common";
+export class BuilderEventService {
+  constructor(options) {
+    this.options = options;
+    this.handlers = /* @__PURE__ */ new Map([
+      [BuilderReadyPingEvent.event, (_payload, origin) => {
+        this.handleBuilderReadyPing(BuilderReadyPingEvent.fromOrigin(origin));
+      }],
+      [SiteOptionsUpdatedEvent.event, (payload, origin) => {
+        const siteOptionsUpdatedEvent = SiteOptionsUpdatedEvent.fromPayload(payload, origin);
+        if (!siteOptionsUpdatedEvent) return;
+        this.applyMutation(siteOptionsUpdatedEvent, () => this.handleSiteOptionsUpdated(siteOptionsUpdatedEvent));
+      }],
+      [BuilderFormPreviewTokenEvent.event, (payload, origin) => {
+        const formPreviewTokenEvent = BuilderFormPreviewTokenEvent.fromPayload(payload, origin);
+        if (!formPreviewTokenEvent) return;
+        this.applyMutation(formPreviewTokenEvent, () => this.handleFormPreviewToken(formPreviewTokenEvent));
+      }],
+      [BuilderPageStateEvent.event, (payload, origin) => {
+        if (!this.pageContext) return;
+        const pageStateEvent = BuilderPageStateEvent.fromPayload(
+          payload,
+          origin,
+          this.pageContext.isKnownBlock
+        );
+        if (!pageStateEvent) return;
+        this.applyMutation(pageStateEvent, () => this.handlePageState(pageStateEvent));
+      }]
+    ]);
+  }
+  static processedMutationLimit = 200;
+  handlers;
+  processedMutationIds = /* @__PURE__ */ new Set();
+  pageContext = null;
+  setPageContext(context) {
+    this.pageContext = context;
+    return () => {
+      if (this.pageContext === context) this.pageContext = null;
+    };
+  }
+  handleMessage = (messageEvent) => {
+    if (window.parent === window || messageEvent.source !== window.parent || messageEvent.origin === "null" || !isRecord(messageEvent.data) || typeof messageEvent.data.event !== "string") {
+      return;
+    }
+    if (messageEvent.data.event !== BuilderReadyPingEvent.event && messageEvent.origin !== this.options.builderOrigin.value) return;
+    this.handlers.get(messageEvent.data.event)?.(
+      messageEvent.data,
+      messageEvent.origin
+    );
+  };
+  sendBlockEvent(event, target, payload = {}) {
+    const origin = this.options.builderOrigin.value;
+    if (!this.options.builderReady.value || origin === null || window.parent === window) return;
+    window.parent.postMessage({
+      event,
+      blockId: target.blockId,
+      placementId: target.placementId,
+      region: target.region,
+      ...payload
+    }, origin);
+  }
+  handleBuilderReadyPing = (event) => {
+    this.options.builderOrigin.value = event.origin;
+    this.options.builderReady.value = true;
+    window.parent.postMessage({ event: "builder-ready-pong" }, event.origin);
+  };
+  handleSiteOptionsUpdated = (event) => {
+    this.options.siteOptions.value = event.options;
+    return true;
+  };
+  handleFormPreviewToken = (event) => {
+    if (!this.pageContext) return false;
+    this.pageContext.formPreviewToken.value = event.token;
+    return true;
+  };
+  handlePageState = (event) => {
+    if (!this.pageContext || event.state.page.options.path !== this.pageContext.currentPath()) return false;
+    this.pageContext.pageRuntimeState.value = event.state;
+    return true;
+  };
+  applyMutation(event, apply) {
+    if (this.processedMutationIds.has(event.mutationId)) {
+      this.acknowledgeMutation(event);
+      return;
+    }
+    if (!apply()) return;
+    this.processedMutationIds.add(event.mutationId);
+    if (this.processedMutationIds.size > BuilderEventService.processedMutationLimit) {
+      const oldestMutationId = this.processedMutationIds.values().next().value;
+      if (oldestMutationId !== void 0) this.processedMutationIds.delete(oldestMutationId);
+    }
+    this.acknowledgeMutation(event);
+  }
+  acknowledgeMutation(event) {
+    window.parent.postMessage({
+      event: "builder-mutation-applied",
+      mutationId: event.mutationId
+    }, event.origin);
+  }
+}

package/dist/runtime/types/assets.d.ts

@@ -0,0 +1,5 @@
+declare module '*.svg' {
+  const source: string
+
+  export default source
+}

package/dist/runtime/types/page.d.ts

@@ -0,0 +1,37 @@
+export declare const pageRegions: readonly ["header", "main", "footer"];
+export declare const blockIdPattern: RegExp;
+export declare const placementIdPattern: RegExp;
+export type PageRegion = (typeof pageRegions)[number];
+export type BlockOptions = Record<string, unknown>;
+export interface BlockPlacement {
+    id: string;
+    enable: boolean;
+    placementId: string;
+}
+export type PageBlocks = Record<PageRegion, BlockPlacement[]>;
+export interface PageOptions {
+    publish: boolean;
+    path: string;
+    seoTitle?: string;
+    seoDescription?: string;
+    [key: string]: unknown;
+}
+export interface PageConfig {
+    version: 1;
+    options: PageOptions;
+    blocks: PageBlocks;
+}
+export interface PageRuntimePlacement extends BlockPlacement {
+    options: BlockOptions;
+}
+export interface PageRuntimeDocument {
+    version: 1;
+    options: PageOptions;
+    blocks: Record<PageRegion, PageRuntimePlacement[]>;
+}
+export interface PageRuntimeState {
+    revision: string;
+    page: PageRuntimeDocument;
+}
+export declare function isBlockId(value: string): boolean;
+export declare function isPlacementId(value: string): boolean;

package/dist/runtime/types/page.js

@@ -0,0 +1,9 @@
+export const pageRegions = ["header", "main", "footer"];
+export const blockIdPattern = /^[A-Z][\w-]*\/[A-Z][\w-]*$/i;
+export const placementIdPattern = /^[A-Z0-9][\w-]{0,127}$/i;
+export function isBlockId(value) {
+  return blockIdPattern.test(value);
+}
+export function isPlacementId(value) {
+  return placementIdPattern.test(value);
+}

package/dist/runtime/utils/block-options.d.ts

@@ -0,0 +1,2 @@
+import type { BlockOptions } from '#toaster-site-runtime/types/page';
+export declare function getBlockElementId(options: BlockOptions, blockId: string): string;

package/dist/runtime/utils/block-options.js

@@ -0,0 +1,9 @@
+export function getBlockElementId(options, blockId) {
+  const value = options["element-id"];
+  if (typeof value !== "string" || value.trim() === "" || /\s/.test(value)) {
+    throw new Error(
+      `Block "${blockId}" option "element-id" must contain a non-empty ID without spaces.`
+    );
+  }
+  return value;
+}

package/dist/runtime/utils/block-placement.d.ts

@@ -0,0 +1,2 @@
+import type { InjectionKey, Ref } from 'vue';
+export declare const blockPlacementIdKey: InjectionKey<Readonly<Ref<string>>>;

package/dist/runtime/utils/block-placement.js

@@ -0,0 +1 @@
+export const blockPlacementIdKey = Symbol("toaster-block-placement-id");

package/dist/runtime/utils/common.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isDev(): boolean;

package/dist/runtime/utils/common.js

@@ -0,0 +1,6 @@
+export function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isDev() {
+  return import.meta.dev;
+}

package/dist/runtime/utils/css-variables.d.ts

@@ -0,0 +1,7 @@
+export interface CssVariableControl {
+    id: string;
+    type: string;
+}
+export declare function controlIdToCssVariable(id: string): string;
+export declare function collectCssVariables(controls: readonly CssVariableControl[], options: Readonly<Record<string, unknown>>): Record<string, string>;
+export declare function serializeCssVariables(variables: Readonly<Record<string, string>>): string;

package/dist/runtime/utils/css-variables.js

@@ -0,0 +1,35 @@
+import { resolveFontFamily } from "#toaster-site-runtime/utils/fonts";
+const cssVariableControlTypes = /* @__PURE__ */ new Set(["color", "font"]);
+const controlIdPattern = /^[a-z][a-zA-Z0-9]*$/;
+const unsafeCssValuePattern = /[;{}]/;
+export function controlIdToCssVariable(id) {
+  if (!controlIdPattern.test(id)) {
+    throw new Error(`Control id "${id}" cannot be converted to a CSS variable name.`);
+  }
+  return `--${id.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()}`;
+}
+export function collectCssVariables(controls, options) {
+  const variables = {};
+  for (const control of controls) {
+    if (!cssVariableControlTypes.has(control.type)) {
+      continue;
+    }
+    const variableName = controlIdToCssVariable(control.id);
+    if (variables[variableName] !== void 0) {
+      throw new Error(`CSS variable "${variableName}" is declared more than once.`);
+    }
+    const value = options[control.id];
+    if (control.type === "font") {
+      variables[variableName] = resolveFontFamily(value, control.id);
+      continue;
+    }
+    if (typeof value !== "string" || value.trim() === "" || unsafeCssValuePattern.test(value)) {
+      throw new Error(`Option "${control.id}" must contain a safe non-empty CSS value.`);
+    }
+    variables[variableName] = value.trim();
+  }
+  return variables;
+}
+export function serializeCssVariables(variables) {
+  return Object.entries(variables).map(([name, value]) => `${name}: ${value}`).join("; ");
+}

package/dist/runtime/utils/fonts.d.ts

@@ -0,0 +1,8 @@
+interface FontControl {
+    id: string;
+    type: string;
+}
+export declare function resolveFontFamily(value: unknown, optionId: string): string;
+export declare function collectFontStyleSheets(controls: readonly FontControl[], options: Readonly<Record<string, unknown>>): string[];
+export declare function collectFontFacesCss(controls: readonly FontControl[], options: Readonly<Record<string, unknown>>): string;
+export {};

package/dist/runtime/utils/fonts.js

@@ -0,0 +1,80 @@
+import { isRecord } from "#toaster-site-runtime/utils/common";
+const fallbackNames = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui"
+]);
+const fontStyles = /* @__PURE__ */ new Set(["normal", "italic", "oblique"]);
+function isGoogleFontsStylesheet(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.hostname === "fonts.googleapis.com" && url.pathname === "/css2";
+  } catch {
+    return false;
+  }
+}
+function fontFaceFormat(value) {
+  try {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol) || url.username !== "" || url.password !== "") return null;
+    const extension = url.pathname.split(".").at(-1)?.toLowerCase();
+    return {
+      woff2: "woff2",
+      woff: "woff",
+      ttf: "truetype",
+      otf: "opentype"
+    }[extension ?? ""] ?? null;
+  } catch {
+    return null;
+  }
+}
+function getFontSelection(value, optionId) {
+  if (!isRecord(value) || !["google_fonts", "custom_fonts"].includes(String(value.provider)) || typeof value.key !== "string" || value.key.trim() === "" || value.key.length > 100 || typeof value.family !== "string" || value.family.trim() === "" || value.family.length > 100 || !/^[\p{L}\p{N} ._-]+$/u.test(value.family) || typeof value.fallback !== "string" || !fallbackNames.has(value.fallback) || !isRecord(value.installation)) {
+    throw new Error(`Font option "${optionId}" does not contain a valid font selection.`);
+  }
+  if (value.provider === "google_fonts" && value.installation.type === "stylesheet" && typeof value.installation.url === "string" && isGoogleFontsStylesheet(value.installation.url)) {
+    return value;
+  }
+  if (value.provider === "custom_fonts" && value.installation.type === "font_faces" && Array.isArray(value.installation.faces) && value.installation.faces.length > 0 && value.installation.faces.every((face) => isRecord(face) && Number.isInteger(face.weight) && Number(face.weight) >= 1 && Number(face.weight) <= 1e3 && typeof face.style === "string" && fontStyles.has(face.style) && typeof face.url === "string" && fontFaceFormat(face.url) !== null)) {
+    return value;
+  }
+  throw new Error(`Font option "${optionId}" contains an invalid provider installation.`);
+}
+export function resolveFontFamily(value, optionId) {
+  const font = getFontSelection(value, optionId);
+  return `"${font.family}", ${font.fallback}`;
+}
+export function collectFontStyleSheets(controls, options) {
+  const styleSheets = /* @__PURE__ */ new Set();
+  for (const control of controls) {
+    if (control.type !== "font") continue;
+    const font = getFontSelection(options[control.id], control.id);
+    if (font.installation.type === "stylesheet") {
+      styleSheets.add(font.installation.url);
+    }
+  }
+  return [...styleSheets];
+}
+export function collectFontFacesCss(controls, options) {
+  const rules = /* @__PURE__ */ new Set();
+  for (const control of controls) {
+    if (control.type !== "font") continue;
+    const font = getFontSelection(options[control.id], control.id);
+    if (font.installation.type !== "font_faces") continue;
+    for (const face of font.installation.faces) {
+      const format = fontFaceFormat(face.url);
+      if (!format) continue;
+      rules.add(`@font-face {
+  font-family: ${JSON.stringify(font.family)};
+  font-style: ${face.style};
+  font-weight: ${face.weight};
+  font-display: swap;
+  src: url(${JSON.stringify(face.url)}) format(${JSON.stringify(format)});
+}`);
+    }
+  }
+  return [...rules].join("\n");
+}

package/dist/runtime/utils/page-config.d.ts

@@ -0,0 +1,3 @@
+import { type BlockOptions, type BlockPlacement, type PageConfig } from '#toaster-site-runtime/types/page';
+export declare function getPageConfig(path: string): PageConfig | undefined;
+export declare function getBlockPlacementOptions(placement: BlockPlacement): BlockOptions;

package/dist/runtime/utils/page-config.js

@@ -0,0 +1,114 @@
+import {
+  isBlockId,
+  isPlacementId,
+  pageRegions
+} from "#toaster-site-runtime/types/page";
+import { normalizePagePath, parsePageOptions } from "#toaster-site-runtime/utils/page-options";
+import { isDev, isRecord } from "#toaster-site-runtime/utils/common";
+const pageConfigModules = import.meta.glob("/pages/*/config.json", {
+  eager: true,
+  import: "default"
+});
+const pageSchemaModules = import.meta.glob("/pages/*/schema.json", {
+  eager: true,
+  import: "default"
+});
+const placementOptionsModules = import.meta.glob("/pages/*/blocks/*.options.json", {
+  eager: true,
+  import: "default"
+});
+function parsePlacement(value, source, region) {
+  if (!isRecord(value) || typeof value.id !== "string" || !isBlockId(value.id) || typeof value.enable !== "boolean" || typeof value.placementId !== "string" || !isPlacementId(value.placementId)) {
+    throw new Error(`Invalid block placement in ${source}, region "${region}"`);
+  }
+  return {
+    id: value.id,
+    enable: value.enable,
+    placementId: value.placementId
+  };
+}
+function parsePageConfig(value, source) {
+  if (!isRecord(value) || value.version !== 1) {
+    throw new Error(`Unsupported or missing page config version in ${source}`);
+  }
+  if (!isRecord(value.blocks)) {
+    throw new Error(`Page config must contain a blocks object in ${source}`);
+  }
+  const blocks = {};
+  for (const region of pageRegions) {
+    const placements = value.blocks[region];
+    if (!Array.isArray(placements)) {
+      throw new TypeError(`Page config blocks.${region} must be an array in ${source}`);
+    }
+    blocks[region] = placements.map((placement) => parsePlacement(placement, source, region));
+  }
+  const options = parsePageOptions(value.options, source);
+  return {
+    version: 1,
+    options,
+    blocks
+  };
+}
+const pageConfigsByPath = /* @__PURE__ */ new Map();
+const placementOptionsById = /* @__PURE__ */ new Map();
+const placementIds = /* @__PURE__ */ new Set();
+const referencedSchemaSources = /* @__PURE__ */ new Set();
+function placementOptionsSource(pageConfigSource, placement) {
+  const [blockName, blockVersion] = placement.id.split("/");
+  return pageConfigSource.replace(
+    /\/config\.json$/,
+    `/blocks/${blockName}.${blockVersion}.${placement.placementId}.options.json`
+  );
+}
+for (const [source, value] of Object.entries(pageConfigModules)) {
+  const config = parsePageConfig(value, source);
+  const schemaSource = source.replace(/\/config\.json$/, "/schema.json");
+  const schema = pageSchemaModules[schemaSource];
+  if (!isRecord(schema) || schema.version !== 1 || !Array.isArray(schema.tabs) || !Array.isArray(schema.controls)) {
+    throw new Error(`Missing or invalid page schema: ${schemaSource}`);
+  }
+  referencedSchemaSources.add(schemaSource);
+  const duplicate = pageConfigsByPath.get(config.options.path);
+  if (duplicate) {
+    throw new Error(`Duplicate page path "${config.options.path}" in ${source}`);
+  }
+  for (const region of pageRegions) {
+    for (const placement of config.blocks[region]) {
+      if (placementIds.has(placement.placementId)) {
+        throw new Error(`Duplicate placementId "${placement.placementId}" in ${source}`);
+      }
+      placementIds.add(placement.placementId);
+      const optionsSource = placementOptionsSource(source, placement);
+      const optionsDocument = placementOptionsModules[optionsSource];
+      if (!optionsDocument) {
+        if (isDev()) {
+          placementOptionsById.set(placement.placementId, {
+            "element-id": `placement-${placement.placementId}`
+          });
+          continue;
+        }
+        throw new Error(`Missing placement options: ${optionsSource}`);
+      }
+      if (!isRecord(optionsDocument) || optionsDocument.version !== 1 || !isRecord(optionsDocument.options)) {
+        throw new Error(`Missing or invalid placement options: ${optionsSource}`);
+      }
+      placementOptionsById.set(placement.placementId, optionsDocument.options);
+    }
+  }
+  pageConfigsByPath.set(config.options.path, config);
+}
+for (const source of Object.keys(pageSchemaModules)) {
+  if (!referencedSchemaSources.has(source)) {
+    throw new Error(`Orphan page schema: ${source}`);
+  }
+}
+export function getPageConfig(path) {
+  return pageConfigsByPath.get(normalizePagePath(path));
+}
+export function getBlockPlacementOptions(placement) {
+  const options = placementOptionsById.get(placement.placementId);
+  if (!options) {
+    throw new Error(`Options for placement "${placement.placementId}" were not loaded`);
+  }
+  return options;
+}

package/dist/runtime/utils/page-options.d.ts

@@ -0,0 +1,3 @@
+import type { PageOptions } from '#toaster-site-runtime/types/page';
+export declare function normalizePagePath(path: string): string;
+export declare function parsePageOptions(value: unknown, source: string): PageOptions;

package/dist/runtime/utils/page-options.js

@@ -0,0 +1,26 @@
+import { isRecord } from "#toaster-site-runtime/utils/common";
+export function normalizePagePath(path) {
+  const normalized = path.trim();
+  if (!normalized.startsWith("/")) {
+    throw new Error(`Page path must start with "/": ${path}`);
+  }
+  if (normalized.includes("?") || normalized.includes("#")) {
+    throw new Error(`Page path must not contain query or hash fragments: ${path}`);
+  }
+  return normalized === "/" ? normalized : normalized.replace(/\/+$/, "");
+}
+export function parsePageOptions(value, source) {
+  if (!isRecord(value) || typeof value.publish !== "boolean" || typeof value.path !== "string") {
+    throw new Error(`Page options must contain boolean publish and string path in ${source}`);
+  }
+  if (value.seoTitle !== void 0 && typeof value.seoTitle !== "string") {
+    throw new Error(`Page options seoTitle must be a string in ${source}`);
+  }
+  if (value.seoDescription !== void 0 && typeof value.seoDescription !== "string") {
+    throw new Error(`Page options seoDescription must be a string in ${source}`);
+  }
+  return {
+    ...value,
+    path: normalizePagePath(value.path)
+  };
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@toaster-builder/site-runtime",
+  "version": "0.1.0",
+  "description": "Shared Nuxt runtime for Toaster sites and Builder integration",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "workspaces": [
+    "playground"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run test:types && npm run prepack && changelogen --release && npm publish --access public && git push --follow-tags",
+    "lint": "eslint .",
+    "pretest": "npm run dev:prepare",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "pretest:types": "npm run dev:prepare",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.5.2"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.4.2",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.5.2",
+    "@nuxt/test-utils": "^4.3.2",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.10.0",
+    "nuxt": "^4.5.2",
+    "sass": "^1.105.0",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.1",
+    "vue-tsc": "^3.3.11"
+  }
+}