framer-cms-markdown 0.0.1

package/dist/src/framer-to-markdown/faq.js

@@ -0,0 +1,44 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function parseFaqEntries(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    return parsed.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const question = typeof entry.question === "string" ? entry.question.trim() : "";
+        const answer = typeof entry.answer === "string" ? entry.answer.trim() : "";
+        if (!question || !answer) {
+            return [];
+        }
+        return [{ question, answer }];
+    });
+}
+export function containsFaqHeading(markdown, heading = "FAQ") {
+    const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^#{2,6}\\s+${escapedHeading}\\s*$`, "im");
+    return pattern.test(markdown);
+}
+export function renderFaqMarkdown(entries, heading = "FAQ") {
+    if (entries.length === 0) {
+        return "";
+    }
+    const lines = [`## ${heading}`, ""];
+    for (const entry of entries) {
+        lines.push(`### ${entry.question}`, "", entry.answer, "");
+    }
+    return `${lines.join("\n").trimEnd()}\n`;
+}

package/dist/src/framer-to-markdown/filename.js

@@ -0,0 +1 @@
+export { resolveMarkdownFilename, slugify, uniqueName, } from "../libs/framer/filename";

package/dist/src/framer-to-markdown/format.js

@@ -0,0 +1 @@
+export { formatMarkdownDocument } from "../libs/framer/format";

package/dist/src/framer-to-markdown/framer-client.js

@@ -0,0 +1 @@
+export { createFieldDataEntryInput, FramerClient, } from "../libs/framer/framer-client";

package/dist/src/framer-to-markdown/framer-ref.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFramerProjectRef = normalizeFramerProjectRef;
+function extractFramerId(value) {
+    const trimmed = value.trim();
+    const parts = trimmed.split("--");
+    if (parts.length > 1) {
+        return parts[parts.length - 1] || trimmed;
+    }
+    return trimmed;
+}
+function normalizeFramerProjectRef(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        const lastPathSegment = parsed.pathname.split("/").filter(Boolean).pop();
+        if (!lastPathSegment) {
+            return trimmed;
+        }
+        return extractFramerId(lastPathSegment);
+    }
+    catch {
+        return extractFramerId(trimmed);
+    }
+}

package/dist/src/framer-to-markdown/frontmatter.js

@@ -0,0 +1 @@
+export { parseFrontmatterDocument, toFrontmatter } from "../libs/framer/frontmatter";

package/dist/src/framer-to-markdown/index.js

@@ -0,0 +1,49 @@
+import path from "node:path";
+import process from "node:process";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { loadConfig } from "./config";
+import { exportItemsToMarkdown } from "./export";
+import { FramerClient } from "./framer-client";
+export async function runCli(argv = hideBin(process.argv)) {
+    const args = await yargs(argv)
+        .scriptName("framer-to-markdown")
+        .usage("$0 --token <token> --config config/use-cases.yml")
+        .option("token", {
+        type: "string",
+        describe: "Framer API token. Falls back to FRAMER_TOKEN.",
+    })
+        .option("config", {
+        type: "string",
+        demandOption: true,
+        describe: "Path to a single export config file",
+    })
+        .strict()
+        .help()
+        .parse();
+    const cliArgs = args;
+    const token = cliArgs.token ?? process.env.FRAMER_TOKEN;
+    if (!token) {
+        throw new Error("Framer token is required. Pass --token or set FRAMER_TOKEN.");
+    }
+    const { config } = await loadConfig(cliArgs.config);
+    const client = new FramerClient({
+        projectRef: config.site,
+        token,
+    });
+    try {
+        const data = await client.getCollectionExportData(config.collection);
+        const writtenFiles = await exportItemsToMarkdown(data.items, {
+            outputDir: config.content ? path.resolve(config.content) : undefined,
+            collectionName: data.collection.name ?? data.collection.id,
+            bodyFieldName: config.markdown,
+            frontmatterFields: config.metadata,
+        });
+        for (const file of writtenFiles) {
+            console.log(file);
+        }
+    }
+    finally {
+        await client.disconnect();
+    }
+}

