@roottale/cms-core 0.55.0 → 0.57.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @roottale/cms-core
 
+## 0.57.0
+
+### Minor Changes
+
+- e222471: 본문 예약 내부 링크(`[[internal:키|문구]]`)를 공용 렌더러가 해석한다.
+  - `@roottale/cms-core`: 토큰 정규식·탐색(`findInternalContentLinkTokens`), 경로→키
+    (`internalContentKeyFromPath`), 발행 글 경로 색인(`internalContentPathIndex`, 옛 slug 포함),
+    텍스트·정화된 HTML 안의 토큰을 링크로 바꾸는 `renderInternalContentLinksInText/InHtml`.
+  - `@roottale/cms-renderer-next`: `RenderTiptap`·`RootTaleBlogPost` 에 `internalLinks`
+    (Map·함수) 옵션. `RootTaleBlogPost` 는 기본 `"auto"` — 본문에 토큰이 있을 때만
+    `fetchInternalContentPathIndex` 로 발행 글 경로 색인을 만들어 링크로 렌더한다.
+    대상이 없는 토큰은 문구만 남기고 `data-rt-internal-link-pending="키"` 를 단다.
+    `<code>`·`<pre>`·기존 링크 안은 건드리지 않는다.
+  - 문서: FRONT 가 토큰을 직접 해석하지 않아도 되는 경로를 안내한다.
+
+- 92d0ad4: 공통 블록(Site Patterns) — 여러 글의 같은 자리(글 하단)에 붙는 재사용 본문.
+  - `@roottale/cms-client`: 글 응답 `patternSlots`(자리 key → 블록 key | null, 구 서버는 빈
+    객체), `fetchSitePatterns`(발행 블록 목록, `GET /v1/cms/public/patterns`),
+    `selectSitePatternForSlot`, `SITE_PATTERNS_CACHE_TAG`(`SETTINGS_CACHE_TAGS` 에 포함 —
+    `theme.updated` 로 함께 갱신), `POST_FOOTER_PATTERN_SLOT`.
+  - `@roottale/cms-renderer-next`: `RootTaleBlogPost` 가 `patternSlots.post_footer` 블록을 본문
+    바로 아래에 자동으로 그린다(목록 요청 실패는 블록만 생략). 자체 글 화면용
+    `RootTalePostPattern` 서버 컴포넌트와 `.rt-cms-post-pattern` 스타일 추가.
+  - `@roottale/cms-core`: 자리 선언·배치 규칙 정규화·`resolvePatternSlots` (플랫폼 서버·어드민과
+    공유하는 순수 규칙).
+  - 문서: `theme-and-settings.md` "공통 블록", `api-reference.md` `GET /patterns`·`pattern_slots`.
+
+## 0.56.0
+
+### Minor Changes
+
+- 9eb39e8: ADR-0105 개정 — 글의 정규 공개 경로 계산기 `resolvePostPublicPath` 를 추가합니다.
+  모델 presentation(fixed_page·detail·category_tree) → 호환 컬렉션 → 레거시 `/blog` 순서
+  하나로 계산하며, 플랫폼의 웹훅·사이트맵·단축링크·내부 링크 키·`posts.public_path`
+  물질화가 모두 이 함수를 씁니다.
+
 ## 0.55.0
 
 ## 0.54.0

package/dist/index.cjs

@@ -31,11 +31,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   BLOCK_NAME_PATTERN: () => BLOCK_NAME_PATTERN,
+  EMPTY_SITE_PATTERN_PLACEMENTS: () => EMPTY_SITE_PATTERN_PLACEMENTS,
   FIELD_BINDING_SOURCE: () => FIELD_BINDING_SOURCE,
   FIELD_BINDING_SOURCE_ALIAS: () => FIELD_BINDING_SOURCE_ALIAS,
   IMAGE_ALT_MAX_LENGTH: () => IMAGE_ALT_MAX_LENGTH,
+  INTERNAL_CONTENT_LINK_CLASS: () => INTERNAL_CONTENT_LINK_CLASS,
+  INTERNAL_CONTENT_LINK_PENDING_ATTR: () => INTERNAL_CONTENT_LINK_PENDING_ATTR,
+  INTERNAL_CONTENT_LINK_PENDING_CLASS: () => INTERNAL_CONTENT_LINK_PENDING_CLASS,
+  INTERNAL_CONTENT_LINK_TOKEN_SOURCE: () => INTERNAL_CONTENT_LINK_TOKEN_SOURCE,
+  LEGACY_BLOG_DETAIL_PATH: () => LEGACY_BLOG_DETAIL_PATH,
   PHASE_1_CORE_BLOCKS: () => PHASE_1_CORE_BLOCKS,
   PHASE_1_CSP: () => PHASE_1_CSP,
