mdx-artifacts 0.1.0

package/dist/lib/cli/dev.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { loadConfig } from "./config.js";
+import { createArtifactProject, startDevServer } from "./vite-artifact.js";
+export async function devCommand(projectRoot, input) {
+    const config = await loadConfig(projectRoot);
+    const mdxPath = path.resolve(projectRoot, input);
+    const project = await createArtifactProject(projectRoot, mdxPath, config);
+    const server = await startDevServer(project);
+    const urls = server.resolvedUrls?.local ?? [];
+    console.log(`dev server ready: ${artifactUrl(urls[0] ?? `http://localhost:${config.port}/`, project.artifact.routePath)}`);
+    console.log("press Ctrl+C to stop");
+    const close = async () => {
+        await server.close();
+        await project.cleanup();
+        process.exit(0);
+    };
+    process.once("SIGINT", close);
+    process.once("SIGTERM", close);
+}
+function artifactUrl(baseUrl, routePath) {
+    const url = new URL(baseUrl);
+    url.pathname = routePath;
+    return url.toString();
+}

package/dist/lib/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/lib/cli/index.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { buildCommand } from "./build.js";
+import { componentsCommand } from "./components.js";
+import { devCommand } from "./dev.js";
+import { reviewCommand } from "./review.js";
+import { initProject } from "./scaffold.js";
+import { printValidationResult, validateMdx } from "./validate.js";
+const projectRoot = process.cwd();
+const [command, input] = process.argv.slice(2);
+async function main() {
+    if (!command || command === "help" || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "init") {
+        await initProject(projectRoot);
+        return;
+    }
+    if (command === "components") {
+        const args = process.argv.slice(3);
+        const json = args.includes("--json");
+        const name = args.find((arg) => arg !== "--json");
+        componentsCommand(name, { json });
+        return;
+    }
+    if (command === "review") {
+        await reviewCommand(projectRoot, process.argv.slice(3));
+        return;
+    }
+    if (!input) {
+        throw new Error(`${command} requires a .mdx file path.`);
+    }
+    if (command === "validate") {
+        const result = await validateMdx(path.resolve(projectRoot, input));
+        printValidationResult(result);
+        if (result.errors.length > 0) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (command === "build") {
+        await buildCommand(projectRoot, input);
+        return;
+    }
+    if (command === "dev") {
+        await devCommand(projectRoot, input);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+function printHelp() {
+    console.log(`artifact-kit
+
+Usage:
+  artifact-kit init
+  artifact-kit components [ComponentName] [--json]
+  artifact-kit validate <file.mdx>
+  artifact-kit review add <file.mdx> --anchor <anchorId> --body <message> [--title <title>]
+  artifact-kit review reply <file.mdx> --thread <threadId> --body <message> [...repeat] [--status <status>]
+  artifact-kit review validate <file.mdx>
+  artifact-kit dev <file.mdx>
+  artifact-kit build <file.mdx>
+`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/lib/cli/review.d.ts

@@ -0,0 +1,33 @@
+type ReviewReply = {
+    threadId: string;
+    body: string;
+};
+type ReviewAddOptions = {
+    anchorId: string;
+    body: string;
+    title?: string;
+};
+type ReviewReplyOptions = {
+    replies: ReviewReply[];
+    status?: string;
+};
+export type ReviewValidationResult = {
+    anchorCount: number;
+    missingThreads: ReviewMissingThread[];
+    output: string;
+    threadCount: number;
+};
+export type ReviewMissingThread = {
+    anchorId: string;
+    threadId: string;
+    title?: string;
+    status?: string;
+};
+export declare function reviewCommand(projectRoot: string, args: string[]): Promise<void>;
+export declare function addReviewThread(projectRoot: string, input: string, options: ReviewAddOptions): Promise<string>;
+export declare function replyToReviewThread(projectRoot: string, input: string, options: ReviewReply & {
+    status?: string;
+}): Promise<string>;
+export declare function replyToReviewThreads(projectRoot: string, input: string, options: ReviewReplyOptions): Promise<string>;
+export declare function validateReviewState(projectRoot: string, input: string): Promise<ReviewValidationResult>;
+export {};

package/dist/lib/cli/review.js

@@ -0,0 +1,390 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createArtifactRoute, readArtifactState, writeArtifactState } from "./artifact-state.js";
+import { loadConfig } from "./config.js";
+export async function reviewCommand(projectRoot, args) {
+    const [subcommand] = args;
+    if (subcommand === "add") {
+        const options = parseReviewAddArgs(args.slice(1));
+        console.log(await addReviewThread(projectRoot, options.input, options));
+        return;
+    }
+    if (subcommand === "reply") {
+        const options = parseReviewReplyArgs(args.slice(1));
+        console.log(await replyToReviewThreads(projectRoot, options.input, options));
+        return;
+    }
+    if (subcommand === "validate") {
+        const input = parseReviewValidateArgs(args.slice(1));
+        const result = await validateReviewState(projectRoot, input);
+        console.log(result.output);
+        if (result.missingThreads.length > 0) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    throw new Error("review requires a subcommand. Use `artifact-kit review add <file.mdx>`, `artifact-kit review reply <file.mdx>`, or `artifact-kit review validate <file.mdx>`.");
+}
+export async function addReviewThread(projectRoot, input, options) {
+    const artifact = await createArtifactFromInput(projectRoot, input);
+    const state = await readArtifactState(artifact);
+    const source = await readFile(artifact.sourcePath, "utf8");
+    const anchorIds = extractReviewAnchorIds(source);
+    if (!anchorIds.has(options.anchorId)) {
+        throw new Error(`Review anchor not found: ${options.anchorId}`);
+    }
+    if (state.threads.some((thread) => isRecord(thread) && thread.anchorId === options.anchorId)) {
+        throw new Error(`Review thread already exists for anchor: ${options.anchorId}`);
+    }
+    const threadId = createThreadId(options.anchorId, state.threads);
+    const message = createUserMessage(options.body);
+    const thread = {
+        id: threadId,
+        anchorId: options.anchorId,
+        status: "open",
+        ...(options.title ? { title: options.title } : {}),
+        messages: [message]
+    };
+    await writeArtifactState(projectRoot, artifact, {
+        ...state,
+        threads: [...state.threads, thread]
+    });
+    return [`review add ok`, `state: ${artifact.stateRelativePath}`, `thread: ${threadId}`, `anchorId: ${options.anchorId}`].join("\n");
+}
+export async function replyToReviewThread(projectRoot, input, options) {
+    return replyToReviewThreads(projectRoot, input, {
+        replies: [{ threadId: options.threadId, body: options.body }],
+        ...(options.status ? { status: options.status } : {})
+    });
+}
+export async function replyToReviewThreads(projectRoot, input, options) {
+    const artifact = await createArtifactFromInput(projectRoot, input);
+    const state = await readArtifactState(artifact);
+    const repliesByThread = groupRepliesByThread(options.replies);
+    const threadIds = new Set(state.threads.filter(isRecord).map((thread) => thread.id).filter(isString));
+    const missingThreadIds = Array.from(repliesByThread.keys()).filter((threadId) => !threadIds.has(threadId));
+    if (missingThreadIds.length > 0) {
+        throw new Error(`Review thread not found: ${missingThreadIds.join(", ")}`);
+    }
+    const messageRecords = [];
+    const threads = state.threads.map((thread) => {
+        if (!isRecord(thread) || !isString(thread.id)) {
+            return thread;
+        }
+        const replies = repliesByThread.get(thread.id);
+        if (!replies) {
+            return thread;
+        }
+        const messages = Array.isArray(thread.messages) ? thread.messages : [];
+        const nextMessages = replies.map((reply, index) => createAssistantMessage(reply.body, messageRecords.length + index));
+        for (const message of nextMessages) {
+            messageRecords.push({ threadId: thread.id, messageId: message.id });
+        }
+        return {
+            ...thread,
+            ...(options.status ? { status: options.status } : {}),
+            messages: [...messages, ...nextMessages]
+        };
+    });
+    await writeArtifactState(projectRoot, artifact, {
+        ...state,
+        threads
+    });
+    return [
+        `review reply ok`,
+        `state: ${artifact.stateRelativePath}`,
+        `messages: ${messageRecords.length}`,
+        ...messageRecords.map((record) => `- thread: ${record.threadId} message: ${record.messageId}`)
+    ].join("\n");
+}
+export async function validateReviewState(projectRoot, input) {
+    const artifact = await createArtifactFromInput(projectRoot, input);
+    const state = await readArtifactState(artifact);
+    const source = await readFile(artifact.sourcePath, "utf8");
+    const anchorIds = extractReviewAnchorIds(source);
+    const threads = state.threads.filter(isRecord);
+    const missingThreads = threads.flatMap((thread) => {
+        if (!isString(thread.anchorId) || anchorIds.has(thread.anchorId)) {
+            return [];
+        }
+        return [
+            {
+                anchorId: thread.anchorId,
+                threadId: isString(thread.id) ? thread.id : "(missing thread id)",
+                title: isString(thread.title) ? thread.title : undefined,
+                status: isString(thread.status) ? thread.status : undefined
+            }
+        ];
+    });
+    const output = missingThreads.length === 0
+        ? [
+            `review validate ok`,
+            `state: ${artifact.stateRelativePath}`,
+            `anchors: ${anchorIds.size}`,
+            `threads: ${threads.length}`
+        ].join("\n")
+        : [
+            `review validate failed`,
+            `state: ${artifact.stateRelativePath}`,
+            `anchors: ${anchorIds.size}`,
+            `threads: ${threads.length}`,
+            `missing: ${missingThreads.length}`,
+            ...missingThreads.map((thread) => [
+                `- thread: ${thread.threadId}`,
+                `anchorId: ${thread.anchorId}`,
+                thread.status ? `status: ${thread.status}` : undefined,
+                thread.title ? `title: ${thread.title}` : undefined
+            ]
+                .filter(Boolean)
+                .join(" "))
+        ].join("\n");
+    return {
+        anchorCount: anchorIds.size,
+        missingThreads,
+        output,
+        threadCount: threads.length
+    };
+}
+async function createArtifactFromInput(projectRoot, input) {
+    const config = await loadConfig(projectRoot);
+    const mdxPath = path.resolve(projectRoot, input);
+    return createArtifactRoute(projectRoot, mdxPath, config.docsDir);
+}
+function parseReviewReplyArgs(args) {
+    const [input, ...rest] = args;
+    if (!input) {
+        throw new Error("review reply requires a .mdx file path.");
+    }
+    const { replies, status } = parseReviewReplyOptions(rest);
+    return {
+        input,
+        replies,
+        ...(status ? { status } : {})
+    };
+}
+function parseReviewValidateArgs(args) {
+    const [input, ...rest] = args;
+    if (!input) {
+        throw new Error("review validate requires a .mdx file path.");
+    }
+    if (rest.length > 0) {
+        throw new Error(`Unexpected review validate argument: ${rest[0]}`);
+    }
+    return input;
+}
+function parseReviewAddArgs(args) {
+    const [input, ...rest] = args;
+    if (!input) {
+        throw new Error("review add requires a .mdx file path.");
+    }
+    const options = parseKeyValueOptions(rest, ["anchor", "body", "title"]);
+    const anchorId = options.get("anchor");
+    const body = options.get("body");
+    const title = options.get("title");
+    if (!anchorId) {
+        throw new Error("review add requires --anchor <anchorId>.");
+    }
+    if (!body || !body.trim()) {
+        throw new Error("review add requires --body <message>.");
+    }
+    return {
+        input,
+        anchorId,
+        body: body.trim(),
+        ...(title ? { title } : {})
+    };
+}
+function parseKeyValueOptions(args, allowedKeys) {
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const name = args[index];
+        if (!name?.startsWith("--")) {
+            throw new Error(`Unexpected review argument: ${name}`);
+        }
+        const key = name.slice(2);
+        const value = args[index + 1];
+        if (!allowedKeys.includes(key)) {
+            throw new Error(`Unknown review option: --${key}.`);
+        }
+        if (!value || value.startsWith("--")) {
+            throw new Error(`Missing value for --${key}.`);
+        }
+        options.set(key, value);
+        index += 1;
+    }
+    return options;
+}
+function parseReviewReplyOptions(args) {
+    const replies = [];
+    let status;
+    let threadId;
+    for (let index = 0; index < args.length; index += 1) {
+        const name = args[index];
+        if (!name?.startsWith("--")) {
+            throw new Error(`Unexpected review reply argument: ${name}`);
+        }
+        const key = name.slice(2);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--")) {
+            throw new Error(`Missing value for --${key}.`);
+        }
+        if (key === "thread") {
+            if (threadId) {
+                throw new Error(`Missing --body for --thread ${threadId}.`);
+            }
+            threadId = value;
+        }
+        else if (key === "body") {
+            if (!threadId) {
+                throw new Error("review reply requires --thread before --body.");
+            }
+            if (!value.trim()) {
+                throw new Error("review reply requires --body <message>.");
+            }
+            replies.push({ threadId, body: value.trim() });
+            threadId = undefined;
+        }
+        else if (key === "status") {
+            status = value;
+        }
+        else {
+            throw new Error(`Unknown review reply option: --${key}.`);
+        }
+        index += 1;
+    }
+    if (threadId) {
+        throw new Error(`Missing --body for --thread ${threadId}.`);
+    }
+    if (replies.length === 0) {
+        throw new Error("review reply requires at least one --thread <threadId> --body <message> pair.");
+    }
+    return { replies, status };
+}
+function groupRepliesByThread(replies) {
+    const repliesByThread = new Map();
+    for (const reply of replies) {
+        const threadReplies = repliesByThread.get(reply.threadId) ?? [];
+        threadReplies.push(reply);
+        repliesByThread.set(reply.threadId, threadReplies);
+    }
+    return repliesByThread;
+}
+function createAssistantMessage(body, index = 0) {
+    return {
+        id: `msg_${Date.now().toString(36)}_${index.toString(36)}`,
+        role: "assistant",
+        body,
+        createdAt: new Date().toISOString()
+    };
+}
+function createUserMessage(body) {
+    return {
+        id: `msg_${Date.now().toString(36)}_0`,
+        role: "user",
+        body,
+        createdAt: new Date().toISOString()
+    };
+}
+function createThreadId(anchorId, threads) {
+    const existingIds = new Set(threads.filter(isRecord).map((thread) => thread.id).filter(isString));
+    const base = `thr_${compactId(anchorId)}`;
+    if (!existingIds.has(base)) {
+        return base;
+    }
+    for (let index = 2; index < 100; index += 1) {
+        const candidate = `${base}_${index}`;
+        if (!existingIds.has(candidate)) {
+            return candidate;
+        }
+    }
+    return `thr_${compactId(anchorId)}_${Date.now().toString(36)}`;
+}
+function extractReviewAnchorIds(source) {
+    const anchorIds = new Set();
+    for (const match of source.matchAll(/<([A-Z][A-Za-z0-9.]*)\b[^>]*(?:\sid|\stargetId)\s*=\s*["']([^"']+)["']/g)) {
+        if (match[2]) {
+            anchorIds.add(match[2]);
+        }
+    }
+    addArrayChildAnchors(source, anchorIds, "DecisionMatrix", "options");
+    addArrayChildAnchors(source, anchorIds, "OptionGrid", "options");
+    addArrayChildAnchors(source, anchorIds, "AnnotatedCode", "annotations", { addCodeChild: true });
+    addComparisonSetChildAnchors(source, anchorIds);
+    return anchorIds;
+}
+function addArrayChildAnchors(source, anchorIds, componentName, arrayPropName, options = {}) {
+    const componentPattern = new RegExp(`<${componentName}\\b[\\s\\S]*?\\/>`, "g");
+    for (const match of source.matchAll(componentPattern)) {
+        const componentSource = match[0];
+        const parentId = extractJsxStringProp(componentSource, "id");
+        if (!parentId) {
+            continue;
+        }
+        if (options.addCodeChild) {
+            anchorIds.add(`${parentId}.code`);
+        }
+        const arraySource = extractJsxArrayProp(componentSource, arrayPropName);
+        if (!arraySource) {
+            continue;
+        }
+        for (const itemId of extractObjectIds(arraySource)) {
+            anchorIds.add(`${parentId}.${itemId}`);
+        }
+    }
+}
+function addComparisonSetChildAnchors(source, anchorIds) {
+    for (const match of source.matchAll(/<ComparisonSet\b[\s\S]*?<\/ComparisonSet>/g)) {
+        const componentSource = match[0];
+        const parentId = extractJsxStringProp(componentSource, "id");
+        if (!parentId) {
+            continue;
+        }
+        for (const itemMatch of componentSource.matchAll(/<ComparisonSet\.Item\b[^>]*\sid\s*=\s*["']([^"']+)["'][^>]*>/g)) {
+            if (itemMatch[1]) {
+                anchorIds.add(`${parentId}.${itemMatch[1]}`);
+            }
+        }
+    }
+}
+function extractJsxStringProp(source, propName) {
+    const pattern = new RegExp(`\\b${propName}\\s*=\\s*["']([^"']+)["']`);
+    return source.match(pattern)?.[1];
+}
+function extractJsxArrayProp(source, propName) {
+    const propStart = source.search(new RegExp(`\\b${propName}\\s*=\\s*\\{\\s*\\[`));
+    if (propStart < 0) {
+        return undefined;
+    }
+    const arrayStart = source.indexOf("[", propStart);
+    let depth = 0;
+    for (let index = arrayStart; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === "[") {
+            depth += 1;
+        }
+        else if (char === "]") {
+            depth -= 1;
+            if (depth === 0) {
+                return source.slice(arrayStart, index + 1);
+            }
+        }
+    }
+    return undefined;
+}
+function extractObjectIds(source) {
+    return Array.from(source.matchAll(/\bid\s*:\s*["']([^"']+)["']/g), (match) => match[1]).filter(Boolean);
+}
+function compactId(value) {
+    const compact = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 32);
+    return compact || "thread";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+    return typeof value === "string";
+}

package/dist/lib/cli/scaffold.d.ts

@@ -0,0 +1 @@
+export declare function initProject(projectRoot: string): Promise<void>;

package/dist/lib/cli/scaffold.js

@@ -0,0 +1,56 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function initProject(projectRoot) {
+    const docsDir = path.join(projectRoot, "artifact-docs", "examples");
+    const agentsDir = path.join(projectRoot, "agents");
+    await mkdir(docsDir, { recursive: true });
+    await mkdir(agentsDir, { recursive: true });
+    await writeFile(path.join(projectRoot, "artifact-kit.config.mjs"), `/** @type {import("mdx-artifacts").ArtifactKitConfig} */
+const config = {
+  docsDir: "artifact-docs",
+  outDir: "dist/artifacts",
+  includeDefaultStyles: true,
+  styles: []
+};
+
+export default config;
+`, { flag: "wx" }).catch(ignoreExisting);
+    await writeFile(path.join(agentsDir, "AGENTS.snippet.md"), `# Artifact Kit Agent Instructions
+
+1. Create .mdx files under artifact-docs/.
+2. Prefer Artifact Kit high-level components. Do not generate raw HTML unless explicitly requested.
+3. Interactive artifacts must include ExportPanel or an equivalent export path.
+4. Run artifact-kit components <ComponentName> when component props are unclear.
+5. Run artifact-kit validate <file.mdx> before build.
+6. Run artifact-kit build <file.mdx> to produce standalone HTML.
+`, { flag: "wx" }).catch(ignoreExisting);
+    await writeFile(path.join(docsDir, "hello.mdx"), `import { DecisionMatrix, ExportPanel } from "mdx-artifacts/react";
+
+# Hello Artifact
+
+<DecisionMatrix
+  id="decision.initialized"
+  question="Has Artifact Kit been initialized?"
+  options={[
+    {
+      name: "Initialized",
+      pros: ["MDX source exists", "Export panel exists"],
+      cons: ["Real content still needs to be added"],
+      verdict: "Ready to continue generating artifacts"
+    }
+  ]}
+/>
+
+<ExportPanel
+  value={{
+    recommendation: "Continue generating interactive HTML artifacts with MDX and high-level components"
+  }}
+/>
+`, { flag: "wx" }).catch(ignoreExisting);
+    console.log("Artifact Kit initialized.");
+}
+function ignoreExisting(error) {
+    if (error.code !== "EEXIST") {
+        throw error;
+    }
+}

package/dist/lib/cli/types.d.ts

@@ -0,0 +1,7 @@
+export type ArtifactKitConfig = {
+    docsDir?: string;
+    includeDefaultStyles?: boolean;
+    outDir?: string;
+    port?: number;
+    styles?: string[];
+};

package/dist/lib/cli/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/cli/validate.d.ts

@@ -0,0 +1,6 @@
+export type ValidationResult = {
+    errors: string[];
+    warnings: string[];
+};
+export declare function validateMdx(filePath: string): Promise<ValidationResult>;
+export declare function printValidationResult(result: ValidationResult): void;

package/dist/lib/cli/validate.js

@@ -0,0 +1,79 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { componentRegistry } from "../react/registry.js";
+const componentsRequiringStableId = [
+    "Section",
+    "DecisionMatrix",
+    "OptionGrid",
+    "ComparisonSet",
+    "ComparisonSet.Item",
+    "AnnotatedCode",
+    "CodeBlock",
+    "DiffBlock",
+    "Callout"
+];
+export async function validateMdx(filePath) {
+    const result = { errors: [], warnings: [] };
+    if (path.extname(filePath) !== ".mdx") {
+        result.errors.push("Input file must be .mdx.");
+        return result;
+    }
+    let source = "";
+    try {
+        source = await readFile(filePath, "utf8");
+    }
+    catch {
+        result.errors.push(`Failed to read file: ${filePath}`);
+        return result;
+    }
+    if (source.includes("<script")) {
+        result.errors.push("Do not write <script> directly in MDX. Wrap behavior in a controlled component.");
+    }
+    if (!source.includes("ExportPanel") && !source.includes("CommentExport")) {
+        result.warnings.push("ExportPanel or equivalent export component not found. Interactive artifacts should provide an export path.");
+    }
+    if (source.length > 40_000) {
+        result.warnings.push("MDX file is large. Move bulky data to adjacent JSON files.");
+    }
+    const knownComponents = componentRegistry.map((component) => component.name);
+    const usedArtifactComponent = knownComponents.some((name) => source.includes(`<${name}`));
+    if (!usedArtifactComponent) {
+        result.warnings.push("No first-stage high-level artifact component found. Confirm plain MDX is intentional.");
+    }
+    const sourceWithoutStringLiterals = stripStringLiterals(source);
+    for (const componentName of componentsRequiringStableId) {
+        if (hasOpeningTagWithoutProp(sourceWithoutStringLiterals, componentName, "id")) {
+            result.warnings.push(`${componentName} should include a stable id prop so comments and state can use a durable anchorId.`);
+        }
+    }
+    return result;
+}
+export function printValidationResult(result) {
+    for (const error of result.errors) {
+        console.error(`error: ${error}`);
+    }
+    for (const warning of result.warnings) {
+        console.warn(`warn: ${warning}`);
+    }
+    if (result.errors.length === 0 && result.warnings.length === 0) {
+        console.log("validate ok");
+    }
+}
+function stripStringLiterals(source) {
+    return source
+        .replace(/`(?:\\[\s\S]|[^`\\])*`/g, "``")
+        .replace(/"(?:\\.|[^"\\])*"/g, '""')
+        .replace(/'(?:\\.|[^'\\])*'/g, "''");
+}
+function hasOpeningTagWithoutProp(source, componentName, propName) {
+    const escapedName = componentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const tagPattern = new RegExp(`<${escapedName}(?=[\\s>/])[^>]*>`, "g");
+    const propPattern = new RegExp(`\\s${propName}\\s*=`);
+    for (const match of source.matchAll(tagPattern)) {
+        const openingTag = match[0];
+        if (!propPattern.test(openingTag)) {
+            return true;
+        }
+    }
+    return false;
+}