package/dist/src/framer-to-markdown/markdown.js

@@ -0,0 +1 @@
+export { htmlToMarkdown, markdownToHtml, splitMarkdownIntoSections, } from "../libs/framer/markdown";

package/dist/src/frontmatter.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFrontmatter = toFrontmatter;
+const yaml_1 = __importDefault(require("yaml"));
+function toFrontmatter(data) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (value === undefined) {
+            continue;
+        }
+        filtered[key] = normalizeYamlValue(value);
+    }
+    const yaml = yaml_1.default.stringify(filtered, {
+        lineWidth: 0,
+        singleQuote: true,
+    });
+    return `---\n${yaml.trimEnd()}\n---\n\n`;
+}
+function normalizeYamlValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map(normalizeYamlValue);
+    }
+    if (value && typeof value === "object") {
+        const output = {};
+        for (const [key, nestedValue] of Object.entries(value)) {
+            if (nestedValue !== undefined) {
+                output[key] = normalizeYamlValue(nestedValue);
+            }
+        }
+        return output;
+    }
+    return value;
+}

package/dist/src/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cli"), exports);
+__exportStar(require("./export"), exports);
+__exportStar(require("./framer-client"), exports);
+__exportStar(require("./frontmatter"), exports);
+__exportStar(require("./markdown"), exports);
+__exportStar(require("./filename"), exports);

package/dist/src/libs/framer/config.js

@@ -0,0 +1,50 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "yaml";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseMetadataConfig(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Config "metadata" must be an array.');
+    }
+    const fields = value.map((entry, index) => {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            throw new Error(`Config "metadata[${index}]" must be a non-empty string.`);
+        }
+        return entry;
+    });
+    if (fields.length === 0) {
+        throw new Error('Config "metadata" must define at least one field.');
+    }
+    return fields;
+}
+export async function loadConfig(configPath) {
+    const resolvedPath = path.resolve(configPath);
+    const raw = await fs.readFile(resolvedPath, "utf8");
+    const parsed = yaml.parse(raw);
+    if (!isRecord(parsed)) {
+        throw new Error("Config file must contain a single object.");
+    }
+    if (typeof parsed.site !== "string" || parsed.site.trim().length === 0) {
+        throw new Error('Config "site" must be a non-empty string.');
+    }
+    if (typeof parsed.collection !== "string" ||
+        parsed.collection.trim().length === 0) {
+        throw new Error('Config "collection" must be a non-empty string.');
+    }
+    if (typeof parsed.markdown !== "string" ||
+        parsed.markdown.trim().length === 0) {
+        throw new Error('Config "markdown" must be a non-empty string.');
+    }
+    return {
+        resolvedPath,
+        config: {
+            site: parsed.site,
+            collection: parsed.collection,
+            content: typeof parsed.content === "string" ? parsed.content : undefined,
+            markdown: parsed.markdown,
+            metadata: parseMetadataConfig(parsed.metadata),
+        },
+    };
+}

package/dist/src/libs/framer/filename.js

@@ -0,0 +1,41 @@
+export function slugify(input) {
+    const normalized = input
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+    return normalized.length > 0 ? normalized : "item";
+}
+export function uniqueName(baseName, existingNames) {
+    if (!existingNames.has(baseName)) {
+        return baseName;
+    }
+    let suffix = 2;
+    while (existingNames.has(`${baseName}-${suffix}`)) {
+        suffix += 1;
+    }
+    return `${baseName}-${suffix}`;
+}
+export function resolveMarkdownFilename(item, existingNames = new Set()) {
+    const candidates = [
+        item.slug,
+        item.title,
+        item.id != null ? String(item.id) : null,
+    ];
+    for (const candidate of candidates) {
+        if (!candidate) {
+            continue;
+        }
+        const name = slugify(candidate);
+        if (name) {
+            const unique = uniqueName(name, existingNames);
+            existingNames.add(unique);
+            return `${unique}.md`;
+        }
+    }
+    const fallback = uniqueName("item", existingNames);
+    existingNames.add(fallback);
+    return `${fallback}.md`;
+}

