@rimelight/cms 0.0.1 → 0.0.3

package/src/storage/index.ts

@@ -0,0 +1,253 @@
+export interface StorageFile {
+  key: string
+  name: string
+  size: number
+  mimeType: string
+  uploadedAt: string
+  url: string
+  etag?: string
+  customMetadata?: Record<string, string>
+}
+
+export interface StorageListResult {
+  files: StorageFile[]
+  truncated: boolean
+  cursor?: string
+}
+
+export interface R2StorageOptions {
+  binding?: string | undefined
+  publicUrl?: string | undefined
+  prefix?: string | undefined
+}
+
+export interface StorageConfig {
+  provider: "r2" | "local" | "s3"
+  binding?: string | undefined
+  publicUrl?: string | undefined
+  prefix?: string | undefined
+}
+
+export interface StorageListOptions {
+  prefix?: string | undefined
+  cursor?: string | undefined
+  limit?: number | undefined
+  publicUrl?: string | undefined
+  apiBasePath?: string | undefined
+}
+
+export interface StorageUploadOptions {
+  key?: string | undefined
+  prefix?: string | undefined
+  publicUrl?: string | undefined
+  apiBasePath?: string | undefined
+}
+
+export function r2(options: R2StorageOptions = {}): StorageConfig {
+  return {
+    provider: "r2",
+    binding: options.binding ?? "BLOB",
+    publicUrl: options.publicUrl,
+    prefix: options.prefix ?? "media/"
+  }
+}
+
+/**
+ * Resolves Cloudflare R2 bucket instance from Cloudflare env or Astro locals.
+ */
+export async function getR2Bucket(locals?: any, bindingName = "BLOB"): Promise<any> {
+  // 1. Try cloudflare:workers standard export (Astro v6+)
+  try {
+    // @ts-ignore
+    const cf = await import("cloudflare:workers")
+    if (cf?.env && cf.env[bindingName]) {
+      return cf.env[bindingName]
+    }
+  } catch {}
+
+  // 2. Direct locals property check (locals.env or locals[bindingName])
+  if (locals) {
+    if (locals.env && locals.env[bindingName]) {
+      return locals.env[bindingName]
+    }
+    if (locals[bindingName]) {
+      return locals[bindingName]
+    }
+  }
+
+  // 3. Global process.env fallback
+  if (typeof process !== "undefined" && process.env && (process.env as any)[bindingName]) {
+    return (process.env as any)[bindingName]
+  }
+
+  return null
+}
+
+/**
+ * Lists files from R2 Bucket under configured prefix.
+ */
+export async function listR2Files(
+  bucket: any,
+  options: StorageListOptions = {}
+): Promise<StorageListResult> {
+  if (!bucket || typeof bucket.list !== "function") {
+    return { files: [], truncated: false }
+  }
+
+  const prefix = options.prefix ?? "media/"
+  const limit = options.limit ?? 50
+
+  const result = await bucket.list({
+    prefix,
+    cursor: options.cursor,
+    limit
+  })
+
+  const files: StorageFile[] = (result.objects || []).map((obj: any) => {
+    const rawKey = obj.key as string
+    const name = rawKey.startsWith(prefix) ? rawKey.slice(prefix.length) : rawKey
+    const cleanedName = name.includes("/") ? name.split("/").pop()! : name
+    const mimeType = obj.httpMetadata?.contentType || guessMimeType(rawKey)
+
+    // Resolve public URL: custom domain, or proxy endpoint
+    let url = ""
+    if (options.publicUrl) {
+      const baseUrl = options.publicUrl.endsWith("/")
+        ? options.publicUrl.slice(0, -1)
+        : options.publicUrl
+      url = `${baseUrl}/${rawKey}`
+    } else if (options.apiBasePath) {
+      const baseApi = options.apiBasePath.endsWith("/")
+        ? options.apiBasePath.slice(0, -1)
+        : options.apiBasePath
+      url = `${baseApi}/${rawKey}`
+    } else {
+      url = `/cms/api/media/${rawKey}`
+    }
+
+    return {
+      key: rawKey,
+      name: cleanedName,
+      size: obj.size,
+      mimeType,
+      uploadedAt: obj.uploaded ? new Date(obj.uploaded).toISOString() : new Date().toISOString(),
+      url,
+      etag: obj.etag,
+      customMetadata: obj.customMetadata
+    }
+  })
+
+  return {
+    files,
+    truncated: result.truncated,
+    cursor: result.cursor
+  }
+}
+
+/**
+ * Uploads a file buffer/stream into R2 Bucket.
+ */
+export async function uploadR2File(
+  bucket: any,
+  file: File,
+  options: StorageUploadOptions = {}
+): Promise<StorageFile> {
+  if (!bucket || typeof bucket.put !== "function") {
+    throw new Error("R2 bucket binding is not available in runtime environment.")
+  }
+
+  const prefix = options.prefix ?? "media/"
+  const timestamp = Date.now()
+  const safeName = file.name.replace(/[^a-zA-Z0-9._-]/g, "_")
+  const randomSuffix = Math.random().toString(36).substring(2, 8)
+  const key = options.key ?? `${prefix}${timestamp}-${randomSuffix}/${safeName}`
+
+  const arrayBuffer = await file.arrayBuffer()
+
+  const r2Object = await bucket.put(key, arrayBuffer, {
+    httpMetadata: {
+      contentType: file.type || guessMimeType(safeName),
+      contentDisposition: `inline; filename="${safeName}"`
+    },
+    customMetadata: {
+      originalName: file.name,
+      uploadedAt: new Date().toISOString()
+    }
+  })
+
+  let url = ""
+  if (options.publicUrl) {
+    const baseUrl = options.publicUrl.endsWith("/")
+      ? options.publicUrl.slice(0, -1)
+      : options.publicUrl
+    url = `${baseUrl}/${key}`
+  } else if (options.apiBasePath) {
+    const baseApi = options.apiBasePath.endsWith("/")
+      ? options.apiBasePath.slice(0, -1)
+      : options.apiBasePath
+    url = `${baseApi}/${key}`
+  } else {
+    url = `/cms/api/media/${key}`
+  }
+
+  return {
+    key,
+    name: safeName,
+    size: file.size,
+    mimeType: file.type || guessMimeType(safeName),
+    uploadedAt: new Date().toISOString(),
+    url,
+    etag: r2Object?.etag
+  }
+}
+
+/**
+ * Deletes a file from R2 Bucket by key.
+ */
+export async function deleteR2File(bucket: any, key: string): Promise<boolean> {
+  if (!bucket || typeof bucket.delete !== "function") {
+    throw new Error("R2 bucket binding is not available in runtime environment.")
+  }
+  await bucket.delete(key)
+  return true
+}
+
+/**
+ * MIME type guesser fallback.
+ */
+function guessMimeType(filename: string): string {
+  const ext = filename.split(".").pop()?.toLowerCase()
+  switch (ext) {
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg"
+    case "png":
+      return "image/png"
+    case "webp":
+      return "image/webp"
+    case "gif":
+      return "image/gif"
+    case "svg":
+      return "image/svg+xml"
+    case "avif":
+      return "image/avif"
+    case "mp4":
+      return "video/mp4"
+    case "webm":
+      return "video/webm"
+    case "mp3":
+      return "audio/mpeg"
+    case "wav":
+      return "audio/wav"
+    case "pdf":
+      return "application/pdf"
+    case "json":
+      return "application/json"
+    case "txt":
+      return "text/plain"
+    case "zip":
+      return "application/zip"
+    default:
+      return "application/octet-stream"
+  }
+}