+  POST_FOOTER_SLOT: () => POST_FOOTER_SLOT,
+  SITE_PATTERN_KEY_PATTERN: () => SITE_PATTERN_KEY_PATTERN,
+  SITE_PATTERN_PLACEMENTS_KEY: () => SITE_PATTERN_PLACEMENTS_KEY,
+  SITE_PATTERN_SLOTS: () => SITE_PATTERN_SLOTS,
   applyBlockBindings: () => applyBlockBindings,
   bindingSrcValue: () => bindingSrcValue,
   bindingTextValue: () => bindingTextValue,
@@ -43,16 +53,24 @@ __export(src_exports, {
   boundFieldValue: () => boundFieldValue,
   chainResolvers: () => chainResolvers,
   createFieldBindingResolver: () => createFieldBindingResolver,
+  emptyPatternSlots: () => emptyPatternSlots,
   ensureImportedHtmlDocumentRoots: () => ensureImportedHtmlDocumentRoots,
   ensureStableIds: () => ensureStableIds,
   extractFaqEntries: () => extractFaqEntries,
   faqPageJsonLd: () => faqPageJsonLd,
+  findInternalContentLinkTokens: () => findInternalContentLinkTokens,
+  findSitePatternPlacementRule: () => findSitePatternPlacementRule,
   htmlToPlainText: () => htmlToPlainText,
   injectStableIdsTree: () => injectStableIdsTree,
+  internalContentKeyFromPath: () => internalContentKeyFromPath,
+  internalContentLinkResolverFrom: () => internalContentLinkResolverFrom,
+  internalContentPathIndex: () => internalContentPathIndex,
   isAllowedEmbedSrc: () => isAllowedEmbedSrc,
   isAllowedMapEmbedSrc: () => isAllowedMapEmbedSrc,
   isInCollectionMode: () => isInCollectionMode,
+  isSitePatternSlotKey: () => isSitePatternSlotKey,
   isValidBlock: () => isValidBlock,
+  isValidSitePatternKey: () => isValidSitePatternKey,
   issuePreviewToken: () => issuePreviewToken,
   normalizeEmbed: () => normalizeEmbed,
   normalizeImageAlt: () => normalizeImageAlt,
@@ -60,19 +78,26 @@ __export(src_exports, {
   postsForCollection: () => postsForCollection,
   postsInAnyCollection: () => postsInAnyCollection,
   postsNotInAnyCollection: () => postsNotInAnyCollection,
+  readSitePatternPlacements: () => readSitePatternPlacements,
+  referencedSitePatternKeys: () => referencedSitePatternKeys,
+  renderInternalContentLinksInHtml: () => renderInternalContentLinksInHtml,
+  renderInternalContentLinksInText: () => renderInternalContentLinksInText,
   resolveCategoryPath: () => resolveCategoryPath,
   resolveCategoryTreeChain: () => resolveCategoryTreeChain,
   resolveCategoryTreeEntryPath: () => resolveCategoryTreeEntryPath,
   resolveCategoryTreeHubPaths: () => resolveCategoryTreeHubPaths,
+  resolvePatternSlots: () => resolvePatternSlots,
   resolvePostCategorySlug: () => resolvePostCategorySlug,
   resolvePostCollection: () => resolvePostCollection,
   resolvePostPath: () => resolvePostPath,
+  resolvePostPublicPath: () => resolvePostPublicPath,
   resolvePostUrl: () => resolvePostUrl,
   sanitizeHtml: () => sanitizeHtml,
   sanitizeImportedCss: () => sanitizeImportedCss,
   sanitizeImportedHtml: () => sanitizeImportedHtml,
   scopeImportedCss: () => scopeImportedCss,
   serializeBlock: () => serializeBlock,
+  setSitePatternPlacementRule: () => setSitePatternPlacementRule,
   validateCollections: () => validateCollections,
   verifyPreviewToken: () => verifyPreviewToken
 });
@@ -359,6 +384,27 @@ function resolveCategoryTreeEntryPath(presentation, entry, terms) {
   return leafPath ? `${leafPath}/${encodeURIComponent(entry.slug)}` : null;
 }
 
+// src/public-path.ts
+var LEGACY_BLOG_DETAIL_PATH = "/blog";
+function resolvePostPublicPath(post, context) {
+  const presentation = context.presentation;
+  if (presentation && presentation.kind !== "data_only") {
+    if (presentation.kind === "fixed_page") return presentation.path;
+    if (presentation.kind === "detail") {
+      if (!presentation.detailPath.includes(":slug")) return null;
+      return presentation.detailPath.replace(":slug", encodeURIComponent(post.slug));
+    }
+    return resolveCategoryTreeEntryPath(presentation, post, context.categories);
+  }
+  const collectionKey = post.collectionKey ?? (presentation ? context.compatibilityCollectionKey ?? post.modelKey ?? null : null);
+  const routable = { slug: post.slug, terms: post.terms, collectionKey };
+  if (!resolvePostCollection(routable, context.collections)) {
+    if (presentation) return null;
+    return `${LEGACY_BLOG_DETAIL_PATH}/${post.slug}`;
+  }
+  return resolvePostPath(routable, context.collections);
+}
+
 // src/delimiter.ts
 function serializeBlock(block) {
   const exportable = sanitizeAttributesForExport(block);
@@ -1018,6 +1064,152 @@ function scopeImportedCss(css, scope, allowedAssetUrls = []) {
   }
 }
 
+// src/internal-content-links.ts
+var INTERNAL_CONTENT_LINK_TOKEN_SOURCE = String.raw`\[\[internal:([a-z0-9가-힣]+(?:[.-][a-z0-9가-힣]+)*)\|([^\]\n|]+)\]\]`;
+function findInternalContentLinkTokens(text) {
+  const pattern = new RegExp(INTERNAL_CONTENT_LINK_TOKEN_SOURCE, "giu");
+  const tokens = [];
+  for (const match of text.matchAll(pattern)) {
+    const [raw, key, label] = match;
+    if (!key || !label || match.index === void 0) continue;
+    tokens.push({
+      index: match.index,
+      raw,
+      key: key.toLowerCase(),
+      label: label.trim()
+    });
+  }
+  return tokens;
+}
+function internalContentKeyFromPath(path) {
+  if (!path) return null;
+  const segments = path.split("/").filter(Boolean).map((segment) => {
+    try {
+      return decodeURIComponent(segment).trim().toLowerCase();
+    } catch {
+      return "";
+    }
+  });
+  if (segments.length === 0 || segments.some((segment) => segment === "" || segment.includes("."))) {
+    return null;
+  }
+  return segments.join(".");
+}
+function internalContentPathIndex(entries) {
+  const index = /* @__PURE__ */ new Map();
+  const previous = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const path = entry.path;
+    const key = internalContentKeyFromPath(path);
+    if (!path || !key) continue;
+    index.set(key, path);
+    const segments = key.split(".");
+    for (const oldSlug of entry.previousSlugs ?? []) {
+      const oldKey = [...segments.slice(0, -1), oldSlug.trim().toLowerCase()].join(".");
+      if (oldKey && !oldKey.includes("..")) previous.set(oldKey, path);
+    }
+  }
+  for (const [key, path] of previous) {
+    if (!index.has(key)) index.set(key, path);
+  }
+  return index;
+}
+function internalContentLinkResolverFrom(source) {
+  if (!source) return () => null;
+  if (typeof source === "function") return source;
+  return (key) => source.get(key.toLowerCase()) ?? null;
+}
+function isSafeInternalPath(path) {
+  return typeof path === "string" && path.startsWith("/") && !path.startsWith("//");
+}
+function escapeHtmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+var INTERNAL_CONTENT_LINK_CLASS = "rt-internal-link";
+var INTERNAL_CONTENT_LINK_PENDING_CLASS = "rt-internal-link--pending";
+var INTERNAL_CONTENT_LINK_PENDING_ATTR = "data-rt-internal-link-pending";
+function renderInternalContentLinksInText(text, resolve) {
+  const tokens = findInternalContentLinkTokens(text);
+  if (tokens.length === 0) return { html: text, hasTokens: false };
+  let cursor = 0;
+  let html = "";
+  for (const token of tokens) {
+    html += text.slice(cursor, token.index);
+    const path = resolve(token.key);
+    const label = escapeHtmlText(token.label);
+    html += isSafeInternalPath(path) ? `<a href="${escapeHtmlText(path)}" class="${INTERNAL_CONTENT_LINK_CLASS}">${label}</a>` : `<span class="${INTERNAL_CONTENT_LINK_CLASS} ${INTERNAL_CONTENT_LINK_PENDING_CLASS}" ${INTERNAL_CONTENT_LINK_PENDING_ATTR}="${escapeHtmlText(token.key)}">${label}</span>`;
+    cursor = token.index + token.raw.length;
+  }
+  html += text.slice(cursor);
+  return { html, hasTokens: true };
+}
+var INTERNAL_LINK_BLOCKED_HTML_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "code",
+  "pre",
+  "script",
+  "style",
+  "textarea"
+]);
+var VOID_HTML_TAGS = /* @__PURE__ */ new Set(["br", "hr", "img", "input", "source", "wbr"]);
+function htmlTagEnd(html, start) {
+  let quote = null;
+  for (let index = start + 1; index < html.length; index += 1) {
+    const character = html[index];
+    if (quote) {
+      if (character === quote) quote = null;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === ">") return index;
+  }
+  return -1;
+}
+function renderInternalContentLinksInHtml(html, resolve) {
+  if (!html.includes("[[internal:")) return { html, hasTokens: false };
+  let blockedDepth = 0;
+  let cursor = 0;
+  let out = "";
+  let hasTokens = false;
+  const emitText = (text) => {
+    if (blockedDepth > 0 || !text) {
+      out += text;
+      return;
+    }
+    const rendered = renderInternalContentLinksInText(text, resolve);
+    hasTokens ||= rendered.hasTokens;
+    out += rendered.html;
+  };
+  while (cursor < html.length) {
+    const tagStart = html.indexOf("<", cursor);
+    if (tagStart < 0) {
+      emitText(html.slice(cursor));
+      break;
+    }
+    emitText(html.slice(cursor, tagStart));
+    const tagEnd = htmlTagEnd(html, tagStart);
+    if (tagEnd < 0) {
+      out += html.slice(tagStart);
+      break;
+    }
+    const tag = html.slice(tagStart, tagEnd + 1);
+    out += tag;
+    const parsed = /^<\s*(\/?)\s*([a-z0-9-]+)/i.exec(tag);
+    const tagName = parsed?.[2]?.toLowerCase();
+    if (tagName && INTERNAL_LINK_BLOCKED_HTML_TAGS.has(tagName)) {
+      const isClosing = parsed?.[1] === "/";
+      const isVoid = VOID_HTML_TAGS.has(tagName) || /\/\s*>$/.test(tag);
+      if (isClosing) blockedDepth = Math.max(0, blockedDepth - 1);
+      else if (!isVoid) blockedDepth += 1;
+    }
+    cursor = tagEnd + 1;
+  }
+  return { html: out, hasTokens };
+}
+
 // src/preview-token.ts
 var import_node_crypto = require("crypto");
 var DELIMITER = ".";
