rimelight-components 2.1.1 → 2.1.3

package/dist/module.d.mts

@@ -1,5 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
-export * from '../dist/runtime/types/index.js';
+export * from '../dist/runtime/types/index.mjs';
 
 interface CalloutOptions {
     icon: string;

package/dist/module.d.ts

@@ -0,0 +1,69 @@
+import * as _nuxt_schema from '@nuxt/schema';
+export * from '../dist/runtime/types/index.mjs';
+
+interface CalloutOptions {
+    icon: string;
+    title: string;
+    tooltip: string;
+}
+
+interface ModuleOptions {
+    /**
+     * Prefix for components
+     * @defaultValue `RC`
+     */
+    prefix?: string;
+    callouts: {
+        info: CalloutOptions;
+        success: CalloutOptions;
+        warning: CalloutOptions;
+        error: CalloutOptions;
+        commentary: CalloutOptions;
+        ideation: CalloutOptions;
+        source: CalloutOptions;
+    };
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, {
+    enabled: boolean;
+    prefix: string;
+    callouts: {
+        info: {
+            icon: string;
+            title: string;
+            tooltip: string;
+        };
+        success: {
+            icon: string;
+            title: string;
+            tooltip: string;
+        };
+        warning: {
+            icon: string;
+            title: string;
+            tooltip: string;
+        };
+        error: {
+            icon: string;
+            title: string;
+            tooltip: string;
+        };
+        commentary: {
+            icon: string;
+            title: string;
+            tooltip: string;
+        };
+        ideation: {
+            icon: string;
+            title: string;
+            tooltip: string;
+        };
+        source: {
+            icon: string;
+            title: string;
+            tooltip: string;
+        };
+    };
+}, true>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

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

package/dist/module.mjs

@@ -4,7 +4,7 @@ import { readdirSync } from 'node:fs';
 import { basename } from 'node:path';
 
 const name = "rimelight-components";
-const version = "2.1.1";
+const version = "2.1.3";
 const homepage = "https://rimelight.com/tools/rimelight-components";
 
 const defaultOptions = {
@@ -194,10 +194,10 @@ const module$1 = defineNuxtModule().with({
       prefix: options.prefix ?? void 0,
       global: true
     });
+    nuxt.options.alias["#rimelight"] = resolve("./runtime");
     addImportsDir(resolve("./runtime/composables"));
     addImportsDir(resolve("./runtime/types"));
     addImportsDir(resolve("./runtime/utils"));
-    addServerImportsDir(resolve("./runtime/composables"));
     addServerImportsDir(resolve("./runtime/types"));
     addServerImportsDir(resolve("./runtime/utils"));
     const blockRendererFiles = readdirSync(resolve("./runtime/components/blocks/renderer")).filter(

package/dist/runtime/app.config.mjs

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

package/dist/runtime/composables/index.mjs

@@ -0,0 +1,4 @@
+export * from "./useDateRange.mjs";
+export * from "./usePageEditor.mjs";
+export * from "./useBlockEditor.mjs";
+export * from "./usePageRegistry.mjs";

package/dist/runtime/composables/useBlockEditor.mjs

@@ -0,0 +1,150 @@
+import { computed, ref, shallowRef } from "vue";
+import { v7 as uuidv7 } from "uuid";
+function findBlockLocation(blocks, id) {
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    if (!block) continue;
+    if (block.id === id) {
+      return { parentArray: blocks, index: i };
+    }
+    if ("children" in block.props && Array.isArray(block.props.children)) {
+      const result = findBlockLocation(block.props.children, id);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+function regenerateIds(block) {
+  block.id = uuidv7();
+  if ("children" in block.props && Array.isArray(block.props.children)) {
+    block.props.children.forEach((child) => regenerateIds(child));
+  }
+}
+export function useBlockEditor(initialBlocks, { maxHistorySize = 100, onMutation } = {}) {
+  const history = shallowRef([]);
+  const future = shallowRef([]);
+  const committedBlocks = ref(JSON.parse(JSON.stringify(initialBlocks.value)));
+  const captureSnapshot = () => {
+    const snapshot = JSON.parse(JSON.stringify(initialBlocks.value));
+    future.value = [];
+    const newHistory = [...history.value, snapshot];
+    if (newHistory.length > maxHistorySize) {
+      newHistory.shift();
+    }
+    history.value = newHistory;
+  };
+  const executeMutation = (mutationFn) => {
+    if (onMutation) {
+      onMutation();
+    } else {
+      captureSnapshot();
+    }
+    mutationFn();
+  };
+  const undo = () => {
+    if (history.value.length === 0) return;
+    const currentState = JSON.parse(JSON.stringify(initialBlocks.value));
+    future.value = [currentState, ...future.value];
+    const previousState = history.value[history.value.length - 1];
+    if (previousState) {
+      initialBlocks.value.splice(0, initialBlocks.value.length, ...previousState);
+      const newHistory = [...history.value];
+      newHistory.pop();
+      history.value = newHistory;
+    }
+  };
+  const redo = () => {
+    if (future.value.length === 0) return;
+    const currentState = JSON.parse(JSON.stringify(initialBlocks.value));
+    let newHistory = [...history.value, currentState];
+    if (newHistory.length > maxHistorySize) {
+      newHistory.shift();
+    }
+    history.value = newHistory;
+    const nextState = future.value[0];
+    if (nextState) {
+      initialBlocks.value.splice(0, initialBlocks.value.length, ...nextState);
+      const newFuture = [...future.value];
+      newFuture.shift();
+      future.value = newFuture;
+    }
+  };
+  const canUndo = computed(() => history.value.length > 0);
+  const canRedo = computed(() => future.value.length > 0);
+  const updateBlockProps = (id, newProps) => {
+    executeMutation(() => {
+      const loc = findBlockLocation(initialBlocks.value, id);
+      if (!loc) return;
+      const oldBlock = loc.parentArray[loc.index];
+      if (!oldBlock) return;
+      const newPropsObject = {
+        ...oldBlock.props,
+        ...newProps
+      };
+      const newBlock = {
+        id: oldBlock.id,
+        // Explicitly carry over the required BaseBlock properties
+        type: oldBlock.type,
+        // Explicitly carry over the required BaseBlock properties
+        props: newPropsObject
+      };
+      loc.parentArray.splice(loc.index, 1, newBlock);
+    });
+  };
+  const removeBlock = (id) => {
+    executeMutation(() => {
+      const loc = findBlockLocation(initialBlocks.value, id);
+      if (!loc) return;
+      loc.parentArray.splice(loc.index, 1);
+    });
+  };
+  const moveBlock = (id, direction) => {
+    executeMutation(() => {
+      const loc = findBlockLocation(initialBlocks.value, id);
+      if (!loc) return;
+      const { parentArray, index } = loc;
+      const newIndex = index + direction;
+      if (newIndex >= 0 && newIndex < parentArray.length) {
+        const movedBlock = parentArray.splice(index, 1)[0];
+        if (movedBlock) {
+          parentArray.splice(newIndex, 0, movedBlock);
+        }
+      }
+    });
+  };
+  const duplicateBlock = (id) => {
+    executeMutation(() => {
+      const loc = findBlockLocation(initialBlocks.value, id);
+      if (!loc) return;
+      const original = loc.parentArray[loc.index];
+      const clone = JSON.parse(JSON.stringify(original));
+      regenerateIds(clone);
+      loc.parentArray.splice(loc.index + 1, 0, clone);
+    });
+  };
+  const insertBlock = (newBlockType, targetId = null, position = "after") => {
+    executeMutation(() => {
+    });
+  };
+  const commitChanges = () => {
+    const committedSnapshot = JSON.parse(JSON.stringify(initialBlocks.value));
+    committedBlocks.value = committedSnapshot;
+    return committedSnapshot;
+  };
+  return {
+    // Mutations
+    updateBlockProps,
+    removeBlock,
+    moveBlock,
+    duplicateBlock,
+    insertBlock,
+    // History
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    // State
+    committedBlocks,
+    commitChanges
+  };
+}

package/dist/runtime/composables/useDateRange.mjs

@@ -0,0 +1,55 @@
+import { useState, readonly } from "#imports";
+import { subDays, subMonths, subYears, startOfDay, endOfDay } from "date-fns";
+export function useDateRange() {
+  const dateRange = useState(`feedback-date-range`, () => ({
+    start: subDays(/* @__PURE__ */ new Date(), 30),
+    end: /* @__PURE__ */ new Date()
+  }));
+  const setDateRange = (range) => {
+    dateRange.value = {
+      start: startOfDay(range.start),
+      end: endOfDay(range.end)
+    };
+  };
+  const setPresetRange = (preset) => {
+    const end = /* @__PURE__ */ new Date();
+    let start;
+    switch (preset) {
+      case `week`:
+        start = subDays(end, 7);
+        break;
+      case `month`:
+        start = subDays(end, 30);
+        break;
+      case `3months`:
+        start = subMonths(end, 3);
+        break;
+      case `6months`:
+        start = subMonths(end, 6);
+        break;
+      case `year`:
+        start = subYears(end, 1);
+        break;
+      default:
+        start = subDays(end, 30);
+    }
+    setDateRange({
+      start,
+      end
+    });
+  };
+  const isDateInRange = (date) => {
+    const checkDate = typeof date === `string` ? new Date(date) : date;
+    return checkDate >= dateRange.value.start && checkDate <= dateRange.value.end;
+  };
+  const filterFeedbackByDateRange = (feedback) => {
+    return feedback.filter((item) => isDateInRange(item.createdAt));
+  };
+  return {
+    dateRange: readonly(dateRange),
+    setDateRange,
+    setPresetRange,
+    isDateInRange,
+    filterFeedbackByDateRange
+  };
+}

package/dist/runtime/composables/usePageEditor.mjs

@@ -0,0 +1,45 @@
+import { computed, shallowRef, watch } from "vue";
+export function usePageEditor(page, maxHistorySize = 100) {
+  const history = shallowRef([]);
+  const future = shallowRef([]);
+  const captureSnapshot = () => {
+    const snapshot = JSON.stringify(page.value);
+    if (history.value.length > 0 && history.value[history.value.length - 1] === snapshot) return;
+    future.value = [];
+    const newHistory = [...history.value, snapshot];
+    if (newHistory.length > maxHistorySize) newHistory.shift();
+    history.value = newHistory;
+  };
+  const undo = () => {
+    if (history.value.length === 0) return;
+    future.value = [JSON.stringify(page.value), ...future.value];
+    const previous = JSON.parse(history.value.pop());
+    page.value = previous;
+  };
+  const redo = () => {
+    if (future.value.length === 0) return;
+    history.value = [...history.value, JSON.stringify(page.value)];
+    const next = JSON.parse(future.value.shift());
+    page.value = next;
+  };
+  const canUndo = computed(() => history.value.length > 0);
+  const canRedo = computed(() => future.value.length > 0);
+  const save = () => {
+    return JSON.parse(JSON.stringify(page.value));
+  };
+  watch(
+    () => page.value.properties,
+    () => {
+      captureSnapshot();
+    },
+    { deep: true }
+  );
+  return {
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    save,
+    captureSnapshot
+  };
+}

package/dist/runtime/composables/usePageRegistry.mjs

@@ -0,0 +1,16 @@
+import { reactive, readonly } from "vue";
+const PAGE_DEFINITIONS = reactive({});
+export const usePageRegistry = () => {
+  const registerDefinitions = (definitions) => {
+    Object.assign(PAGE_DEFINITIONS, definitions);
+  };
+  const getTypeLabelKey = (type) => {
+    const definition = PAGE_DEFINITIONS[type];
+    return definition?.typeLabelKey ?? `page.type.${type.toLowerCase()}`;
+  };
+  return {
+    registerDefinitions,
+    getTypeLabelKey,
+    definitions: readonly(PAGE_DEFINITIONS)
+  };
+};

package/dist/runtime/db/index.mjs

@@ -0,0 +1,10 @@
+import { uuid, timestamp } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+export const id = uuid("id").default(sql`uuidv7()`).notNull();
+export const timestamps = {
+  updated_at: timestamp("updated_at", {
+    withTimezone: true
+  }).$onUpdate(() => /* @__PURE__ */ new Date()),
+  created_at: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  deleted_at: timestamp("deleted_at", { withTimezone: true })
+};

package/dist/runtime/internal/blockMapper.mjs

@@ -0,0 +1,29 @@
+import { defineAsyncComponent } from "vue";
+import { BLOCK_RENDERER_COMPONENT_MAP } from "#build/rimelight-block-renderer-map";
+import { BLOCK_EDITOR_COMPONENT_MAP } from "#build/rimelight-block-editor-map";
+export const getBlockRendererComponent = (type) => {
+  const componentImporter = BLOCK_RENDERER_COMPONENT_MAP[type];
+  if (!componentImporter) {
+    console.warn(
+      `[BlockMapper] Block component not found for type: ${type}. Please check block name.`
+    );
+    return void 0;
+  }
+  return defineAsyncComponent(async () => {
+    const module = await componentImporter();
+    return module.default;
+  });
+};
+export const getBlockEditorComponent = (type) => {
+  const componentImporter = BLOCK_EDITOR_COMPONENT_MAP[type];
+  if (!componentImporter) {
+    console.warn(
+      `[EditorBlockMapper] Editor block component not found for type: ${type}. Please check block name.`
+    );
+    return void 0;
+  }
+  return defineAsyncComponent(async () => {
+    const module = await componentImporter();
+    return module.default;
+  });
+};

package/dist/runtime/types/index.mjs

@@ -0,0 +1,3 @@
+export * from "./blocks.mjs";
+export * from "./pages.mjs";
+export * from "./schemas.mjs";

package/dist/runtime/types/schemas.mjs

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export const LocalizedSchema = (schema) => z.record(z.string(), schema);
+export const linkVariantEnum = z.enum(["solid", "outline", "subtle", "soft", "ghost", "link"]);
+export const linkColorEnum = z.enum([
+  "primary",
+  "secondary",
+  "neutral",
+  "error",
+  "warning",
+  "success",
+  "info"
+]);
+export const ImageSchema = z.object({
+  src: z.string().min(1, "Image source must be provided."),
+  alt: z.string().min(1, "Image alt text must be provided."),
+  width: z.number().int().positive().optional(),
+  height: z.number().int().positive().optional(),
+  name: LocalizedSchema(z.string()).optional()
+});
+export const LinkSchema = z.object({
+  label: z.string().min(1, "Link label must be provided."),
+  to: z.url("Link destination must be a valid URL.").min(1, "Link destination must be provided."),
+  icon: z.string().optional(),
+  trailing: z.boolean().optional(),
+  color: linkColorEnum.optional(),
+  variant: linkVariantEnum.optional()
+});

package/dist/runtime/utils/index.js

@@ -1,6 +1,6 @@
 export * from "./richTextHelpers.js";
 export * from "./page.js";
-export * from "./database.js";
+export * from "./database";
 export function slugify(text) {
   if (!text) {
     return "";

package/dist/runtime/utils/index.mjs

@@ -0,0 +1,9 @@
+export * from "./richTextHelpers.mjs";
+export * from "./page.mjs";
+export * from "./database";
+export function slugify(text) {
+  if (!text) {
+    return "";
+  }
+  return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}

package/dist/runtime/utils/page.mjs

@@ -0,0 +1,77 @@
+import { toValue } from "vue";
+export const getLocalizedContent = (field, currentLocale) => {
+  if (!field || typeof field !== "object") return "";
+  const locale = toValue(currentLocale);
+  return field[locale] ?? field["en"] ?? "";
+};
+export function definePageDefinition(def) {
+  return def;
+}
+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.updated_at = /* @__PURE__ */ new Date();
+  }
+  return page;
+}

package/dist/runtime/utils/richTextHelpers.mjs

@@ -0,0 +1,25 @@
+import { v7 as uuidv7 } from "uuid";
+export function richTextToHtml(content) {
+  return content.map((item) => {
+    if (item.type === "text" || item.type === "link") {
+      return item.props.content;
+    }
+    if (item.type === "mention") {
+      return "";
+    }
+    return "";
+  }).join("");
+}
+export function parseHtmlToRichText(html) {
+  if (html.trim().length === 0) {
+    return [];
+  }
+  const newTextNode = {
+    id: uuidv7(),
+    type: "text",
+    props: {
+      content: html.trim()
+    }
+  };
+  return [newTextNode];
+}

package/dist/types.d.mts

@@ -2,4 +2,4 @@ export { default } from './module.mjs'
 
 export { type ModuleOptions } from './module.mjs'
 
-export * from '../dist/runtime/types/index.js'
+export * from '../dist/runtime/types/index.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rimelight-components",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "A component library by Rimelight Entertainment.",
   "keywords": [
     "nuxt",
@@ -32,6 +32,10 @@
     "./utils/*": {
       "types": "./dist/runtime/utils/*.d.mts",
       "import": "./dist/runtime/utils/*.js"
+    },
+    "./db": {
+      "types": "./dist/runtime/utils/db.d.ts",
+      "import": "./dist/runtime/utils/db.js"
     }
   },
   "typesVersions": {