package/dist/src/libs/framer/format.js

@@ -0,0 +1,9 @@
+import * as markdownPlugin from "prettier/plugins/markdown";
+import * as prettier from "prettier/standalone";
+export async function formatMarkdownDocument(markdown) {
+    return prettier.format(markdown, {
+        parser: "markdown",
+        plugins: [markdownPlugin],
+        proseWrap: "preserve",
+    });
+}

package/dist/src/libs/framer/framer-client.js

@@ -0,0 +1,180 @@
+import { connect, } from "framer-api";
+function extractAssetUrl(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const record = value;
+    return typeof record.url === "string" ? record.url : undefined;
+}
+function extractIdOrString(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const record = value;
+    if (typeof record.id === "string") {
+        return record.id;
+    }
+    if (typeof record.name === "string") {
+        return record.name;
+    }
+    return undefined;
+}
+function normalizeFieldEntry(entry) {
+    switch (entry.type) {
+        case "boolean":
+        case "number":
+        case "string":
+        case "enum":
+        case "link":
+            return entry.value;
+        case "date":
+            return entry.value ?? undefined;
+        case "formattedText":
+            return typeof entry.value === "string" ? entry.value : undefined;
+        case "image":
+        case "file":
+            return extractAssetUrl(entry.value);
+        case "color":
+            return extractIdOrString(entry.value);
+        case "collectionReference":
+            return entry.value ?? undefined;
+        case "multiCollectionReference":
+            return Array.isArray(entry.value) ? entry.value : undefined;
+        default:
+            return undefined;
+    }
+}
+export function createFieldDataEntryInput(field, value, options = {}) {
+    switch (field.type) {
+        case "boolean":
+            return typeof value === "boolean"
+                ? { type: field.type, value }
+                : undefined;
+        case "number":
+            return typeof value === "number" ? { type: field.type, value } : undefined;
+        case "string":
+            return typeof value === "string" ? { type: field.type, value } : undefined;
+        case "formattedText":
+            return typeof value === "string"
+                ? {
+                    type: field.type,
+                    value,
+                    contentType: options.formattedTextContentType ?? "html",
+                }
+                : undefined;
+        case "enum":
+            return typeof value === "string" ? { type: field.type, value } : undefined;
+        case "link":
+            return typeof value === "string" ? { type: field.type, value } : undefined;
+        case "date":
+            return typeof value === "string" || typeof value === "number"
+                ? { type: field.type, value: value }
+                : undefined;
+        case "collectionReference":
+            return typeof value === "string" || value === null
+                ? { type: field.type, value: value }
+                : undefined;
+        case "multiCollectionReference":
+            return Array.isArray(value) &&
+                value.every((entry) => typeof entry === "string")
+                ? { type: field.type, value: value }
+                : undefined;
+        case "color":
+        case "file":
+        case "image":
+            return typeof value === "string" || value === null
+                ? { type: field.type, value: value }
+                : undefined;
+        case "array":
+        case "divider":
+        case "unsupported":
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+export class FramerClient {
+    constructor(options) {
+        this.projectRef = options.projectRef;
+        this.token = options.token;
+    }
+    async connect() {
+        if (!this.framer) {
+            this.framer = await connect(this.projectRef, this.token);
+        }
+    }
+    async disconnect() {
+        if (this.framer) {
+            await this.framer.disconnect();
+            this.framer = undefined;
+        }
+    }
+    async getCollections() {
+        return (await this.getFramer()).getCollections();
+    }
+    async resolveCollection(collectionRef) {
+        const collections = await this.getCollections();
+        const normalizedRef = collectionRef.trim().toLowerCase();
+        const match = collections.find((collection) => {
+            return (collection.id.toLowerCase() === normalizedRef ||
+                collection.name.toLowerCase() === normalizedRef);
+        });
+        if (!match) {
+            const available = collections
+                .map((collection) => `${collection.name} (${collection.id})`)
+                .join(", ");
+            throw new Error(`Collection "${collectionRef}" was not found. Available collections: ${available || "none"}.`);
+        }
+        return match;
+    }
+    async getCollectionData(collectionRef) {
+        const collection = await this.resolveCollection(collectionRef);
+        const fields = await collection.getFields();
+        const items = await collection.getItems();
+        return { collection, fields, items };
+    }
+    async getCollectionExportData(collectionRef) {
+        const { collection, fields, items } = await this.getCollectionData(collectionRef);
+        return {
+            collection,
+            fields,
+            items: items.map((item) => this.toExportItem(item, fields)),
+        };
+    }
+    async upsertCollectionItems(collection, items) {
+        await collection.addItems(items);
+    }
+    async getFramer() {
+        await this.connect();
+        if (!this.framer) {
+            throw new Error("Failed to connect to Framer");
+        }
+        return this.framer;
+    }
+    toExportItem(item, fields) {
+        const fieldData = {};
+        for (const field of fields) {
+            if (field.type === "divider") {
+                continue;
+            }
+            const entry = item.fieldData[field.id];
+            if (!entry) {
+                continue;
+            }
+            const value = normalizeFieldEntry(entry);
+            if (value === undefined) {
+                continue;
+            }
+            fieldData[field.name] = value;
+        }
+        return {
+            id: String(item.id),
+            slug: item.slug,
+            draft: item.draft,
+            fieldData,
+        };
+    }
+}

package/dist/src/libs/framer/frontmatter.js

@@ -0,0 +1,49 @@
+import yaml from "yaml";
+function normalizeYamlValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map(normalizeYamlValue);
+    }
+    if (value && typeof value === "object") {
+        const output = {};
+        for (const [key, nestedValue] of Object.entries(value)) {
+            if (nestedValue !== undefined) {
+                output[key] = normalizeYamlValue(nestedValue);
+            }
+        }
+        return output;
+    }
+    return value;
+}
+export function toFrontmatter(data) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (value === undefined) {
+            continue;
+        }
+        filtered[key] = normalizeYamlValue(value);
+    }
+    const rendered = yaml.stringify(filtered, {
+        lineWidth: 0,
+        singleQuote: true,
+    });
+    return `---\n${rendered.trimEnd()}\n---\n\n`;
+}
+export function parseFrontmatterDocument(content) {
+    const normalized = content.replace(/\r\n/g, "\n");
+    const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match) {
+        return { data: {}, body: normalized };
+    }
+    const [, rawFrontmatter, rawBody] = match;
+    const parsed = yaml.parse(rawFrontmatter);
+    const data = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : {};
+    return {
+        data,
+        body: rawBody.replace(/^\n+/, ""),
+    };
+}