package/src/astro/blocks/DialogueBlock.astro

@@ -1,23 +0,0 @@
----
-import type { BaseBlock } from "@rimelight/cms"
-
-interface Props {
-  block: BaseBlock
-  locale?: string
-}
-
-const { block } = Astro.props
-const { character, parenthetical, line } = block.props
----
-
-<div class="my-3 mx-8 max-w-md">
-  <div class="text-sm font-bold text-center text-pink-800 dark:text-pink-200">
-    {character}
-  </div>
-  {parenthetical && (
-    <div class="text-xs italic text-center text-gray-600 dark:text-gray-400 mt-0.5">
-      ({parenthetical})
-    </div>
-  )}
-  <div class="text-sm text-center text-gray-700 dark:text-gray-300 mt-1">{line}</div>
-</div>

package/src/astro/blocks/SceneBlock.astro

@@ -1,65 +0,0 @@
----
-import type { BaseBlock, TimeOfDay, Setting, Transition } from "@rimelight/cms"
-
-interface Props {
-  block: BaseBlock
-  locale?: string
-}
-
-const { block } = Astro.props
-const { location, timeOfDay, setting, transition, description } = block.props
-
-const timeOfDayLabels: Record<TimeOfDay, string> = {
-  MORNING: "Morning",
-  NOON: "Noon",
-  AFTERNOON: "Afternoon",
-  EVENING: "Evening",
-  NIGHT: "Night",
-  OTHER: "Other"
-}
-
-const settingLabels: Record<Setting, string> = { 
-  INTERIOR: "INT.", 
-  EXTERIOR: "EXT.", 
-  OTHER: "Other" 
-}
-
-const transitionLabels: Record<Transition, string> = {
-  CUT_TO: "CUT TO",
-  CUT_BACK_TO: "CUT BACK TO",
-  FADE_TO: "FADE TO",
-  NONE: ""
-}
-
-const settingLabel = settingLabels[setting as Setting] || "Other"
-const todLabel = timeOfDayLabels[timeOfDay as TimeOfDay] || "Other"
-const transitionLabel = transitionLabels[transition as Transition] || ""
-
-const headingParts = []
-if (settingLabel && settingLabel !== "Other") headingParts.push(settingLabel)
-if (location) headingParts.push(location)
-if (todLabel && todLabel !== "Other") headingParts.push(`- ${todLabel}`)
----
-
-<div class="my-4 p-3 border-l-4 border-indigo-400 bg-indigo-50/20 dark:bg-indigo-950/10 rounded-r-lg">
-  <div class="flex flex-wrap items-center gap-2 text-sm font-semibold text-indigo-800 dark:text-indigo-200 mb-2">
-    {headingParts.map((part) => (
-      <span>{part}</span>
-    ))}
-    {transitionLabel && (
-      <span class="ml-auto text-[10px] italic text-gray-600 dark:text-gray-400">
-        {transitionLabel}
-      </span>
-    )}
-  </div>
-  {description && (
-    <p class="text-sm text-gray-700 dark:text-gray-300 mb-2">
-      {description}
-    </p>
-  )}
-  {((block.children && block.children.length > 0) || (block.props?.children && block.props.children.length > 0)) && (
-    <div class="mt-3">
-      <slot />
-    </div>
-  )}
-</div>

