@vicacha-devs/strapi-plugin-notes 0.0.0-stage → 1.1.0

package/dist/admin/index-ClQtejgN.js

@@ -0,0 +1,1442 @@
+import * as React from "react";
+import { useRef, useEffect, useState, useCallback } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Dialog, Button, Box, Flex, Badge, Typography, IconButton, Modal, Field, TextInput, SingleSelect, SingleSelectOption, Textarea, Checkbox, Grid, Divider, Loader } from "@strapi/design-system";
+import { WarningCircle, Trash, Pin, Pencil, Check, Plus, File } from "@strapi/icons";
+import { useIntl } from "react-intl";
+import { useFetchClient, useNotification } from "@strapi/strapi/admin";
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+function prefixPluginTranslations(trad, pluginId, options) {
+  if (!pluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  const result = {
+    ...options?.baseTranslations
+  };
+  for (const [key, value] of Object.entries(trad)) {
+    if (options?.keepUnprefixed) {
+      result[key] = value;
+    }
+    const fullKey = key.startsWith(`${pluginId}.`) ? key : `${pluginId}.${key}`;
+    result[fullKey] = value;
+  }
+  return result;
+}
+function createRegisterTrads(options) {
+  const { pluginId, defaultLocales = ["en", "es", "ar", "tr"], supportedLocales, keepUnprefixed = true, loadTranslation, translations, getBaseTranslations, onLoaded } = options;
+  return async function registerTrads({ locales = [] } = {}) {
+    const allLocales = Array.from(/* @__PURE__ */ new Set([...locales, ...defaultLocales]));
+    return Promise.all(allLocales.map(async (locale) => {
+      if (supportedLocales && !supportedLocales.includes(locale)) {
+        return { data: {}, locale };
+      }
+      try {
+        let rawData = translations?.[locale];
+        if (!rawData && loadTranslation) {
+          const loaded = await loadTranslation(locale);
+          rawData = loaded && "default" in loaded && loaded.default ? loaded.default : loaded;
+        }
+        if (!rawData) {
+          return { data: {}, locale };
+        }
+        const prefixed = prefixPluginTranslations(rawData, pluginId, {
+          keepUnprefixed,
+          baseTranslations: getBaseTranslations ? getBaseTranslations(locale) : void 0
+        });
+        onLoaded?.(locale, prefixed);
+        return { data: prefixed, locale };
+      } catch {
+        return { data: {}, locale };
+      }
+    }));
+  };
+}
+const PLUGIN_ID = "notes";
+const NOTE_CATEGORIES = ["general", "todo", "blocker", "idea"];
+const MAX_NOTE_TITLE_LENGTH = 255;
+const MAX_NOTE_CONTENT_LENGTH = 2e4;
+const MAX_ENTITY_SLUG_LENGTH = 160;
+const MAX_ENTITY_ID_LENGTH = 128;
+const MAX_LOCALE_LENGTH = 32;
+const NOTE_CATEGORY_META = {
+  general: {
+    labelKey: "category.general",
+    defaultLabel: "General",
+    badgeBackground: "neutral150",
+    badgeTextColor: "neutral800"
+  },
+  todo: {
+    labelKey: "category.todo",
+    defaultLabel: "Todo",
+    badgeBackground: "primary100",
+    badgeTextColor: "primary700"
+  },
+  blocker: {
+    labelKey: "category.blocker",
+    defaultLabel: "Blocker",
+    badgeBackground: "danger100",
+    badgeTextColor: "danger700"
+  },
+  idea: {
+    labelKey: "category.idea",
+    defaultLabel: "Idea",
+    badgeBackground: "success100",
+    badgeTextColor: "success700"
+  }
+};
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef(setPlugin);
+  useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const ENTITY_SLUG_PATTERN = /^[a-zA-Z0-9_:.-]{1,160}$/;
+const SAFE_ID_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+const LOCALE_PATTERN = /^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8}){0,4}$/;
+const FORBIDDEN_IDENTIFIER_TOKENS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isForbiddenIdentifier(value) {
+  const lower = value.toLowerCase();
+  if (FORBIDDEN_IDENTIFIER_TOKENS.has(lower)) return true;
+  if (value === "." || value === ".." || value.includes("..") || value.startsWith(".") || value.endsWith(".")) {
+    return true;
+  }
+  return lower.split(/[:./]+/).some((segment) => FORBIDDEN_IDENTIFIER_TOKENS.has(segment));
+}
+function toPositiveSafeInt(input) {
+  if (typeof input !== "number" || !Number.isFinite(input)) return null;
+  const truncated = Math.trunc(input);
+  return Number.isSafeInteger(truncated) && truncated >= 1 ? truncated : null;
+}
+function isValidNoteCategory(value) {
+  return typeof value === "string" && NOTE_CATEGORIES.includes(value);
+}
+function normalizeNoteCategory(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (isValidNoteCategory(normalized)) return normalized;
+  }
+  return "general";
+}
+function sanitizePlainText(input, maxLength) {
+  if (typeof input !== "string") return "";
+  const cleaned = input.replace(/\0/g, "").replace(/\r\n/g, "\n").trim();
+  return cleaned.length > maxLength ? cleaned.slice(0, maxLength) : cleaned;
+}
+function sanitizeEntitySlug(input) {
+  if (typeof input !== "string" || input.includes("\0")) return "";
+  const cleaned = input.trim();
+  if (!cleaned || cleaned.length > MAX_ENTITY_SLUG_LENGTH || isForbiddenIdentifier(cleaned) || !ENTITY_SLUG_PATTERN.test(cleaned)) {
+    return "";
+  }
+  return cleaned;
+}
+function sanitizeEntityDocumentId(input) {
+  const numeric = toPositiveSafeInt(input);
+  if (numeric !== null) return String(numeric);
+  if (typeof input !== "string" || input.includes("\0")) return "";
+  const cleaned = input.trim();
+  if (!cleaned || cleaned.length > MAX_ENTITY_ID_LENGTH || isForbiddenIdentifier(cleaned) || !SAFE_ID_PATTERN.test(cleaned)) {
+    return "";
+  }
+  return cleaned;
+}
+function parseStringEntityId(input) {
+  if (input.includes("\0")) return null;
+  const trimmed = input.trim();
+  if (!trimmed || trimmed.length > MAX_ENTITY_ID_LENGTH || isForbiddenIdentifier(trimmed)) {
+    return null;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+  return SAFE_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function sanitizeEntityId(input) {
+  const numeric = toPositiveSafeInt(input);
+  if (numeric !== null) {
+    return numeric;
+  }
+  if (typeof input === "string") {
+    return parseStringEntityId(input);
+  }
+  return null;
+}
+function isWildcardOrInvalidLocale(cleaned) {
+  if (!cleaned || cleaned === "all" || cleaned === "*") {
+    return true;
+  }
+  return cleaned.length > MAX_LOCALE_LENGTH || isForbiddenIdentifier(cleaned);
+}
+function sanitizeEntityLocale(input) {
+  if (typeof input !== "string" || input.includes("\0")) {
+    return null;
+  }
+  const cleaned = input.trim();
+  if (isWildcardOrInvalidLocale(cleaned)) {
+    return null;
+  }
+  return LOCALE_PATTERN.test(cleaned) ? cleaned : null;
+}
+function extractPrimitiveAuthorId(rawUser) {
+  const numeric = toPositiveSafeInt(rawUser);
+  if (numeric !== null) {
+    return numeric;
+  }
+  if (typeof rawUser === "string" && rawUser.trim()) {
+    return sanitizeEntityDocumentId(rawUser) || null;
+  }
+  return null;
+}
+function sanitizePrimitiveAuthor(rawUser, fallback) {
+  const primitiveId = extractPrimitiveAuthorId(rawUser);
+  if (!fallback && primitiveId === null) {
+    return null;
+  }
+  return {
+    id: primitiveId,
+    firstname: "",
+    lastname: "",
+    username: "",
+    displayName: fallback || `#${String(primitiveId)}`
+  };
+}
+function asPlainObject(value, fallback) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : fallback;
+}
+function unwrapAuthorRecord(rawUser) {
+  const nestedData = asPlainObject(rawUser.data, rawUser);
+  const attrs = asPlainObject(nestedData.attributes, nestedData);
+  const id = extractPrimitiveAuthorId(nestedData.id ?? rawUser.id);
+  return { attrs, id };
+}
+function sanitizeNoteAuthor(rawUser, fallbackDisplayName) {
+  const fallback = sanitizePlainText(fallbackDisplayName, 120);
+  if (!rawUser || typeof rawUser !== "object" || Array.isArray(rawUser)) {
+    return sanitizePrimitiveAuthor(rawUser, fallback);
+  }
+  const { attrs, id } = unwrapAuthorRecord(rawUser);
+  const firstname = sanitizePlainText(attrs.firstname, 80);
+  const lastname = sanitizePlainText(attrs.lastname, 80);
+  const username = sanitizePlainText(attrs.username, 80);
+  const explicitDisplayName = sanitizePlainText(attrs.displayName, 120);
+  const fullName = [firstname, lastname].filter(Boolean).join(" ").trim();
+  const displayName = fullName || username || explicitDisplayName || fallback || "";
+  if (!displayName && id === null) {
+    return null;
+  }
+  return {
+    id,
+    firstname,
+    lastname,
+    username,
+    displayName: displayName || `#${String(id)}`
+  };
+}
+function formatNoteAuthorDisplay(author, emptyFallback = "-") {
+  if (!author) {
+    return emptyFallback;
+  }
+  const fullName = [author.firstname, author.lastname].filter(Boolean).join(" ").trim();
+  if (fullName) {
+    return fullName;
+  }
+  if (author.username && author.username.trim()) {
+    return author.username.trim();
+  }
+  if (author.displayName && author.displayName.trim()) {
+    return author.displayName.trim();
+  }
+  return emptyFallback;
+}
+function formatNoteTimestamp(isoString, locale = "en", emptyFallback = "-") {
+  if (!isoString || typeof isoString !== "string") {
+    return emptyFallback;
+  }
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) {
+    return emptyFallback;
+  }
+  try {
+    return new Intl.DateTimeFormat(locale || "en", {
+      dateStyle: "medium",
+      timeStyle: "short"
+    }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}
+function extractRecordId(root, attrs) {
+  if (typeof root.id === "number" && Number.isFinite(root.id) || typeof root.id === "string") {
+    return root.id;
+  }
+  if (typeof attrs.id === "number" && Number.isFinite(attrs.id) || typeof attrs.id === "string") {
+    return attrs.id;
+  }
+  return "";
+}
+function sanitizeOptionalIsoString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function unwrapRawNoteAttributes(raw) {
+  const root = asPlainObject(raw, {});
+  const rawAttrs = asPlainObject(root.attributes, {});
+  const attrs = { ...root, ...rawAttrs };
+  return { root, attrs };
+}
+function normalizeNoteRecord(raw) {
+  const { root, attrs } = unwrapRawNoteAttributes(raw);
+  const id = extractRecordId(root, attrs);
+  const documentId = sanitizeEntityDocumentId(root.documentId ?? attrs.documentId) || String(id || "");
+  const entityId = sanitizeEntityId(attrs.entityId);
+  const entityDocumentId = sanitizeEntityDocumentId(attrs.entityDocumentId) || (entityId !== null ? String(entityId) : "");
+  const createdBy = sanitizeNoteAuthor(
+    attrs.createdBy,
+    attrs.createdByName ?? attrs.authorName
+  );
+  const updatedBy = sanitizeNoteAuthor(attrs.updatedBy, attrs.updatedByName) ?? createdBy;
+  const createdAt = sanitizeOptionalIsoString(attrs.createdAt);
+  const updatedAt = sanitizeOptionalIsoString(attrs.updatedAt) ?? createdAt;
+  const normalizedAttributes = {
+    title: sanitizePlainText(attrs.title, MAX_NOTE_TITLE_LENGTH),
+    content: sanitizePlainText(attrs.content, MAX_NOTE_CONTENT_LENGTH),
+    category: normalizeNoteCategory(attrs.category),
+    isPinned: Boolean(attrs.isPinned),
+    entitySlug: sanitizeEntitySlug(attrs.entitySlug),
+    entityId,
+    entityDocumentId,
+    entityLocale: sanitizeEntityLocale(attrs.entityLocale),
+    createdAt,
+    updatedAt,
+    createdBy,
+    updatedBy
+  };
+  return {
+    id,
+    documentId,
+    ...normalizedAttributes,
+    attributes: normalizedAttributes
+  };
+}
+function sortNotesPinnedFirst(notes, direction = "DESC") {
+  return [...notes].sort((a, b) => {
+    if (a.isPinned !== b.isPinned) {
+      return a.isPinned ? -1 : 1;
+    }
+    const timeA = a.createdAt ? Date.parse(a.createdAt) : 0;
+    const timeB = b.createdAt ? Date.parse(b.createdAt) : 0;
+    if (timeA !== timeB && !Number.isNaN(timeA) && !Number.isNaN(timeB)) {
+      return direction === "ASC" ? timeA - timeB : timeB - timeA;
+    }
+    return String(a.id).localeCompare(String(b.id));
+  });
+}
+function matchesEntityIdentifier(note, docIdFilter, entityIdFilter) {
+  if (!docIdFilter && entityIdFilter === null) {
+    return true;
+  }
+  const noteIdStr = note.entityId !== null ? String(note.entityId) : "";
+  if (docIdFilter) {
+    if (note.entityDocumentId === docIdFilter || noteIdStr === docIdFilter) {
+      return true;
+    }
+  }
+  if (entityIdFilter !== null) {
+    const filterStr = String(entityIdFilter);
+    if (noteIdStr === filterStr || note.entityDocumentId === filterStr) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesLocaleFilter(note, localeFilter, includeAllLocales) {
+  if (!localeFilter || includeAllLocales) {
+    return true;
+  }
+  return !note.entityLocale || note.entityLocale === localeFilter;
+}
+function matchesSearchFilter(note, searchFilter) {
+  if (!searchFilter) {
+    return true;
+  }
+  const haystack = [
+    note.title,
+    note.content,
+    note.entitySlug,
+    note.createdBy?.displayName ?? "",
+    note.updatedBy?.displayName ?? ""
+  ].join(" ").toLowerCase();
+  return haystack.includes(searchFilter);
+}
+function matchesAllNoteFilters(note, filters) {
+  if (filters.slugFilter && note.entitySlug !== filters.slugFilter) {
+    return false;
+  }
+  if (!matchesEntityIdentifier(note, filters.docIdFilter, filters.entityIdFilter)) {
+    return false;
+  }
+  if (!matchesLocaleFilter(note, filters.localeFilter, filters.includeAllLocales)) {
+    return false;
+  }
+  if (filters.categoryFilter && note.category !== filters.categoryFilter) {
+    return false;
+  }
+  if (typeof filters.isPinned === "boolean" && note.isPinned !== filters.isPinned) {
+    return false;
+  }
+  return matchesSearchFilter(note, filters.searchFilter);
+}
+function filterNotesList(notes, params = {}) {
+  const filters = {
+    slugFilter: params.entitySlug ? sanitizeEntitySlug(params.entitySlug) : "",
+    docIdFilter: params.entityDocumentId ? sanitizeEntityDocumentId(params.entityDocumentId) : "",
+    entityIdFilter: params.entityId !== void 0 && params.entityId !== null ? sanitizeEntityId(params.entityId) : null,
+    localeFilter: sanitizeEntityLocale(params.entityLocale),
+    includeAllLocales: params.includeAllLocales,
+    categoryFilter: params.category && params.category !== "all" ? normalizeNoteCategory(params.category) : null,
+    isPinned: params.isPinned,
+    searchFilter: sanitizePlainText(params.search, 160).toLowerCase()
+  };
+  const filtered = notes.filter((note) => matchesAllNoteFilters(note, filters));
+  const sorted = sortNotesPinnedFirst(filtered, params.sort ?? "DESC");
+  const offset = typeof params.offset === "number" && Number.isFinite(params.offset) && params.offset > 0 ? Math.trunc(params.offset) : 0;
+  const limit = typeof params.limit === "number" && Number.isFinite(params.limit) && params.limit > 0 ? Math.trunc(params.limit) : void 0;
+  if (offset > 0 || limit !== void 0) {
+    return sorted.slice(
+      offset,
+      limit !== void 0 ? offset + limit : void 0
+    );
+  }
+  return sorted;
+}
+function computeNotesSummaryStats(notes) {
+  const byCategory = {
+    general: 0,
+    todo: 0,
+    blocker: 0,
+    idea: 0
+  };
+  let pinned = 0;
+  const slugSet = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    if (note.isPinned) {
+      pinned += 1;
+    }
+    const cat = normalizeNoteCategory(note.category);
+    byCategory[cat] += 1;
+    if (note.entitySlug) {
+      slugSet.add(note.entitySlug);
+    }
+  }
+  return {
+    total: notes.length,
+    pinned,
+    byCategory,
+    entitySlugs: Array.from(slugSet).sort()
+  };
+}
+function buildContentManagerNoteLink(note) {
+  const slug = sanitizeEntitySlug(note.entitySlug);
+  const targetId = sanitizeEntityDocumentId(note.entityDocumentId) || (note.entityId !== null && note.entityId !== void 0 ? sanitizeEntityDocumentId(String(note.entityId)) : "");
+  const isSingleType = note.collectionType === "single-types" || note.collectionType === "singleType" || targetId === "single";
+  if (!slug || !isSingleType && !targetId) {
+    return null;
+  }
+  const basePath = isSingleType ? `/content-manager/single-types/${encodeURIComponent(slug)}` : `/content-manager/collection-types/${encodeURIComponent(
+    slug
+  )}/${encodeURIComponent(targetId)}`;
+  const locale = sanitizeEntityLocale(note.entityLocale);
+  if (locale) {
+    return `${basePath}?plugins[i18n][locale]=${encodeURIComponent(locale)}`;
+  }
+  return basePath;
+}
+const getTrad = (id) => `${PLUGIN_ID}.${id}`;
+function formatEntityIdParam(entityId) {
+  if (entityId === void 0 || entityId === null || entityId === "") {
+    return "";
+  }
+  return String(entityId);
+}
+function formatOptionalIntParam(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? String(Math.trunc(value)) : void 0;
+}
+function buildNotesQueryString(params = {}) {
+  const entries = [
+    ["entitySlug", params.entitySlug],
+    ["entityDocumentId", params.entityDocumentId],
+    ["entityId", formatEntityIdParam(params.entityId)],
+    ["entityLocale", params.entityLocale ?? void 0],
+    ["includeAllLocales", params.includeAllLocales ? "true" : void 0],
+    [
+      "category",
+      params.category && params.category !== "all" ? params.category : void 0
+    ],
+    [
+      "isPinned",
+      typeof params.isPinned === "boolean" ? String(params.isPinned) : void 0
+    ],
+    ["search", params.search],
+    ["sort", params.sort],
+    ["limit", formatOptionalIntParam(params.limit)],
+    ["offset", formatOptionalIntParam(params.offset)]
+  ];
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of entries) {
+    if (value) {
+      searchParams.set(key, value);
+    }
+  }
+  const qs = searchParams.toString();
+  return qs ? `?${qs}` : "";
+}
+function matchesNoteIdentifier(note, targetId) {
+  const cleanTarget = String(targetId);
+  return String(note.id) === cleanTarget || String(note.documentId) === cleanTarget;
+}
+function useNotes(initialParams = {}) {
+  const { get, post, put, del } = useFetchClient();
+  const { toggleNotification } = useNotification();
+  const { formatMessage } = useIntl();
+  const [notes, setNotes] = useState([]);
+  const [summary, setSummary] = useState(
+    () => computeNotesSummaryStats([])
+  );
+  const [isLoading, setIsLoading] = useState(false);
+  const [isMutating, setIsMutating] = useState(false);
+  const requestIdRef = useRef(0);
+  const pendingMutationsRef = useRef(0);
+  const notesRef = useRef([]);
+  const beginMutation = useCallback(() => {
+    pendingMutationsRef.current += 1;
+    setIsMutating(true);
+  }, []);
+  const endMutation = useCallback(() => {
+    pendingMutationsRef.current = Math.max(0, pendingMutationsRef.current - 1);
+    if (pendingMutationsRef.current === 0) {
+      setIsMutating(false);
+    }
+  }, []);
+  const t = useCallback(
+    (id, defaultMessage) => formatMessage({ id: getTrad(id), defaultMessage }),
+    [formatMessage]
+  );
+  const applyLocalNotesState = useCallback(
+    (updater) => {
+      const next = sortNotesPinnedFirst(
+        updater(notesRef.current),
+        initialParams.sort ?? "DESC"
+      );
+      notesRef.current = next;
+      setNotes(next);
+      setSummary(computeNotesSummaryStats(next));
+    },
+    [initialParams.sort]
+  );
+  const fetchNotes = useCallback(
+    async (overrideParams) => {
+      const requestId = ++requestIdRef.current;
+      const merged = { ...initialParams, ...overrideParams };
+      setIsLoading(true);
+      try {
+        const qs = buildNotesQueryString(merged);
+        const res = await get(`/${PLUGIN_ID}/notes${qs}`);
+        const rawItems = Array.isArray(res?.data?.data) ? res.data.data : [];
+        const normalized = rawItems.map((item) => normalizeNoteRecord(item));
+        if (requestId === requestIdRef.current) {
+          notesRef.current = normalized;
+          setNotes(normalized);
+          setSummary(
+            res?.data?.meta?.summary ?? computeNotesSummaryStats(normalized)
+          );
+        }
+        return normalized;
+      } catch {
+        if (requestId === requestIdRef.current) {
+          toggleNotification({
+            type: "warning",
+            message: t("notes.notification.loadError", "Unable to load notes.")
+          });
+        }
+        return [];
+      } finally {
+        if (requestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [
+      get,
+      initialParams.category,
+      initialParams.entityDocumentId,
+      initialParams.entityId,
+      initialParams.entityLocale,
+      initialParams.entitySlug,
+      initialParams.includeAllLocales,
+      initialParams.isPinned,
+      initialParams.limit,
+      initialParams.offset,
+      initialParams.search,
+      initialParams.sort,
+      t,
+      toggleNotification
+    ]
+  );
+  useEffect(() => {
+    void fetchNotes();
+    return () => {
+      requestIdRef.current += 1;
+    };
+  }, [fetchNotes]);
+  const createNote = useCallback(
+    async (payload) => {
+      beginMutation();
+      try {
+        const res = await post(`/${PLUGIN_ID}/notes`, {
+          data: payload
+        });
+        const created = res?.data?.data ? normalizeNoteRecord(res.data.data) : null;
+        if (created) {
+          applyLocalNotesState((prev) => [created, ...prev]);
+        }
+        toggleNotification({
+          type: "success",
+          message: t(
+            "notes.notification.created",
+            "Note has been successfully created."
+          )
+        });
+        await fetchNotes();
+        return created;
+      } catch {
+        toggleNotification({
+          type: "warning",
+          message: t(
+            "notes.notification.createError",
+            "Failed to create note."
+          )
+        });
+        return null;
+      } finally {
+        endMutation();
+      }
+    },
+    [
+      applyLocalNotesState,
+      beginMutation,
+      endMutation,
+      fetchNotes,
+      post,
+      t,
+      toggleNotification
+    ]
+  );
+  const updateNote = useCallback(
+    async (id, body) => {
+      beginMutation();
+      try {
+        const res = await put(
+          `/${PLUGIN_ID}/notes/${encodeURIComponent(String(id))}`,
+          { data: body }
+        );
+        const updated = res?.data?.data ? normalizeNoteRecord(res.data.data) : null;
+        if (updated) {
+          applyLocalNotesState(
+            (prev) => prev.map(
+              (item) => matchesNoteIdentifier(item, id) ? updated : item
+            )
+          );
+        }
+        toggleNotification({
+          type: "success",
+          message: t(
+            "notes.notification.updated",
+            "Note has been successfully updated."
+          )
+        });
+        await fetchNotes();
+        return updated;
+      } catch {
+        toggleNotification({
+          type: "warning",
+          message: t(
+            "notes.notification.updateError",
+            "Failed to update note."
+          )
+        });
+        return null;
+      } finally {
+        endMutation();
+      }
+    },
+    [
+      applyLocalNotesState,
+      beginMutation,
+      endMutation,
+      fetchNotes,
+      put,
+      t,
+      toggleNotification
+    ]
+  );
+  const deleteNote = useCallback(
+    async (id) => {
+      beginMutation();
+      try {
+        await del(`/${PLUGIN_ID}/notes/${encodeURIComponent(String(id))}`);
+        applyLocalNotesState(
+          (prev) => prev.filter((item) => !matchesNoteIdentifier(item, id))
+        );
+        toggleNotification({
+          type: "success",
+          message: t(
+            "notes.notification.deleted",
+            "Note has been successfully deleted."
+          )
+        });
+        await fetchNotes();
+        return true;
+      } catch {
+        toggleNotification({
+          type: "warning",
+          message: t(
+            "notes.notification.deleteError",
+            "Failed to delete note."
+          )
+        });
+        return false;
+      } finally {
+        endMutation();
+      }
+    },
+    [
+      applyLocalNotesState,
+      beginMutation,
+      del,
+      endMutation,
+      fetchNotes,
+      t,
+      toggleNotification
+    ]
+  );
+  return {
+    notes,
+    summary,
+    isLoading,
+    isMutating,
+    refetch: fetchNotes,
+    createNote,
+    updateNote,
+    deleteNote
+  };
+}
+const DeleteNoteDialog = ({
+  note,
+  isSubmitting = false,
+  onCancel,
+  onConfirm
+}) => {
+  const { formatMessage } = useIntl();
+  if (!note) {
+    return null;
+  }
+  const t = (id, defaultMessage, values) => formatMessage({ id: getTrad(id), defaultMessage }, values);
+  return /* @__PURE__ */ jsx(
+    Dialog.Root,
+    {
+      open: Boolean(note),
+      onOpenChange: (open) => !open && onCancel(),
+      children: /* @__PURE__ */ jsxs(Dialog.Content, { children: [
+        /* @__PURE__ */ jsx(Dialog.Header, { children: t("note.delete.dialog.title", "Confirmation") }),
+        /* @__PURE__ */ jsx(Dialog.Body, { icon: /* @__PURE__ */ jsx(WarningCircle, {}), children: t(
+          "note.delete.dialog.description",
+          'Are you sure you want to delete the note "{title}"?',
+          { title: note.title }
+        ) }),
+        /* @__PURE__ */ jsxs(Dialog.Footer, { children: [
+          /* @__PURE__ */ jsx(Dialog.Cancel, { children: /* @__PURE__ */ jsx(Button, { fullWidth: true, variant: "tertiary", onClick: onCancel, children: t("note.modal.actions.cancel", "Cancel") }) }),
+          /* @__PURE__ */ jsx(Dialog.Action, { children: /* @__PURE__ */ jsx(
+            Button,
+            {
+              fullWidth: true,
+              variant: "danger-light",
+              startIcon: /* @__PURE__ */ jsx(Trash, {}),
+              loading: isSubmitting,
+              disabled: isSubmitting,
+              onClick: () => onConfirm(note),
+              children: t("note.delete.dialog.confirm", "Confirm")
+            }
+          ) })
+        ] })
+      ] })
+    }
+  );
+};
+const NoteListItem = ({
+  note,
+  onEdit,
+  onRequestDelete,
+  onTogglePin
+}) => {
+  const { formatMessage, locale } = useIntl();
+  const t = (id, defaultMessage) => formatMessage({ id: getTrad(id), defaultMessage });
+  const categoryMeta = NOTE_CATEGORY_META[note.category] ?? NOTE_CATEGORY_META.general;
+  const authorLabel = formatNoteAuthorDisplay(
+    note.updatedBy ?? note.createdBy,
+    ""
+  );
+  const timestampLabel = formatNoteTimestamp(
+    note.updatedAt ?? note.createdAt,
+    locale,
+    ""
+  );
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      hasRadius: true,
+      padding: 3,
+      background: "neutral0",
+      borderStyle: "solid",
+      borderWidth: "1px",
+      borderColor: note.isPinned ? "primary600" : "neutral150",
+      shadow: "tableShadow",
+      tag: "article",
+      children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 1, children: [
+        /* @__PURE__ */ jsxs(Flex, { gap: 2, justifyContent: "space-between", alignItems: "center", children: [
+          /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", style: { minWidth: 0, flex: 1 }, children: [
+            /* @__PURE__ */ jsx(
+              Badge,
+              {
+                backgroundColor: categoryMeta.badgeBackground,
+                textColor: categoryMeta.badgeTextColor,
+                children: t(categoryMeta.labelKey, categoryMeta.defaultLabel)
+              }
+            ),
+            note.entityLocale && /* @__PURE__ */ jsx(Badge, { backgroundColor: "neutral100", textColor: "neutral700", children: note.entityLocale.toUpperCase() }),
+            /* @__PURE__ */ jsx(
+              Typography,
+              {
+                variant: "pi",
+                textColor: "neutral800",
+                fontWeight: "bold",
+                ellipsis: true,
+                role: "button",
+                tabIndex: 0,
+                style: { cursor: "pointer" },
+                onClick: () => onEdit(note),
+                onKeyDown: (e) => {
+                  if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    onEdit(note);
+                  }
+                },
+                children: note.title
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { gap: 1, alignItems: "center", children: [
+            /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                withTooltip: false,
+                variant: note.isPinned ? "secondary" : "ghost",
+                onClick: () => onTogglePin(note),
+                label: note.isPinned ? t("note.actions.unpin", "Unpin note") : t("note.actions.pin", "Pin note"),
+                children: /* @__PURE__ */ jsx(Pin, {})
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                withTooltip: false,
+                variant: "ghost",
+                onClick: () => onEdit(note),
+                label: t("note.actions.edit", "Edit"),
+                children: /* @__PURE__ */ jsx(Pencil, {})
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                withTooltip: false,
+                variant: "ghost",
+                onClick: () => onRequestDelete(note),
+                label: t("note.actions.delete", "Delete"),
+                children: /* @__PURE__ */ jsx(Trash, {})
+              }
+            )
+          ] })
+        ] }),
+        (authorLabel || timestampLabel) && /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral500", ellipsis: true, children: [authorLabel, timestampLabel].filter(Boolean).join(" • ") })
+      ] })
+    }
+  );
+};
+function resolveNormalizedExisting(note) {
+  if (!note) return null;
+  const hasId = Boolean(note.id || note.documentId);
+  return hasId ? normalizeNoteRecord(note) : null;
+}
+function resolveEntityDocumentId(existingDocId, entity) {
+  if (existingDocId) return existingDocId;
+  if (entity.documentId) return entity.documentId;
+  if (entity.id !== null && entity.id !== void 0) return String(entity.id);
+  return "";
+}
+function buildNoteSavePayload(params) {
+  const {
+    trimmedTitle,
+    content,
+    category,
+    isPinned,
+    scopeToLocale,
+    effectiveLocale,
+    normalizedExisting,
+    entity
+  } = params;
+  return {
+    title: trimmedTitle,
+    content: content.trim(),
+    category: normalizeNoteCategory(category),
+    isPinned,
+    entitySlug: normalizedExisting?.entitySlug || entity.slug,
+    entityId: normalizedExisting?.entityId ?? entity.id ?? null,
+    entityDocumentId: resolveEntityDocumentId(
+      normalizedExisting?.entityDocumentId,
+      entity
+    ),
+    entityLocale: scopeToLocale ? effectiveLocale : null
+  };
+}
+const NoteMetadataBox = ({
+  note,
+  uiLocale,
+  t
+}) => /* @__PURE__ */ jsx(
+  Box,
+  {
+    padding: 4,
+    background: "neutral100",
+    hasRadius: true,
+    "data-testid": "note-modal-meta-box",
+    children: /* @__PURE__ */ jsxs(Grid.Root, { gap: 4, children: [
+      /* @__PURE__ */ jsx(Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.createdAt", "Created At") }),
+        /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral800", children: formatNoteTimestamp(note.createdAt, uiLocale) })
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.createdBy", "Created By") }),
+        /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral800", children: formatNoteAuthorDisplay(note.createdBy) })
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.updatedAt", "Updated At") }),
+        /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral800", children: formatNoteTimestamp(note.updatedAt, uiLocale) })
+      ] }) }),
+      /* @__PURE__ */ jsx(Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.updatedBy", "Updated By") }),
+        /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral800", children: formatNoteAuthorDisplay(note.updatedBy) })
+      ] }) })
+    ] })
+  }
+);
+const NoteModal = ({
+  entity,
+  note,
+  isOpen,
+  isSubmitting = false,
+  onClose,
+  onSubmit
+}) => {
+  const { formatMessage, locale: uiLocale } = useIntl();
+  const normalizedExisting = React.useMemo(
+    () => resolveNormalizedExisting(note),
+    [note]
+  );
+  const isExistingNote = Boolean(normalizedExisting);
+  const [title, setTitle] = React.useState("");
+  const [content, setContent] = React.useState("");
+  const [category, setCategory] = React.useState("general");
+  const [isPinned, setIsPinned] = React.useState(false);
+  const [scopeToLocale, setScopeToLocale] = React.useState(false);
+  const [titleError, setTitleError] = React.useState("");
+  const lastInitKeyRef = React.useRef(null);
+  const noteIdentityKey = normalizedExisting ? String(normalizedExisting.id || normalizedExisting.documentId) : "new";
+  React.useEffect(() => {
+    if (!isOpen) {
+      lastInitKeyRef.current = null;
+      return;
+    }
+    if (lastInitKeyRef.current === noteIdentityKey) {
+      return;
+    }
+    lastInitKeyRef.current = noteIdentityKey;
+    setTitle(normalizedExisting?.title ?? "");
+    setContent(normalizedExisting?.content ?? "");
+    setCategory(normalizedExisting?.category ?? "general");
+    setIsPinned(Boolean(normalizedExisting?.isPinned));
+    setScopeToLocale(Boolean(normalizedExisting?.entityLocale));
+    setTitleError("");
+  }, [isOpen, noteIdentityKey, normalizedExisting]);
+  const t = (id, defaultMessage, values) => formatMessage({ id: getTrad(id), defaultMessage }, values);
+  const effectiveLocale = normalizedExisting?.entityLocale || sanitizeEntityLocale(entity.locale) || null;
+  const handleSave = async () => {
+    if (isSubmitting) {
+      return;
+    }
+    const trimmedTitle = title.trim();
+    if (!trimmedTitle) {
+      setTitleError(
+        t("note.modal.validation.titleRequired", "Title is required.")
+      );
+      return;
+    }
+    setTitleError("");
+    const payload = buildNoteSavePayload({
+      trimmedTitle,
+      content,
+      category,
+      isPinned,
+      scopeToLocale,
+      effectiveLocale,
+      normalizedExisting,
+      entity
+    });
+    const targetId = normalizedExisting?.id || normalizedExisting?.documentId;
+    await onSubmit(payload, targetId);
+  };
+  if (!isOpen) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    Modal.Root,
+    {
+      open: isOpen,
+      onOpenChange: (open) => !open && onClose(),
+      children: /* @__PURE__ */ jsxs(Modal.Content, { children: [
+        /* @__PURE__ */ jsx(Modal.Header, { closeLabel: t("note.modal.actions.close", "Close modal"), children: /* @__PURE__ */ jsx(Modal.Title, { children: isExistingNote ? t("note.modal.existing.title", "Edit a note") : t("note.modal.new.title", "Add a note") }) }),
+        /* @__PURE__ */ jsx(Modal.Body, { children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 4, children: [
+          normalizedExisting && /* @__PURE__ */ jsx(
+            NoteMetadataBox,
+            {
+              note: normalizedExisting,
+              uiLocale,
+              t
+            }
+          ),
+          /* @__PURE__ */ jsxs(Field.Root, { name: "title", required: true, error: titleError || void 0, children: [
+            /* @__PURE__ */ jsx(Field.Label, { children: t("note.modal.fields.title", "Title") }),
+            /* @__PURE__ */ jsx(
+              TextInput,
+              {
+                name: "title",
+                value: title,
+                maxLength: MAX_NOTE_TITLE_LENGTH,
+                onChange: (e) => {
+                  setTitle(e.target.value);
+                  if (titleError) setTitleError("");
+                },
+                placeholder: t(
+                  "note.modal.fields.title.placeholder",
+                  "Short summary of this note..."
+                )
+              }
+            ),
+            titleError && /* @__PURE__ */ jsx(Field.Error, {})
+          ] }),
+          /* @__PURE__ */ jsxs(Field.Root, { name: "category", children: [
+            /* @__PURE__ */ jsx(Field.Label, { children: t("note.modal.fields.category", "Category") }),
+            /* @__PURE__ */ jsx(
+              SingleSelect,
+              {
+                value: category,
+                onChange: (val) => setCategory(normalizeNoteCategory(val)),
+                children: NOTE_CATEGORIES.map((cat) => /* @__PURE__ */ jsx(SingleSelectOption, { value: cat, children: t(
+                  NOTE_CATEGORY_META[cat].labelKey,
+                  NOTE_CATEGORY_META[cat].defaultLabel
+                ) }, cat))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Field.Root, { name: "content", children: [
+            /* @__PURE__ */ jsx(Field.Label, { children: t("note.modal.fields.content", "Content") }),
+            /* @__PURE__ */ jsx(
+              Textarea,
+              {
+                name: "content",
+                value: content,
+                maxLength: MAX_NOTE_CONTENT_LENGTH,
+                onChange: (e) => setContent(e.target.value),
+                placeholder: t(
+                  "note.modal.fields.content.placeholder",
+                  "Write detailed editorial context, review feedback, or follow-up steps..."
+                )
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { gap: 4, wrap: "wrap", paddingTop: 1, children: [
+            /* @__PURE__ */ jsx(
+              Checkbox,
+              {
+                checked: isPinned,
+                onCheckedChange: (checked) => setIsPinned(Boolean(checked)),
+                children: t("note.modal.fields.isPinned", "Pin note to top")
+              }
+            ),
+            effectiveLocale && /* @__PURE__ */ jsx(
+              Checkbox,
+              {
+                checked: scopeToLocale,
+                onCheckedChange: (checked) => setScopeToLocale(Boolean(checked)),
+                children: t(
+                  "note.modal.fields.scopeToLocale",
+                  "Scope only to locale ({locale})",
+                  {
+                    locale: effectiveLocale
+                  }
+                )
+              }
+            )
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsxs(Modal.Footer, { children: [
+          /* @__PURE__ */ jsx(Modal.Close, { children: /* @__PURE__ */ jsx(Button, { onClick: onClose, variant: "tertiary", children: t("note.modal.actions.cancel", "Cancel") }) }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: handleSave,
+              startIcon: /* @__PURE__ */ jsx(Check, {}),
+              loading: isSubmitting,
+              disabled: isSubmitting,
+              children: t("note.modal.actions.save", "Save")
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+};
+function detectDocumentLocale(props) {
+  const fromDoc = sanitizeEntityLocale(props.document?.locale);
+  if (fromDoc) {
+    return fromDoc;
+  }
+  if (typeof window !== "undefined") {
+    const fromUrl = new URLSearchParams(window.location.search).get(
+      "plugins[i18n][locale]"
+    );
+    return sanitizeEntityLocale(fromUrl);
+  }
+  return null;
+}
+function interpolateTemplateValues(template, values) {
+  if (!values) return template;
+  return Object.entries(values).reduce(
+    (acc, [k, v]) => acc.split(`{${k}}`).join(String(v)),
+    template
+  );
+}
+function formatNoteMessageWithLocale(id, defaultMessage, formatMessage, uiLocale, entityLocale, values) {
+  const fullKey = getTrad(id);
+  const fallbackEntityLoc = entityLocale || (typeof window !== "undefined" ? new URLSearchParams(window.location.search).get("plugins[i18n][locale]") : null);
+  const globalMessages = globalThis.__CM_I18N_MESSAGES__;
+  const override = (uiLocale ? globalMessages?.[uiLocale]?.[fullKey] : void 0) ?? (fallbackEntityLoc ? globalMessages?.[fallbackEntityLoc]?.[fullKey] : void 0);
+  if (override) {
+    return interpolateTemplateValues(override, values);
+  }
+  return formatMessage({ id: fullKey, defaultMessage }, values);
+}
+const NotesSidePanelContent = ({
+  entity
+}) => {
+  const { formatMessage, locale: uiLocale } = useIntl();
+  const [searchQuery, setSearchQuery] = React.useState("");
+  const [categoryFilter, setCategoryFilter] = React.useState("all");
+  const [isModalOpen, setIsModalOpen] = React.useState(false);
+  const [activeNote, setActiveNote] = React.useState(null);
+  const [noteToDelete, setNoteToDelete] = React.useState(
+    null
+  );
+  const { notes, isLoading, isMutating, createNote, updateNote, deleteNote } = useNotes({
+    entitySlug: entity.slug,
+    entityDocumentId: entity.documentId,
+    entityId: entity.id,
+    entityLocale: entity.locale
+  });
+  const t = (id, defaultMessage, values) => formatNoteMessageWithLocale(
+    id,
+    defaultMessage,
+    formatMessage,
+    uiLocale,
+    entity.locale,
+    values
+  );
+  const visibleNotes = React.useMemo(
+    () => filterNotesList(notes, {
+      category: categoryFilter,
+      search: searchQuery,
+      sort: "DESC"
+    }),
+    [notes, categoryFilter, searchQuery]
+  );
+  const showFilterControls = notes.length > 1 || Boolean(searchQuery.trim()) || categoryFilter !== "all";
+  const handleUpsert = async (payload, existingId) => {
+    const saved = existingId !== void 0 && existingId !== "" ? await updateNote(existingId, payload) : await createNote(payload);
+    if (saved) {
+      setIsModalOpen(false);
+      setActiveNote(null);
+    }
+  };
+  const handleTogglePin = async (note) => {
+    const targetId = note.id || note.documentId;
+    if (!targetId) return;
+    await updateNote(targetId, { isPinned: !note.isPinned });
+  };
+  const handleConfirmDelete = async (note) => {
+    const targetId = note.id || note.documentId;
+    if (!targetId) return;
+    const deleted = await deleteNote(targetId);
+    if (deleted) {
+      setNoteToDelete(null);
+    }
+  };
+  return /* @__PURE__ */ jsx(Box, { paddingTop: 2, paddingBottom: 2, children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 3, children: [
+    /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", children: [
+      /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", children: t("notes.sidePanel.count", "{count} note(s)", {
+        count: notes.length
+      }) }),
+      entity.locale && /* @__PURE__ */ jsx(Badge, { backgroundColor: "neutral150", textColor: "neutral800", children: entity.locale.toUpperCase() })
+    ] }),
+    showFilterControls && /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 2, children: [
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          name: "noteSearch",
+          size: "S",
+          value: searchQuery,
+          onChange: (e) => setSearchQuery(e.target.value),
+          placeholder: t(
+            "notes.sidePanel.search.placeholder",
+            "Filter notes..."
+          )
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        SingleSelect,
+        {
+          size: "S",
+          value: categoryFilter,
+          onChange: (val) => setCategoryFilter(
+            String(val) || "all"
+          ),
+          children: [
+            /* @__PURE__ */ jsx(SingleSelectOption, { value: "all", children: t("category.all", "All categories") }),
+            NOTE_CATEGORIES.map((cat) => /* @__PURE__ */ jsx(SingleSelectOption, { value: cat, children: t(
+              NOTE_CATEGORY_META[cat].labelKey,
+              NOTE_CATEGORY_META[cat].defaultLabel
+            ) }, cat))
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Divider, {}),
+    isLoading ? /* @__PURE__ */ jsx(Flex, { justifyContent: "center", paddingTop: 3, paddingBottom: 3, children: /* @__PURE__ */ jsx(Loader, { small: true, children: t("notes.loading", "Loading Content ...") }) }) : visibleNotes.length === 0 ? /* @__PURE__ */ jsx(Box, { padding: 3, background: "neutral100", hasRadius: true, children: /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", children: notes.length === 0 ? t(
+      "notes.sidePanel.empty",
+      "No editorial notes attached to this entry yet."
+    ) : t(
+      "notes.sidePanel.noMatches",
+      "No notes match the current filter."
+    ) }) }) : /* @__PURE__ */ jsx(
+      Flex,
+      {
+        direction: "column",
+        alignItems: "stretch",
+        gap: 2,
+        style: {
+          maxHeight: "240px",
+          overflowY: "auto",
+          overflowX: "hidden"
+        },
+        children: visibleNotes.map((item) => /* @__PURE__ */ jsx(
+          NoteListItem,
+          {
+            note: item,
+            onEdit: (selected) => {
+              setActiveNote(selected);
+              setIsModalOpen(true);
+            },
+            onRequestDelete: (selected) => setNoteToDelete(selected),
+            onTogglePin: handleTogglePin
+          },
+          String(item.id || item.documentId)
+        ))
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        fullWidth: true,
+        variant: "secondary",
+        startIcon: /* @__PURE__ */ jsx(Plus, {}),
+        disabled: isLoading || isMutating,
+        onClick: () => {
+          setActiveNote(null);
+          setIsModalOpen(true);
+        },
+        children: t("note.modal.new.title", "Add a note")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      NoteModal,
+      {
+        entity,
+        note: activeNote,
+        isOpen: isModalOpen,
+        isSubmitting: isMutating,
+        onClose: () => {
+          setIsModalOpen(false);
+          setActiveNote(null);
+        },
+        onSubmit: handleUpsert
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      DeleteNoteDialog,
+      {
+        note: noteToDelete,
+        isSubmitting: isMutating,
+        onCancel: () => setNoteToDelete(null),
+        onConfirm: handleConfirmDelete
+      }
+    )
+  ] }) });
+};
+function resolveSidePanelDocumentId(props) {
+  if (props.documentId) return props.documentId;
+  const docId = props.document?.documentId;
+  return typeof docId === "string" ? docId : "";
+}
+function resolveSidePanelNumericId(props) {
+  const id = props.document?.id;
+  if (typeof id === "number" || typeof id === "string") {
+    return id;
+  }
+  return null;
+}
+function resolveSidePanelEntity(props) {
+  const slug = props.model ?? "";
+  const documentId = resolveSidePanelDocumentId(props);
+  const numericId = resolveSidePanelNumericId(props);
+  const isSingleType = props.collectionType === "single-types" || props.collectionType === "singleType";
+  const hasIdentifier = Boolean(
+    documentId || numericId !== null || isSingleType
+  );
+  if (!slug || !hasIdentifier) {
+    return null;
+  }
+  return {
+    id: numericId,
+    documentId: documentId || (numericId !== null ? String(numericId) : "single"),
+    slug,
+    locale: detectDocumentLocale(props)
+  };
+}
+const NotesSidePanel = (props) => {
+  const { formatMessage, locale: uiLocale } = useIntl();
+  const entity = resolveSidePanelEntity(props);
+  if (!entity) {
+    return null;
+  }
+  return {
+    title: formatNoteMessageWithLocale(
+      "plugin.name",
+      "Notes",
+      formatMessage,
+      uiLocale,
+      entity.locale
+    ),
+    content: /* @__PURE__ */ jsx(NotesSidePanelContent, { entity })
+  };
+};
+const PluginIcon = () => /* @__PURE__ */ jsx(File, {});
+const index = {
+  register(app) {
+    app.addMenuLink({
+      to: `plugins/${PLUGIN_ID}`,
+      icon: PluginIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.plugin.name`,
+        defaultMessage: "Notes"
+      },
+      Component: () => import("./NotesHomePage-CIWSOu3n.js").then((mod) => ({
+        default: mod.NotesHomePage
+      })),
+      permissions: [
+        {
+          action: `plugin::${PLUGIN_ID}.read`,
+          subject: null
+        }
+      ]
+    });
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  bootstrap(app) {
+    const cmPlugin = app.getPlugin("content-manager");
+    if (cmPlugin?.apis && typeof cmPlugin.apis.addEditViewSidePanel === "function") {
+      cmPlugin.apis.addEditViewSidePanel([NotesSidePanel]);
+    }
+  },
+  registerTrads: createRegisterTrads({
+    pluginId: PLUGIN_ID,
+    defaultLocales: [
+      "en",
+      "es",
+      "ar",
+      "tr",
+      "fr",
+      "de",
+      "it",
+      "pt",
+      "ru",
+      "zh"
+    ],
+    loadTranslation: (locale) => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/ar.json": () => import("./ar-uSBvoP4-.js"), "./translations/de.json": () => import("./de-DlFY4yCr.js"), "./translations/en.json": () => import("./en-DQUtJt3K.js"), "./translations/es.json": () => import("./es-DcTVGahO.js"), "./translations/fr.json": () => import("./fr-QW7vMjBs.js"), "./translations/it.json": () => import("./it-F24NTVne.js"), "./translations/pt.json": () => import("./pt-B4OG4ZiY.js"), "./translations/ru.json": () => import("./ru-DGiT4YZI.js"), "./translations/tr.json": () => import("./tr-CwzORNP2.js"), "./translations/zh.json": () => import("./zh-C1EjzGrj.js") }), `./translations/${locale}.json`, 3)
+  })
+};
+export {
+  DeleteNoteDialog as D,
+  NOTE_CATEGORIES as N,
+  NOTE_CATEGORY_META as a,
+  NoteModal as b,
+  buildContentManagerNoteLink as c,
+  formatNoteAuthorDisplay as d,
+  formatNoteTimestamp as e,
+  filterNotesList as f,
+  getTrad as g,
+  index as i,
+  useNotes as u
+};