@@ -1325,14 +1517,115 @@ function ensureStableIds(block) {
 function injectStableIdsTree(blocks) {
   return blocks.map((b) => ensureStableIds(b));
 }
+
+// src/site-patterns.ts
+var SITE_PATTERN_SLOTS = [
+  { key: "post_footer", label: "\uAE00 \uD558\uB2E8", description: "\uAE00 \uBCF8\uBB38 \uBC14\uB85C \uC544\uB798" }
+];
+var POST_FOOTER_SLOT = "post_footer";
+var SITE_PATTERN_PLACEMENTS_KEY = "site_pattern_placements";
+var SITE_PATTERN_KEY_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+function isValidSitePatternKey(key) {
+  return SITE_PATTERN_KEY_PATTERN.test(key);
+}
+function isSitePatternSlotKey(value) {
+  return SITE_PATTERN_SLOTS.some((slot) => slot.key === value);
+}
+var EMPTY_SITE_PATTERN_PLACEMENTS = { rules: [] };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNullableKey(value) {
+  if (value === null) return null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  return void 0;
+}
+function readSitePatternPlacements(raw) {
+  let value = raw;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return EMPTY_SITE_PATTERN_PLACEMENTS;
+    }
+  }
+  if (!isRecord(value) || !Array.isArray(value.rules)) {
+    return EMPTY_SITE_PATTERN_PLACEMENTS;
+  }
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const item of value.rules) {
+    if (!isRecord(item)) continue;
+    const slot = typeof item.slot === "string" ? item.slot : "";
+    if (!isSitePatternSlotKey(slot)) continue;
+    const collectionKey = readNullableKey(item.collectionKey);
+    if (collectionKey === void 0) continue;
+    const patternKey = readNullableKey(item.patternKey);
+    if (patternKey === void 0) continue;
+    if (patternKey !== null && !isValidSitePatternKey(patternKey)) continue;
+    byTarget.set(`${slot}\0${collectionKey ?? ""}`, {
+      slot,
+      collectionKey,
+      patternKey
+    });
+  }
+  return { rules: [...byTarget.values()] };
+}
+function findSitePatternPlacementRule(placements, slot, collectionKey) {
+  return placements.rules.find(
+    (rule) => rule.slot === slot && rule.collectionKey === collectionKey
+  );
+}
+function setSitePatternPlacementRule(placements, target, patternKey) {
+  const rest = placements.rules.filter(
+    (rule) => !(rule.slot === target.slot && rule.collectionKey === target.collectionKey)
+  );
+  if (patternKey === void 0) return { rules: rest };
+  return {
+    rules: [
+      ...rest,
+      { slot: target.slot, collectionKey: target.collectionKey, patternKey }
+    ]
+  };
+}
+function emptyPatternSlots() {
+  return Object.fromEntries(SITE_PATTERN_SLOTS.map((slot) => [slot.key, null]));
+}
+function resolvePatternSlots(post, placements, publishedKeys) {
+  const slots = emptyPatternSlots();
+  for (const slot of SITE_PATTERN_SLOTS) {
+    const specific = post.collectionKey !== null ? findSitePatternPlacementRule(placements, slot.key, post.collectionKey) : void 0;
+    const rule = specific ?? findSitePatternPlacementRule(placements, slot.key, null);
+    const key = rule?.patternKey ?? null;
+    slots[slot.key] = key !== null && publishedKeys.has(key) ? key : null;
+  }
+  return slots;
+}
+function referencedSitePatternKeys(placements) {
+  return new Set(
+    placements.rules.map((rule) => rule.patternKey).filter((key) => key !== null)
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BLOCK_NAME_PATTERN,
+  EMPTY_SITE_PATTERN_PLACEMENTS,
   FIELD_BINDING_SOURCE,
   FIELD_BINDING_SOURCE_ALIAS,
   IMAGE_ALT_MAX_LENGTH,
+  INTERNAL_CONTENT_LINK_CLASS,
+  INTERNAL_CONTENT_LINK_PENDING_ATTR,
+  INTERNAL_CONTENT_LINK_PENDING_CLASS,
+  INTERNAL_CONTENT_LINK_TOKEN_SOURCE,
+  LEGACY_BLOG_DETAIL_PATH,
   PHASE_1_CORE_BLOCKS,
   PHASE_1_CSP,
+  POST_FOOTER_SLOT,
+  SITE_PATTERN_KEY_PATTERN,
+  SITE_PATTERN_PLACEMENTS_KEY,
+  SITE_PATTERN_SLOTS,
   applyBlockBindings,
   bindingSrcValue,
   bindingTextValue,
@@ -1340,16 +1633,24 @@ function injectStableIdsTree(blocks) {
   boundFieldValue,
   chainResolvers,
   createFieldBindingResolver,
+  emptyPatternSlots,
   ensureImportedHtmlDocumentRoots,
   ensureStableIds,
   extractFaqEntries,
   faqPageJsonLd,
+  findInternalContentLinkTokens,
+  findSitePatternPlacementRule,
   htmlToPlainText,
   injectStableIdsTree,
+  internalContentKeyFromPath,
+  internalContentLinkResolverFrom,
+  internalContentPathIndex,
   isAllowedEmbedSrc,
   isAllowedMapEmbedSrc,
   isInCollectionMode,
+  isSitePatternSlotKey,
   isValidBlock,
+  isValidSitePatternKey,
   issuePreviewToken,
   normalizeEmbed,
   normalizeImageAlt,
@@ -1357,19 +1658,26 @@ function injectStableIdsTree(blocks) {
   postsForCollection,
   postsInAnyCollection,
   postsNotInAnyCollection,
+  readSitePatternPlacements,
+  referencedSitePatternKeys,
+  renderInternalContentLinksInHtml,
+  renderInternalContentLinksInText,
   resolveCategoryPath,
   resolveCategoryTreeChain,
   resolveCategoryTreeEntryPath,
   resolveCategoryTreeHubPaths,
+  resolvePatternSlots,
   resolvePostCategorySlug,
   resolvePostCollection,
   resolvePostPath,
+  resolvePostPublicPath,
   resolvePostUrl,
   sanitizeHtml,
   sanitizeImportedCss,
   sanitizeImportedHtml,
   scopeImportedCss,
   serializeBlock,
+  setSitePatternPlacementRule,
   validateCollections,
   verifyPreviewToken
 });