package/dist/src/libs/framer/markdown.js

@@ -0,0 +1,70 @@
+import rehypeParse from "rehype-parse";
+import rehypeRemark from "rehype-remark";
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+const htmlToMarkdownProcessor = unified()
+    .use(rehypeParse, { fragment: true })
+    .use(rehypeRemark)
+    .use(remarkGfm, {
+    tablePipeAlign: true,
+    tableCellPadding: true,
+})
+    .use(remarkStringify, {
+    bullet: "-",
+    emphasis: "_",
+    fences: true,
+    setext: false,
+});
+const markdownToHtmlProcessor = unified()
+    .use(remarkParse)
+    .use(remarkGfm)
+    .use(remarkRehype)
+    .use(rehypeStringify, { closeSelfClosing: true });
+function normalizeFragment(markdown) {
+    return markdown.trim().replace(/\n{3,}/g, "\n\n");
+}
+function stripMarkdownComments(markdown) {
+    return markdown.replace(/<!--[\s\S]*?-->\s*/g, "").trim();
+}
+export async function htmlToMarkdown(html) {
+    const input = html.trim();
+    if (!input) {
+        return "";
+    }
+    const file = await htmlToMarkdownProcessor.process(input);
+    const markdown = normalizeFragment(String(file));
+    return markdown.length > 0 ? `${markdown}\n` : "";
+}
+export async function markdownToHtml(markdown) {
+    const input = stripMarkdownComments(markdown);
+    if (!input) {
+        return "";
+    }
+    const file = await markdownToHtmlProcessor.process(input);
+    return String(file).trim();
+}
+export function splitMarkdownIntoSections(markdown) {
+    const normalized = markdown.replace(/\r\n/g, "\n").trim();
+    if (!normalized) {
+        return [];
+    }
+    const lines = normalized.split("\n");
+    const sections = [];
+    let current = [];
+    for (const line of lines) {
+        if (/^##\s+/.test(line) && current.length > 0) {
+            sections.push(current.join("\n").trim());
+            current = [line];
+            continue;
+        }
+        current.push(line);
+    }
+    if (current.length > 0) {
+        sections.push(current.join("\n").trim());
+    }
+    return sections.filter((section) => section.length > 0);
+}

