@thinhnguyencth1204/nextcli 0.6.1 → 0.8.0

package/templates/next-base/src/components/rich-text/types.ts

@@ -0,0 +1,60 @@
+import type { SerializedEditorState } from "lexical";
+
+/** Lexical editor state persisted as JSON (API / database). */
+export type LexicalEditorContent = SerializedEditorState;
+
+/** Plain string content for the native textarea adapter. */
+export type TextareaEditorContent = string;
+
+export type EditorVariant = "textarea" | "lexical";
+
+export type EditorContent = LexicalEditorContent | TextareaEditorContent;
+
+export type EditorFieldProps = {
+  /** Switch editor implementation without changing form code. */
+  variant?: EditorVariant;
+  value: EditorContent | null;
+  onChange: (value: EditorContent) => void;
+  /** Called when image URLs disappear from Lexical content (for storage cleanup). */
+  onImagesRemoved?: (removedUrls: string[]) => void;
+  placeholder?: string;
+  disabled?: boolean;
+  readOnly?: boolean;
+  error?: string;
+  className?: string;
+  id?: string;
+  name?: string;
+};
+
+export function isLexicalContent(
+  value: EditorContent | null,
+): value is LexicalEditorContent {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    "root" in value &&
+    typeof value.root === "object"
+  );
+}
+
+export function createEmptyLexicalContent(): LexicalEditorContent {
+  return {
+    root: {
+      children: [
+        {
+          children: [],
+          direction: null,
+          format: "",
+          indent: 0,
+          type: "paragraph",
+          version: 1,
+        },
+      ],
+      direction: null,
+      format: "",
+      indent: 0,
+      type: "root",
+      version: 1,
+    },
+  } as unknown as LexicalEditorContent;
+}

package/templates/next-base/src/hooks/index.ts

@@ -1 +1 @@
-export * from "@/hooks/use-mobile";
+/** Re-export hooks from optional modules here when needed. */

package/templates/next-base/src/lib/rich-text/default-image-removal.ts

@@ -0,0 +1,10 @@
+import type { RemoveManagedImageFn } from "@/lib/rich-text";
+
+/**
+ * Default no-op image remover for base-only projects.
+ * After `nextcli add module supabase`, use
+ * `removeSupabaseManagedImage` from `@/lib/supabase/rich-text-image-sync`.
+ */
+export const defaultRemoveManagedImage: RemoveManagedImageFn = async () => {
+  // Intentionally empty — wire Supabase removal when the module is installed.
+};

package/templates/next-base/src/lib/rich-text/image-urls.ts

@@ -0,0 +1,41 @@
+import type { SerializedEditorState } from "lexical";
+
+type LexicalJsonNode = {
+  type?: string;
+  src?: string;
+  children?: LexicalJsonNode[];
+};
+
+function walkNodes(node: LexicalJsonNode, urls: Set<string>): void {
+  if (node.type === "image" && typeof node.src === "string" && node.src) {
+    urls.add(node.src);
+  }
+
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkNodes(child, urls);
+    }
+  }
+}
+
+export function extractImageUrlsFromState(
+  state: SerializedEditorState | null | undefined,
+): string[] {
+  if (!state?.root) {
+    return [];
+  }
+
+  const urls = new Set<string>();
+  walkNodes(state.root as LexicalJsonNode, urls);
+  return [...urls];
+}
+
+export function diffRemovedImageUrls(
+  previous: SerializedEditorState | null | undefined,
+  next: SerializedEditorState | null | undefined,
+): string[] {
+  const previousUrls = extractImageUrlsFromState(previous);
+  const nextUrls = new Set(extractImageUrlsFromState(next));
+
+  return previousUrls.filter((url) => !nextUrls.has(url));
+}

package/templates/next-base/src/lib/rich-text/index.ts

@@ -0,0 +1,12 @@
+export { diffRemovedImageUrls, extractImageUrlsFromState } from "./image-urls";
+export {
+  isSupabaseManagedImageUrl,
+  parseSupabaseStorageUrl,
+  type SupabaseStorageRef,
+} from "./supabase-url";
+export {
+  syncRemovedRichTextImages,
+  type RemoveManagedImageFn,
+  type SyncRemovedImagesOptions,
+} from "./sync-removed-images";
+export { defaultRemoveManagedImage } from "./default-image-removal";