package/src/astro/blocks/ScriptBlock.astro

@@ -1,59 +0,0 @@
----
-import type { BaseBlock } from "@rimelight/cms"
-
-interface Props {
-  block: BaseBlock
-  locale?: string
-}
-
-const { block } = Astro.props
-const { title, synopsis, characters, aPlot, bPlot, cPlot, stinger } = block.props
----
-
-<div class="my-6 p-4 border-l-4 border-amber-400 bg-amber-50/20 dark:bg-amber-950/10 rounded-r-lg">
-  <div class="mb-4">
-    <h3 class="text-xl font-bold text-amber-900 dark:text-amber-100">{title}</h3>
-    {synopsis && <p class="text-sm text-gray-600 dark:text-gray-400 mt-1 italic">{synopsis}</p>}
-    {characters && characters.length > 0 && (
-      <div class="flex flex-wrap gap-3 mt-3 text-xs">
-        {characters.map((char: string) => (
-          <span class="px-2 py-0.5 rounded-full bg-amber-100 dark:bg-amber-900/30 text-amber-800 dark:text-amber-200">
-            {char}
-          </span>
-        ))}
-      </div>
-    )}
-  </div>
-  {(aPlot || bPlot || cPlot) && (
-    <div class="grid grid-cols-1 md:grid-cols-3 gap-3 my-3">
-      {aPlot && (
-        <div class="bg-white/50 dark:bg-neutral-900/30 rounded p-2 border border-gray-200 dark:border-gray-700">
-          <div class="text-[10px] font-bold uppercase tracking-wider text-gray-600 dark:text-gray-400">A Plot</div>
-          <div class="text-sm mt-0.5">{aPlot}</div>
-        </div>
-      )}
-      {bPlot && (
-        <div class="bg-white/50 dark:bg-neutral-900/30 rounded p-2 border border-gray-200 dark:border-gray-700">
-          <div class="text-[10px] font-bold uppercase tracking-wider text-gray-600 dark:text-gray-400">B Plot</div>
-          <div class="text-sm mt-0.5">{bPlot}</div>
-        </div>
-      )}
-      {cPlot && (
-        <div class="bg-white/50 dark:bg-neutral-900/30 rounded p-2 border border-gray-200 dark:border-gray-700">
-          <div class="text-[10px] font-bold uppercase tracking-wider text-gray-600 dark:text-gray-400">C Plot</div>
-          <div class="text-sm mt-0.5">{cPlot}</div>
-        </div>
-      )}
-    </div>
-  )}
-  {stinger && (
-    <p class="text-sm text-gray-600 dark:text-gray-400 italic mt-2 border-t border-gray-200 dark:border-gray-700 pt-2">
-      Stinger: {stinger}
-    </p>
-  )}
-  {((block.children && block.children.length > 0) || (block.props?.children && block.props.children.length > 0)) && (
-    <div class="mt-4">
-      <slot />
-    </div>
-  )}
-</div>