package/dist/src/markdown-to-framer/__tests__/import.spec.js

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "@jest/globals";
+import { buildCollectionItemInput, resolveSectionHtmlFields, } from "../import";
+function field(id, name, type) {
+    return { id, name, type };
+}
+describe("markdown-to-framer import", () => {
+    it("maps metadata verbatim and rebuilds ordered section html fields", async () => {
+        const document = {
+            path: "/tmp/example.md",
+            slug: "example-post",
+            metadata: {
+                Title: "Example Post",
+                Excerpt: "Short summary",
+            },
+            body: [
+                "Intro paragraph.",
+                "",
+                "## Second Section",
+                "",
+                "| A | B |",
+                "| --- | --- |",
+                "| 1 | 2 |",
+            ].join("\n"),
+        };
+        const fields = [
+            field("title-id", "Title", "string"),
+            field("excerpt-id", "Excerpt", "string"),
+            field("s02-id", "Section 02 HTML", "formattedText"),
+            field("s01-id", "Section 01 HTML", "formattedText"),
+            field("s02-title-id", "Section 02 Title", "string"),
+            field("s01-title-id", "Section 01 Title", "string"),
+        ];
+        expect(resolveSectionHtmlFields(fields).map((entry) => entry.name)).toEqual([
+            "Section 01 HTML",
+            "Section 02 HTML",
+        ]);
+        const item = await buildCollectionItemInput(document, fields, {
+            markdown: "sections",
+            metadata: ["Title", "Excerpt"],
+        }, new Map());
+        expect(item.slug).toBe("example-post");
+        expect(item.fieldData?.["title-id"]).toEqual({
+            type: "string",
+            value: "Example Post",
+        });
+        expect(item.fieldData?.["excerpt-id"]).toEqual({
+            type: "string",
+            value: "Short summary",
+        });
+        expect(item.fieldData?.["s01-id"]).toMatchObject({
+            type: "formattedText",
+            contentType: "html",
+        });
+        expect(item.fieldData?.["s02-id"]).toMatchObject({
+            type: "formattedText",
+            contentType: "html",
+        });
+        expect(item.fieldData?.["s01-title-id"]).toEqual({
+            type: "string",
+            value: "",
+        });
+        expect(item.fieldData?.["s02-title-id"]).toEqual({
+            type: "string",
+            value: "Second Section",
+        });
+        expect((item.fieldData?.["s01-id"]).value).toContain("<p>Intro paragraph.</p>");
+        expect((item.fieldData?.["s02-id"]).value).toContain("<table>");
+    });
+});

package/dist/src/markdown-to-framer/cli.js

@@ -0,0 +1,5 @@
+import { runCli } from "./index";
+await runCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});