package/templates/next-base/src/lib/rich-text/supabase-url.ts

@@ -0,0 +1,67 @@
+const DEFAULT_BUCKET =
+  process.env.NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET?.trim() || "public";
+
+export type SupabaseStorageRef = {
+  bucket: string;
+  path: string;
+};
+
+function getConfiguredBucket(): string {
+  return (
+    process.env.NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET?.trim() || DEFAULT_BUCKET
+  );
+}
+
+/**
+ * Maps a Supabase public object URL back to `{ bucket, path }`.
+ * Returns null for external URLs or when Supabase env is not configured.
+ */
+export function parseSupabaseStorageUrl(
+  url: string,
+): SupabaseStorageRef | null {
+  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL?.trim();
+  if (!supabaseUrl) {
+    return null;
+  }
+
+  try {
+    const parsed = new URL(url);
+    const base = new URL(supabaseUrl);
+
+    if (parsed.origin !== base.origin) {
+      return null;
+    }
+
+    const publicPrefix = "/storage/v1/object/public/";
+    if (!parsed.pathname.startsWith(publicPrefix)) {
+      return null;
+    }
+
+    const remainder = parsed.pathname.slice(publicPrefix.length);
+    const slashIndex = remainder.indexOf("/");
+    if (slashIndex <= 0) {
+      return null;
+    }
+
+    const bucket = remainder.slice(0, slashIndex);
+    const path = remainder.slice(slashIndex + 1);
+
+    if (!path) {
+      return null;
+    }
+
+    return { bucket, path };
+  } catch {
+    return null;
+  }
+}
+
+export function isSupabaseManagedImageUrl(url: string): boolean {
+  const ref = parseSupabaseStorageUrl(url);
+  if (!ref) {
+    return false;
+  }
+
+  const configuredBucket = getConfiguredBucket();
+  return ref.bucket === configuredBucket;
+}

package/templates/next-base/src/lib/rich-text/sync-removed-images.ts

@@ -0,0 +1,48 @@
+import type { SerializedEditorState } from "lexical";
+import { diffRemovedImageUrls } from "./image-urls";
+import {
+  isSupabaseManagedImageUrl,
+  parseSupabaseStorageUrl,
+} from "./supabase-url";
+
+export type RemoveManagedImageFn = (
+  url: string,
+  ref: { bucket: string; path: string },
+) => Promise<void>;
+
+export type SyncRemovedImagesOptions = {
+  /** Custom predicate; defaults to Supabase bucket/path URLs for this project. */
+  isManagedUrl?: (url: string) => boolean;
+  /** Injected remover (e.g. Supabase `removeResource`). */
+  removeManagedImage: RemoveManagedImageFn;
+};
+
+/**
+ * Compares previous and next Lexical states, then removes storage objects
+ * for images that disappeared from content. Non-managed URLs are ignored.
+ */
+export async function syncRemovedRichTextImages(
+  previous: SerializedEditorState | null | undefined,
+  next: SerializedEditorState | null | undefined,
+  options: SyncRemovedImagesOptions,
+): Promise<string[]> {
+  const removedUrls = diffRemovedImageUrls(previous, next);
+  const isManaged = options.isManagedUrl ?? isSupabaseManagedImageUrl;
+  const deleted: string[] = [];
+
+  for (const url of removedUrls) {
+    if (!isManaged(url)) {
+      continue;
+    }
+
+    const ref = parseSupabaseStorageUrl(url);
+    if (!ref) {
+      continue;
+    }
+
+    await options.removeManagedImage(url, ref);
+    deleted.push(url);
+  }
+
+  return deleted;
+}

package/templates/next-base/src/types/index.ts

@@ -38,5 +38,3 @@ export type ApiErrorResponse = {
 };
 
 export type ApiResponse<T> = ApiSuccess<T> | ApiErrorResponse;
-
-export * from "@/types/data-table";