canopycms 0.3.2 → 0.4.0

package/dist/editor/fields/markdown-fidelity-visitors.js

@@ -1,4 +1,5 @@
 'use client';
+import { autolinkLiteralAt, gfmAutolinkLiteral, gfmAutolinkLiteralFromMarkdown, } from './gfm-autolink-literal.js';
 function isListLike(node) {
     return (typeof node === 'object' &&
         node !== null &&
@@ -17,6 +18,26 @@ const FORMAT_CONTAINER_TYPES = ['emphasis', 'strong', 'delete'];
 function isFormatContainer(node) {
     return FORMAT_CONTAINER_TYPES.includes(node.type);
 }
+/** Cuts `tail` off `nodes`' last text at any depth, returned in the spans it was cut from. */
+function cutTail(nodes, tail) {
+    const last = nodes.at(-1);
+    if (last?.type === 'text') {
+        if (!last.value.endsWith(tail))
+            return undefined;
+        last.value = last.value.slice(0, last.value.length - tail.length);
+        if (last.value === '')
+            nodes.pop();
+        return { type: 'text', value: tail };
+    }
+    if (last === undefined || !isFormatContainer(last))
+        return undefined;
+    const cut = cutTail(last.children, tail);
+    if (cut === undefined)
+        return undefined;
+    if (last.children.length === 0)
+        nodes.pop();
+    return { ...last, children: [cut] };
+}
 /** `nodes` with every container of a type in `types` replaced by its children, at any depth. */
 function withoutContainers(nodes, types) {
     return nodes.flatMap((node) => {
@@ -28,7 +49,7 @@ function withoutContainers(nodes, types) {
 }
 /** Creates the plugin from MDXEditor's exports; call once per load of MDXEditor. */
 export function createMarkdownFidelityPlugin(mdx) {
-    const { IS_BOLD, IS_CODE, IS_ITALIC, IS_STRIKETHROUGH, addExportVisitor$, addImportVisitor$, lexical: { $isElementNode, $isTextNode }, realmPlugin, } = mdx;
+    const { IS_BOLD, IS_CODE, IS_ITALIC, IS_STRIKETHROUGH, addExportVisitor$, addImportVisitor$, addMdastExtension$, addSyntaxExtension$, lexical: { $getState, $isElementNode, $isTextNode, $setState, createState }, realmPlugin, } = mdx;
     const FORMATS = [
         { format: IS_ITALIC, type: 'emphasis' },
         { format: IS_BOLD, type: 'strong' },
@@ -39,6 +60,49 @@ export function createMarkdownFidelityPlugin(mdx) {
         const texts = $isElementNode(node) ? node.getChildren().filter($isTextNode) : [];
         return texts.length === 0 ? 0 : texts.reduce((all, text) => all & text.getFormat(), ~0);
     };
+    /**
+     * The href a bare URL was imported with. MDXEditor imports it as a LinkNode, whose href, unlike
+     * an AutoLinkNode's, never follows its text; while the href is still this one, the link is
+     * still the bare URL it was.
+     */
+    const bareUrlHref = createState('canopyBareUrlHref', {
+        parse: (value) => (typeof value === 'string' ? value : null),
+    });
+    /** A link written as a bare URL: an auto-link, or an imported one whose href is untouched. */
+    const isBareUrl = (link) => link.getType() === 'autolink' || $getState(link, bareUrlHref) === link.getURL();
+    /** The literal GFM reads at `link` in its paragraph's text, which may run on past `link`. */
+    const literalAt = (link) => {
+        let context = '';
+        let offset = 0;
+        for (const sibling of link.getParent()?.getChildren() ?? [link]) {
+            if (sibling.is(link))
+                offset = context.length;
+            context += sibling.getTextContent();
+        }
+        return autolinkLiteralAt(context, offset);
+    };
+    const bareUrlImportVisitor = {
+        priority: 100,
+        testNode: (node) => {
+            if (node.type !== 'link')
+                return false;
+            const [only, ...rest] = 'children' in node ? node.children : [];
+            if (rest.length > 0 || only?.type !== 'text')
+                return false;
+            const literal = autolinkLiteralAt(only.value, 0);
+            const start = node.position?.start.offset;
+            const end = node.position?.end.offset;
+            // A literal's source is its text; `[url](url)` is longer. GFM's own transform sets none.
+            const bare = start === undefined || end === undefined || end - start === only.value.length;
+            return bare && literal?.url === node.url && literal.length === only.value.length;
+        },
+        visitNode({ mdastNode, lexicalParent, actions }) {
+            actions.nextVisitor();
+            const link = $isElementNode(lexicalParent) ? lexicalParent.getLastChild() : null;
+            if (link !== null && isLinkLike(link))
+                $setState(link, bareUrlHref, mdastNode.url);
+        },
+    };
     // MDXEditor imports a list without its `start`, and exports one without it.
     const listStartImportVisitor = {
         priority: 100,
@@ -87,6 +151,10 @@ export function createMarkdownFidelityPlugin(mdx) {
      *
      * An auto-link holding code-formatted text is written as its text: lexical's auto-link matchers
      * see text, not formats, so a URL inside a code span becomes a link markdown never meant.
+     *
+     * A bare URL (`isBareUrl`) is written as GFM reads its text where it stands: GFM's link and the
+     * punctuation GFM leaves out. Where GFM links nothing, an auto-link is written as text and an
+     * imported one as the link the editor shows.
      */
     const linkExportVisitor = {
         priority: 100,
@@ -102,6 +170,16 @@ export function createMarkdownFidelityPlugin(mdx) {
                 actions.visitChildren(lexicalNode, mdastParent);
                 return;
             }
+            let literal;
+            if (isBareUrl(lexicalNode)) {
+                const text = lexicalNode.getTextContent();
+                const here = literalAt(lexicalNode);
+                if (here === undefined && lexicalNode.getType() === 'autolink') {
+                    actions.visitChildren(lexicalNode, mdastParent);
+                    return;
+                }
+                literal = here && (here.length <= text.length ? here : autolinkLiteralAt(text, 0));
+            }
             const format = sharedFormat(lexicalNode);
             const next = lexicalNode.getNextSibling();
             const carried = new Set();
@@ -127,7 +205,7 @@ export function createMarkdownFidelityPlugin(mdx) {
             }
             const link = {
                 type: 'link',
-                url: lexicalNode.getURL(),
+                url: literal?.url ?? lexicalNode.getURL(),
                 title: lexicalNode.getTitle(),
                 children: [],
             };
@@ -135,6 +213,10 @@ export function createMarkdownFidelityPlugin(mdx) {
             actions.visitChildren(lexicalNode, link);
             if (carried.size > 0)
                 link.children = withoutContainers(link.children, carried);
+            const tail = literal ? lexicalNode.getTextContent().slice(literal.length) : '';
+            const cut = tail === '' ? undefined : cutTail(link.children, tail);
+            if (cut !== undefined)
+                actions.appendToParent(parent, cut);
         },
     };
     // Markdown has no way to write two code spans side by side, and an auto-link written as its
@@ -149,7 +231,10 @@ export function createMarkdownFidelityPlugin(mdx) {
     };
     return realmPlugin({
         init(realm) {
-            realm.pub(addImportVisitor$, listStartImportVisitor);
+            // Without autolink literals a bare URL imports as text, for lexical's matcher to re-link.
+            realm.pub(addSyntaxExtension$, gfmAutolinkLiteral());
+            realm.pub(addMdastExtension$, gfmAutolinkLiteralFromMarkdown());
+            realm.pub(addImportVisitor$, [listStartImportVisitor, bareUrlImportVisitor]);
             realm.pub(addExportVisitor$, [
                 listStartExportVisitor,
                 linkExportVisitor,

package/dist/entry-schema.d.ts

@@ -48,7 +48,10 @@ type InferableField = {
     entryTypes?: readonly string[];
     /** For reference fields: collection paths to scope the search. */
     collections?: readonly string[];
-    /** For reference fields: resolve the target's body too. See ReferenceFieldConfig.includeBody. */
+    /**
+     * For reference fields: resolve the target's body too. Without it the `resolvedSchema`'s
+     * `isBody` field is optional in the resolved type. See ReferenceFieldConfig.includeBody.
+     */
     includeBody?: boolean;
 };
 /**
@@ -79,7 +82,9 @@ export interface ResolvedReferenceMeta {
 }
 /**
  * Assemble a resolved reference: the target's own data, then its body if the field asked to
- * embed it, then the reserved metadata.
+ * embed it, then the reserved metadata. A link-only reference carries no body for any format:
+ * an md/mdx target passes none here, and a json/yaml target's `data` arrives without its
+ * `isBody` field (`linkOnlyReferenceData`), so both formats resolve alike.
  *
  * The ordering is the contract, not a detail. Metadata LAST means a target that models `id` as
  * a content field cannot shadow the real content ID, which the write boundary recovers from
@@ -272,7 +277,7 @@ type FieldValue<F extends InferableField> = F extends {
 } ? ScalarValue<F, SelectValue<F>> : F extends {
     type: 'reference';
     resolvedSchema: infer S;
-} ? ScalarValue<F, (InferContentShape<Extract<S, readonly InferableField[]>> & ResolvedReferenceMeta & {
+} ? ScalarValue<F, (InferContentShape<Extract<S, readonly InferableField[]>, F['includeBody'] extends true ? false : true> & ResolvedReferenceMeta & {
     unavailable?: undefined;
 }) | UnavailableReference | null> : F extends {
     type: 'reference';
@@ -298,11 +303,16 @@ type FieldValue<F extends InferableField> = F extends {
  *
  * Works with any structurally compatible array; importing FieldConfig is not required.
  */
-type InferContentShape<Fields extends readonly InferableField[]> = Simplify<{
-    [F in FlattenInlineGroups<Fields>[number] as F['required'] extends false ? never : F['name']]: FieldValue<F>;
+type InferContentShape<Fields extends readonly InferableField[], BodyOptional extends boolean = false> = Simplify<{
+    [F in FlattenInlineGroups<Fields>[number] as IsOptionalKey<F, BodyOptional> extends true ? never : F['name']]: FieldValue<F>;
 } & {
-    [F in FlattenInlineGroups<Fields>[number] as F['required'] extends false ? F['name'] : never]?: FieldValue<F>;
+    [F in FlattenInlineGroups<Fields>[number] as IsOptionalKey<F, BodyOptional> extends true ? F['name'] : never]?: FieldValue<F>;
 }>;
+/**
+ * Whether InferContentShape gives a field `?:`: an explicit `required: false`, or, with
+ * `BodyOptional` (a reference target resolved without `includeBody`), the `isBody` field.
+ */
+type IsOptionalKey<F extends InferableField, BodyOptional extends boolean> = F['required'] extends false ? true : BodyOptional extends true ? F['isBody'] extends true ? true : false : false;
 /** Define an entry schema's field array with literal inference, without sprinkling `as const`. */
 export declare const defineEntrySchema: <const T extends readonly InferableField[]>(fields: T) => T;
 /** Content shape derived from a `defineEntrySchema` result. */

package/dist/entry-schema.js

@@ -12,7 +12,9 @@ import { DEFAULT_SEO_FIELD_NAMES } from './static/seo.js';
 export const RESOLVED_REFERENCE_KEYS = ['id', 'slug', 'collection', 'urlPath'];
 /**
  * Assemble a resolved reference: the target's own data, then its body if the field asked to
- * embed it, then the reserved metadata.
+ * embed it, then the reserved metadata. A link-only reference carries no body for any format:
+ * an md/mdx target passes none here, and a json/yaml target's `data` arrives without its
+ * `isBody` field (`linkOnlyReferenceData`), so both formats resolve alike.
  *
  * The ordering is the contract, not a detail. Metadata LAST means a target that models `id` as
  * a content field cannot shadow the real content ID, which the write boundary recovers from

package/dist/utils/body-field.d.ts

@@ -1,4 +1,4 @@
-import type { FieldConfig } from '../config/index.js';
+import type { ContentFormat, FieldConfig } from '../config/index.js';
 /**
  * Count top-level fields marked `isBody: true`. Does NOT recurse into objects — `isBody` maps
  * to the file's markdown content, which exists only at the top level.
@@ -6,6 +6,14 @@ import type { FieldConfig } from '../config/index.js';
 export declare function countBodyFields(fields: readonly FieldConfig[]): number;
 /** Name of the `isBody: true` field, or `'body'`; maps the file's markdown onto a data field. */
 export declare function findBodyFieldName(fields: readonly FieldConfig[]): string;
+/** Name of the `isBody: true` field, or `undefined`: no `'body'` fallback. */
+export declare function findExplicitBodyFieldName(fields: readonly FieldConfig[]): string | undefined;
+/**
+ * The data a link-only reference (one without `includeBody: true`) carries for its target. A
+ * json/yaml entry's `isBody` field is its prose, so it is left out, as an md/mdx target's body
+ * is. Only an explicit `isBody` counts: a field merely named `body` is ordinary data.
+ */
+export declare function linkOnlyReferenceData(data: Record<string, unknown>, format: ContentFormat, fields: readonly FieldConfig[] | undefined): Record<string, unknown>;
 /**
  * Find an isBody field whose NAME is reserved by reference resolution.
  *

package/dist/utils/body-field.js

@@ -1,4 +1,5 @@
 import { flattenGroupFields } from './flatten-group-fields.js';
+import { isDataOnlyFormat } from './format.js';
 const BODY_FIELD_TYPES = new Set(['markdown', 'mdx']);
 /**
  * Count top-level fields marked `isBody: true`. Does NOT recurse into objects — `isBody` maps
@@ -14,11 +15,27 @@ export function countBodyFields(fields) {
 }
 /** Name of the `isBody: true` field, or `'body'`; maps the file's markdown onto a data field. */
 export function findBodyFieldName(fields) {
+    return findExplicitBodyFieldName(fields) ?? 'body';
+}
+/** Name of the `isBody: true` field, or `undefined`: no `'body'` fallback. */
+export function findExplicitBodyFieldName(fields) {
     for (const field of flattenGroupFields(fields)) {
         if ('isBody' in field && field.isBody)
             return field.name;
     }
-    return 'body';
+    return undefined;
+}
+/**
+ * The data a link-only reference (one without `includeBody: true`) carries for its target. A
+ * json/yaml entry's `isBody` field is its prose, so it is left out, as an md/mdx target's body
+ * is. Only an explicit `isBody` counts: a field merely named `body` is ordinary data.
+ */
+export function linkOnlyReferenceData(data, format, fields) {
+    const bodyFieldName = isDataOnlyFormat(format) && fields ? findExplicitBodyFieldName(fields) : undefined;
+    if (bodyFieldName === undefined || !(bodyFieldName in data))
+        return data;
+    const { [bodyFieldName]: _body, ...rest } = data;
+    return rest;
 }
 /**
  * Find an isBody field whose NAME is reserved by reference resolution.

package/dist/utils/markdown-body-splice.js

@@ -49,8 +49,9 @@ function parse(text, format) {
  * A node's meaning as a string: its tree without source positions. `data` goes too, because
  * the parser fills it only with derived information (an MDX expression's estree, which carries
  * its own offsets) and never with content. Line endings inside values are normalised, so a CRLF
- * file's blocks match the editor's LF ones. A bare URL and `[url](url)` share a tree, which keeps
- * a bare URL on disk when the editor (whose `linkPlugin()` autolinks, in `MarkdownField.tsx`) sends it back as a link.
+ * file's blocks match the editor's LF ones. A bare URL and the `[text](url)` the editor writes for
+ * it share a tree, since the editor imports it as GFM's link (`markdown-fidelity-visitors.ts`), so
+ * a bare URL stays on disk.
  */
 function canonical(node) {
     return JSON.stringify(node, (key, value) => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CANOPYCMS_VERSION = "0.3.2";
+export declare const CANOPYCMS_VERSION = "0.4.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/bump-version.mjs, its only writer. The package builds with plain
 // tsc (rootDir: src), so src/ cannot import ../package.json; version.test.ts keeps the two equal.
-export const CANOPYCMS_VERSION = '0.3.2';
+export const CANOPYCMS_VERSION = '0.4.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@codemirror/language, @lezer/highlight: workaround — @mdxeditor/editor uses cm6-theme-basic-light which peer-requires these but mdxeditor doesn't declare them as dependencies",
   "name": "canopycms",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "CanopyCMS core package: schema-driven content, branch-aware editing, and editor UI for Next.js.",
   "license": "MIT",
   "repository": {
@@ -135,8 +135,10 @@
     "lru-cache": "^10.4.3",
     "mdast-util-from-markdown": "^2.0.3",
     "mdast-util-gfm": "^3.1.0",
+    "mdast-util-gfm-autolink-literal": "^2.0.1",
     "mdast-util-mdx": "^3.0.0",
     "micromark-extension-gfm": "^3.0.0",
+    "micromark-extension-gfm-autolink-literal": "^2.1.0",
     "micromark-extension-mdxjs": "^3.0.0",
     "minimatch": "^9.0.7",
     "minimist": "^1.2.8",