package/src/core/template-sync.ts

@@ -1,75 +0,0 @@
-import type { BaseBlock } from "./types/blocks"
-
-/**
- * Merges updated template blocks into an existing page block tree. Matches templated blocks by
- * block `type` + `isTemplated: true` tag and structural index. Fits updated template anchors while
- * preserving user-inserted custom blocks around them.
- */
-export function mergeTemplateBlocks(
-  existingPageBlocks: BaseBlock[],
-  newTemplateBlocks: BaseBlock[]
-): BaseBlock[] {
-  const merged: BaseBlock[] = []
-
-  const newTemplatedAnchors = newTemplateBlocks.filter((b) => b.isTemplated)
-  let existingIndex = 0
-
-  for (const templateAnchor of newTemplatedAnchors) {
-    // Collect user-inserted custom blocks preceding this template anchor
-    while (
-      existingIndex < existingPageBlocks.length &&
-      !existingPageBlocks[existingIndex]?.isTemplated
-    ) {
-      const block = existingPageBlocks[existingIndex]
-      if (block) merged.push(block)
-      existingIndex++
-    }
-
-    // Match existing template anchor by block type
-    const existingAnchor = existingPageBlocks[existingIndex]
-
-    if (existingAnchor && existingAnchor.type === templateAnchor.type) {
-      merged.push({
-        ...templateAnchor,
-        id: existingAnchor.id,
-        props: mergeBlockProps(
-          existingAnchor.props,
-          templateAnchor.props,
-          existingAnchor.templatedProps
-        )
-      })
-      existingIndex++
-    } else {
-      // New template anchor inserted in template update: add fresh block with new random UUID
-      merged.push({
-        ...templateAnchor,
-        id: crypto.randomUUID()
-      })
-    }
-  }
-
-  // Append any remaining custom user blocks at the end of the document
-  while (existingIndex < existingPageBlocks.length) {
-    const block = existingPageBlocks[existingIndex]
-    if (block) merged.push(block)
-    existingIndex++
-  }
-
-  return merged
-}
-
-function mergeBlockProps(
-  existingProps: any,
-  templateProps: any,
-  templatedProps?: boolean | string[]
-) {
-  if (templatedProps === true) return { ...templateProps }
-  if (Array.isArray(templatedProps)) {
-    const updated = { ...existingProps }
-    for (const key of templatedProps) {
-      updated[key] = templateProps[key]
-    }
-    return updated
-  }
-  return { ...existingProps, ...templateProps }
-}