rimelight-components 2.0.59 → 2.0.61

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "rimelight-components",
-  "version": "2.0.59",
+  "version": "2.0.61",
   "docs": "https://rimelight.com/tools/rimelight-components",
   "configKey": "rimelightComponents",
   "compatibility": {

package/dist/module.mjs

@@ -5,7 +5,7 @@ import { basename } from 'node:path';
 export * from '../dist/runtime/types/index.js';
 
 const name = "rimelight-components";
-const version = "2.0.59";
+const version = "2.0.61";
 const homepage = "https://rimelight.com/tools/rimelight-components";
 
 const defaultOptions = {

package/dist/runtime/app.config.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    rimelightComponents: {};
+};
+export default _default;

package/dist/runtime/app.config.js

@@ -0,0 +1,4 @@
+import { defineAppConfig } from "#imports";
+export default defineAppConfig({
+  rimelightComponents: {}
+});

package/dist/runtime/components/blocks/BlockEditor.vue

@@ -16,7 +16,7 @@ const {
   redo,
   canUndo,
   canRedo
-} = useBlockEditor(blocks, historyLimit);
+} = useBlockEditor(blocks, { maxHistorySize: historyLimit });
 provide("block-editor-api", {
   removeBlock,
   moveBlock,

package/dist/runtime/components/content/Section.vue

@@ -2,7 +2,7 @@
 import { useRoute } from "#imports";
 import { computed } from "vue";
 import { useClipboard } from "@vueuse/core";
-import { useToast } from "#imports";
+import { useToast } from "@nuxt/ui/composables";
 import { tv } from "tailwind-variants";
 import { slugify } from "../../utils";
 const { copy } = useClipboard();

package/dist/runtime/components/page/PageEditor.d.vue.ts

@@ -1,24 +0,0 @@
-import type { Page } from "../../types/pages.js";
-interface Props {
-    isSaving: boolean;
-}
-type __VLS_Props = Props;
-type __VLS_ModelProps = {
-    modelValue: Page;
-};
-type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
-    undo: () => void;
-    redo: () => void;
-    canUndo: import("vue").ComputedRef<boolean>;
-    canRedo: import("vue").ComputedRef<boolean>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Page) => any;
-} & {
-    save: (value: Page) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onSave?: ((value: Page) => any) | undefined;
-    "onUpdate:modelValue"?: ((value: Page) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/page/PageEditor.vue

@@ -1,7 +1,7 @@
 <script setup>
 import { ref, computed, useTemplateRef } from "vue";
 import { usePageEditor } from "../../composables/usePageEditor";
-const page = defineModel({ type: Object, ...{ required: true } });
+const page = defineModel({ type: null, ...{ required: true } });
 const { undo, redo, canUndo, canRedo, captureSnapshot } = usePageEditor(page);
 const emit = defineEmits(["save"]);
 const handleSave = () => {

package/dist/runtime/components/page/PageEditor.vue.d.ts

@@ -1,24 +0,0 @@
-import type { Page } from "../../types/pages.js";
-interface Props {
-    isSaving: boolean;
-}
-type __VLS_Props = Props;
-type __VLS_ModelProps = {
-    modelValue: Page;
-};
-type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
-    undo: () => void;
-    redo: () => void;
-    canUndo: import("vue").ComputedRef<boolean>;
-    canRedo: import("vue").ComputedRef<boolean>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Page) => any;
-} & {
-    save: (value: Page) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onSave?: ((value: Page) => any) | undefined;
-    "onUpdate:modelValue"?: ((value: Page) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/page/PagePropertiesEditor.d.vue.ts

@@ -1,11 +0,0 @@
-import { type Page } from '../../types/pages.js';
-type __VLS_ModelProps = {
-    modelValue: Page;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Page) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Page) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/page/PagePropertiesEditor.vue

@@ -1,10 +1,14 @@
 <script setup>
 import { computed } from "vue";
-import { PAGE_SCHEMAS } from "../../types/pages";
-const page = defineModel({ type: Object, ...{ required: true } });
+import { useAppConfig } from "#imports";
+import { useI18n } from "vue-i18n";
+import {} from "../../types/pages";
+const page = defineModel({ type: null, ...{ required: true } });
+const appConfig = useAppConfig();
+const locale = useI18n().locale;
 const properties = computed(() => page.value.properties);
 const groups = computed(() => {
-  return PAGE_SCHEMAS[page.value.type] || [];
+  return page.value.properties;
 });
 const isFieldVisible = (fieldSchema) => {
   if (!fieldSchema.visibleIf) return true;
@@ -26,46 +30,46 @@ const getSortedFields = (fields) => {
       </UBadge>
     </div>
 
-    <div v-for="group in groups" :key="group.id" class="space-y-4">
+    <div v-for="(group, groupId) in groups" :key="groupId" class="space-y-4">
       <div class="flex items-center gap-3">
         <span class="text-[10px] font-bold uppercase tracking-widest text-primary">
-          {{ group.label }}
+          {{ group.label[locale] }}
         </span>
         <div class="h-px flex-1 bg-border/50"></div>
       </div>
 
       <div class="grid gap-y-4 px-1">
-        <template v-for="[key, schema] in getSortedFields(group.fields)" :key="key">
+        <template v-for="[fieldKey, schema] in getSortedFields(group.fields)" :key="fieldKey">
 
           <UFormField
             v-if="isFieldVisible(schema)"
             :label="schema.label"
-            :name="key"
+            :name="fieldKey"
           >
             <UInput
               v-if="schema.type === 'text'"
-              v-model="properties[key]"
+              v-model="properties[groupId].fields[fieldKey].value[locale]"
               variant="subtle"
               placeholder="..."
             />
 
             <UInput
               v-else-if="schema.type === 'number'"
-              v-model.number="properties[key]"
+              v-model.number="properties[groupId].fields[fieldKey].value"
               type="number"
               variant="subtle"
             />
 
             <USelect
               v-else-if="schema.type === 'enum'"
-              v-model="properties[key]"
+              v-model="properties[groupId].fields[fieldKey].value"
               :items="schema.options || []"
               variant="subtle"
             />
 
             <UInputMenu
               v-else-if="schema.type === 'text-array'"
-              v-model="properties[key]"
+              v-model="properties[groupId].fields[fieldKey].value[locale]"
               multiple
               creatable
               variant="subtle"
@@ -74,7 +78,7 @@ const getSortedFields = (fields) => {
 
             <UInput
               v-else-if="schema.type === 'page'"
-              v-model="properties[key]"
+              v-model="properties[groupId].fields[fieldKey].value"
               icon="lucide:link-2"
               variant="subtle"
               :placeholder="`Select ${schema.allowedPageTypes?.join('/')}`"

package/dist/runtime/components/page/PagePropertiesEditor.vue.d.ts

@@ -1,11 +0,0 @@
-import { type Page } from '../../types/pages.js';
-type __VLS_ModelProps = {
-    modelValue: Page;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Page) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Page) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/page/PagePropertiesRenderer.vue

@@ -1,17 +1,19 @@
 <script setup>
 import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { useI18n } from "vue-i18n";
 import {
-  PAGE_SCHEMAS
 } from "../../types/pages";
 const props = defineProps({
-  modelValue: { type: Object, required: true }
+  modelValue: { type: null, required: true }
 });
+const appConfig = useAppConfig();
+const locale = useI18n().locale;
 const properties = computed(() => props.modelValue.properties);
 const displayGroups = computed(() => {
-  const allGroups = PAGE_SCHEMAS[props.modelValue.type] || [];
-  return allGroups.map((group) => {
-    const visibleFields = Object.entries(group.fields).filter(([key, schema]) => {
-      const value = properties.value[key];
+  return Object.entries(properties.value || {}).map(([groupId, group]) => {
+    const visibleFields = Object.entries(group.fields || {}).filter(([fieldKey, schema]) => {
+      const value = schema.type === "text" || schema.type === "text-array" ? schema.value?.[locale.value] : schema.value;
       const isVisible = !schema.visibleIf || schema.visibleIf(props.modelValue.properties);
       if (!isVisible) return false;
       if (Array.isArray(value)) return value.length > 0;
@@ -19,6 +21,7 @@ const displayGroups = computed(() => {
     }).sort(([, a], [, b]) => (a.order ?? 0) - (b.order ?? 0));
     return {
       ...group,
+      groupId,
       visibleFields
     };
   }).filter((group) => group.visibleFields.length > 0);
@@ -32,19 +35,19 @@ const displayGroups = computed(() => {
         {{ props.modelValue.type }}
       </div>
       <h2 class="text-xl font-serif font-bold italic text-foreground">
-        {{ properties.name || props.modelValue.slug }}
+        {{ properties.name?.value?.[locale] || props.modelValue.slug }}
       </h2>
     </div>
 
-    <div v-for="group in displayGroups" :key="group.id" class="border-b last:border-b-0 border-border/40">
+    <div v-for="group in displayGroups" :key="group.groupId" class="border-b last:border-b-0 border-border/40">
       <div class="bg-muted/30 px-3 py-1.5 text-[10px] font-black text-primary uppercase tracking-tighter border-b border-border/10">
-        {{ group.label }}
+        {{ group.label[locale] }}
       </div>
 
       <dl class="p-3 space-y-2.5">
         <div
-          v-for="[key, schema] in group.visibleFields"
-          :key="key"
+          v-for="[fieldKey, schema] in group.visibleFields"
+          :key="fieldKey"
           class="grid grid-cols-3 gap-x-3 items-baseline"
         >
           <dt class="text-[11px] font-semibold text-muted-foreground leading-tight">
@@ -53,18 +56,22 @@ const displayGroups = computed(() => {
 
           <dd class="text-xs col-span-2 text-foreground leading-snug">
             <div v-if="schema.type === 'text-array'" class="flex flex-wrap gap-1">
-              <template v-for="(item, index) in properties[key]" :key="index">
+              <template v-for="(item, index) in properties[group.groupId].fields[fieldKey].value[locale]" :key="index">
                 <span class="font-medium">{{ item }}</span>
-                <span v-if="index < properties[key].length - 1" class="text-muted-foreground/50">, </span>
+                <span v-if="index < properties[group.groupId].fields[fieldKey].value[locale].length - 1" class="text-muted-foreground/50">, </span>
               </template>
             </div>
 
             <span v-else-if="schema.type === 'page'" class="text-primary font-bold hover:underline cursor-pointer">
-              {{ properties[key] }}
+              {{ properties[group.groupId].fields[fieldKey].value }}
+            </span>
+
+            <span v-else-if="schema.type === 'text'" class="font-medium">
+              {{ properties[group.groupId].fields[fieldKey].value[locale] }}
             </span>
 
             <span v-else class="font-medium">
-              {{ properties[key] }}
+              {{ properties[group.groupId].fields[fieldKey].value }}
             </span>
           </dd>
         </div>
@@ -75,16 +82,17 @@ const displayGroups = computed(() => {
       <div class="flex flex-wrap gap-1.5">
         <UBadge
           v-for="tag in props.modelValue.tags"
-          :key="tag"
+          :key="String(tag[locale])"
           variant="subtle"
           size="sm"
           color="neutral"
           class="text-[9px] font-bold uppercase tracking-tight"
         >
-          #{{ tag }}
+          #{{ tag[locale] }}
         </UBadge>
       </div>
     </div>
+
   </div>
 </template>
 

package/dist/runtime/components/swatches/ColorSwatch.vue

@@ -1,7 +1,7 @@
 <script setup>
 import { computed } from "vue";
 import { useClipboard } from "@vueuse/core";
-import { useToast } from "#imports";
+import { useToast } from "@nuxt/ui/composables";
 const { copy } = useClipboard();
 const toast = useToast();
 const { name, hex, rgb, hsl, oklch, cmyk } = defineProps({

package/dist/runtime/types/app.config.d.ts

@@ -1,6 +1,14 @@
 declare module '#build/app.config' {
   import type { AppConfig } from '@nuxt/schema'
 
-  const _default: AppConfig
+  interface RimelightComponentsConfig {
+    [key: string]: any
+  }
+
+  interface CustomAppConfig extends AppConfig {
+    rimelightComponents?: RimelightComponentsConfig
+  }
+
+  const _default: CustomAppConfig
   export default _default
-}
+}

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

@@ -1,4 +1,3 @@
 export * from "./blocks.js";
 export * from "./pages.js";
-export * from "./pageTemplates.js";
 export * from "./schemas.js";

package/dist/runtime/types/index.js

@@ -1,4 +1,3 @@
 export * from "./blocks.js";
 export * from "./pages.js";
-export * from "./pageTemplates.js";
 export * from "./schemas.js";

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

@@ -1,7 +1,12 @@
 import { type Image } from "../types/schemas.js";
 import { type Block } from "./blocks.js";
-export type PageType = "Default" | "Document" | "BlogPost" | "PatchNote" | "Location" | "Species" | "Character" | "Object" | "Tale" | "Item" | "Skill" | "Hero" | "Card" | "Series" | "Episode";
-export interface Property {
+declare global {
+    interface RimelightRegisterPageTypes {
+    }
+}
+export type PageType = keyof RegisterPageTypes;
+export interface Property<T = any> {
+    value: T;
     label: string;
     type: "number" | "text" | "text-array" | "enum" | "page" | "page-array";
     options?: string[];
@@ -9,66 +14,29 @@ export interface Property {
     order?: number;
     visibleIf?: (properties: any) => boolean;
 }
+export type Localized<T = string> = Record<string, T>;
 export interface PropertyGroup {
-    id: string;
-    label: string;
+    label: Localized<string>;
     order?: number;
     fields: Record<string, Property>;
 }
-export interface BasePageProperties {
-}
-export interface DocumentProperties extends BasePageProperties {
-}
-export interface BlogPostProperties extends BasePageProperties {
-}
-export interface PatchNoteProperties extends BasePageProperties {
-}
-export interface LocationProperties extends BasePageProperties {
-}
-export interface SpeciesProperties extends BasePageProperties {
-}
-export interface CharacterProperties extends BasePageProperties {
-    name: string;
-    title?: string;
-    aliases?: string[];
-    flavourText?: string;
-    species?: string;
-    sex?: string;
-    pronouns?: string;
-    height?: number;
-    weight?: number;
-    dateOfBirth?: string;
-    dateOfDeath?: string;
-    placeOfBirth?: string;
-    placeOfDeath?: string;
-    formerAffiliations?: string[];
-    currentAffiliations?: string[];
-    equipment?: string[];
-    pets?: string[];
-    mounts?: string[];
-    favouriteFood?: string;
-}
-export interface ObjectProperties extends BasePageProperties {
-}
-export interface TaleProperties extends BasePageProperties {
-}
-export interface ItemProperties extends BasePageProperties {
-}
-export interface SkillProperties extends BasePageProperties {
-}
-export interface HeroProperties extends BasePageProperties {
-}
-export interface CardProperties extends BasePageProperties {
-    name: string;
-    alignment: string;
-    type: string;
-    flavourText: string;
+/**
+ * A PageTemplate is the single definition for a page's properties and initial blocks.
+ */
+export interface PageDefinition {
+    properties: Record<string, PropertyGroup>;
+    initialBlocks?: () => Block[];
 }
-export interface SeriesProperties extends BasePageProperties {
+/**
+ * Helper to define a page with full type safety and literal preservation.
+ * This is used by consuming apps to define their custom page types.
+ */
+export declare function definePageDefinition<T extends PageDefinition>(def: T): T;
+export interface BasePageProperties {
 }
-export interface EpisodeProperties extends BasePageProperties {
+export interface RegisterPageTypes extends RimelightRegisterPageTypes {
+    Default: BasePageProperties;
 }
-export type Localized<T = string> = Record<string, T>;
 /**
  * Common fields shared by every page regardless of type.
  */
@@ -89,54 +57,9 @@ interface BasePage {
  * Discriminated Union for Page Data structure
  */
 export type Page = {
-    type: "Default";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Document";
-    properties: DocumentProperties;
-} & BasePage | {
-    type: "BlogPost";
-    properties: BlogPostProperties;
-} & BasePage | {
-    type: "PatchNote";
-    properties: PatchNoteProperties;
-} & BasePage | {
-    type: "Character";
-    properties: CharacterProperties;
-} & BasePage | {
-    type: "Card";
-    properties: CardProperties;
-} & BasePage | {
-    type: "Location";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Species";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Object";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Tale";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Item";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Skill";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Hero";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Series";
-    properties: BasePageProperties;
-} & BasePage | {
-    type: "Episode";
-    properties: BasePageProperties;
-} & BasePage;
-/**
- * Registry mapping PageTypes to their UI schema.
- * This drives the dynamic form generation in the Sidebar.
- */
-export declare const PAGE_SCHEMAS: Record<PageType, PropertyGroup[]>;
+    [K in PageType]: {
+        type: K;
+        properties: RegisterPageTypes[K];
+    } & BasePage;
+}[PageType];
 export {};

package/dist/runtime/types/pages.js

@@ -1,58 +1,3 @@
-export const PAGE_SCHEMAS = {
-  Default: [],
-  Document: [],
-  BlogPost: [],
-  PatchNote: [],
-  Character: [
-    {
-      id: "identity",
-      label: "Identity",
-      fields: {
-        name: { label: "Name", type: "text" },
-        title: { label: "Social Title", type: "text" },
-        aliases: { label: "Aliases", type: "text-array" }
-      }
-    },
-    {
-      id: "characteristics",
-      label: "Characteristics",
-      fields: {
-        species: { label: "Species", type: "page", allowedPageTypes: ["Species"] },
-        sex: { label: "Sex", type: "enum", options: ["Male", "Female", "Other", "Unknown"] },
-        height: { label: "Height", type: "number" },
-        weight: { label: "Weight", type: "number" }
-      }
-    },
-    {
-      id: "timeline",
-      label: "Timeline",
-      fields: {
-        dateOfBirth: { label: "Date of Birth", type: "text" },
-        dateOfDeath: { label: "Date of Death", type: "text" },
-        placeOfDeath: {
-          label: "Place of Death",
-          type: "text",
-          visibleIf: (props) => !!props.dateOfDeath
-        }
-      }
-    },
-    {
-      id: "other",
-      label: "Other",
-      order: 3,
-      fields: {
-        flavourText: { label: "Flavour Text", type: "text" }
-      }
-    }
-  ],
-  Location: [],
-  Species: [],
-  Object: [],
-  Tale: [],
-  Item: [],
-  Skill: [],
-  Hero: [],
-  Card: [],
-  Series: [],
-  Episode: []
-};
+export function definePageDefinition(def) {
+  return def;
+}

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

@@ -1,7 +1,10 @@
-import type { Page, Localized } from "../types/pages.js";
+import type { Page, Localized, PageDefinition } from "../types/pages.js";
 export declare const getLocalizedContent: (field: Localized | undefined, currentLocale: string) => string;
 /**
- * Ensures an existing page has all the blocks currently defined in its template.
- * Matches based on SectionBlock titles.
+ * Ensures a page strictly adheres to its PageDefinition.
+ * - Adds missing properties and groups in the correct order.
+ * - Removes properties and groups no longer in the definition.
+ * - Adds missing templated blocks in the correct relative position.
+ * - Removes templated blocks no longer in the definition.
  */
-export declare function syncTemplateBlocks(page: Page): Page;
+export declare function syncPageWithDefinition(page: Page, definition?: PageDefinition): Page;

package/dist/runtime/utils/page.js

@@ -1,20 +1,71 @@
-import { PAGE_TEMPLATES } from "../types/pageTemplates.js";
 export const getLocalizedContent = (field, currentLocale) => {
   if (!field) return "";
   return field[currentLocale] || field["en"] || "";
 };
-export function syncTemplateBlocks(page) {
-  const templateFn = PAGE_TEMPLATES[page.type];
-  if (!templateFn) return page;
-  const idealBlocks = templateFn();
-  const existingTitles = new Set(
-    page.blocks.filter((b) => b.type === "SectionBlock").map((b) => b.props.title)
-  );
-  const missingBlocks = idealBlocks.filter(
-    (b) => b.type === "SectionBlock" && !existingTitles.has(b.props.title)
-  );
-  if (missingBlocks.length > 0) {
-    page.blocks = [...page.blocks, ...missingBlocks];
+export function syncPageWithDefinition(page, definition) {
+  if (!definition) return page;
+  let hasChanged = false;
+  const updatedProperties = {};
+  const definitionGroups = definition.properties;
+  for (const [groupId, definitionGroup] of Object.entries(definitionGroups)) {
+    const existingGroup = page.properties[groupId];
+    const updatedGroupFields = {};
+    for (const [fieldId, definitionField] of Object.entries(definitionGroup.fields)) {
+      if (existingGroup?.fields[fieldId]) {
+        updatedGroupFields[fieldId] = {
+          ...definitionField,
+          value: existingGroup.fields[fieldId].value
+        };
+      } else {
+        updatedGroupFields[fieldId] = { ...definitionField };
+        hasChanged = true;
+      }
+    }
+    updatedProperties[groupId] = {
+      ...definitionGroup,
+      fields: updatedGroupFields
+    };
+    if (!existingGroup) {
+      hasChanged = true;
+    }
+  }
+  if (Object.keys(page.properties).length !== Object.keys(updatedProperties).length) {
+    hasChanged = true;
+  } else {
+    for (const groupId in updatedProperties) {
+      const pageGroup = page.properties[groupId];
+      if (Object.keys(pageGroup?.fields || {}).length !== Object.keys(updatedProperties[groupId].fields).length) {
+        hasChanged = true;
+        break;
+      }
+    }
+  }
+  page.properties = updatedProperties;
+  if (definition.initialBlocks) {
+    const idealBlocks = definition.initialBlocks();
+    const currentBlocks = [...page.blocks];
+    const idealBlocksMap = new Map(idealBlocks.map((b) => [b.id, b]));
+    const filteredCurrent = currentBlocks.filter((b) => {
+      if (!b.isTemplated) return true;
+      return idealBlocksMap.has(b.id);
+    });
+    if (filteredCurrent.length !== currentBlocks.length) {
+      hasChanged = true;
+    }
+    let lastExistingIdealIndex = -1;
+    for (const idealBlock of idealBlocks) {
+      const existingIndex = filteredCurrent.findIndex((b) => b.id === idealBlock.id);
+      if (existingIndex !== -1) {
+        lastExistingIdealIndex = existingIndex;
+      } else {
+        filteredCurrent.splice(lastExistingIdealIndex + 1, 0, { ...idealBlock });
+        lastExistingIdealIndex++;
+        hasChanged = true;
+      }
+    }
+    page.blocks = filteredCurrent;
+  }
+  if (hasChanged) {
     page.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   }
   return page;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rimelight-components",
   "description": "A component library by Rimelight Entertainment.",
-  "version": "2.0.59",
+  "version": "2.0.61",
   "type": "module",
   "repository": {
     "type": "git",
@@ -78,8 +78,10 @@
     "typecheck": "vue-tsc --noEmit && nuxt typecheck",
     "lint": "oxlint .",
     "lint:fix": "oxlint . --fix",
-    "format": "prettier . --check .",
-    "format:fix": "prettier . --write .",
+    "format": "oxfmt --check",
+    "format:fix": "oxfmt .",
+    "check": "bun run typecheck && bun run lint && bun run format",
+    "fix": "bun run lint:fix && bun run format:fix",
     "test": "vitest",
     "release": "release-it --ci"
   },

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

@@ -1,3 +0,0 @@
-import { type Block } from "./blocks.js";
-import { type PageType } from "./pages.js";
-export declare const PAGE_TEMPLATES: Record<PageType, () => Block[]>;

package/dist/runtime/types/pageTemplates.js

@@ -1,170 +0,0 @@
-import { v7 as uuidv7 } from "uuid";
-export const PAGE_TEMPLATES = {
-  Default: () => [],
-  Character: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Appearance", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Abilities", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "History", children: [] }
-    }
-  ],
-  Location: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Geography", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Points of Interest", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "History", children: [] }
-    }
-  ],
-  Species: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Biology", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Culture", children: [] }
-    }
-  ],
-  Object: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Description", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Properties", children: [] }
-    }
-  ],
-  Tale: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Summary", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "The Story", children: [] }
-    }
-  ],
-  Item: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Statistics", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Lore", children: [] }
-    }
-  ],
-  Skill: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Effects", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Acquisition", children: [] }
-    }
-  ],
-  Hero: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Background", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Legacy", children: [] }
-    }
-  ],
-  Card: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Card Art", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Game Mechanics", children: [] }
-    }
-  ],
-  Series: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Synopsis", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "List of Episodes", children: [] }
-    }
-  ],
-  Episode: () => [
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Plot Summary", children: [] }
-    },
-    {
-      id: uuidv7(),
-      type: "SectionBlock",
-      isTemplated: true,
-      props: { level: 2, title: "Characters Appearing", children: [] }
-    }
-  ]
-};