eddev 0.3.38 → 2.0.0-beta.10

package/dist/node/types/block-type.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { objFormat } from "obj-console";
+import chalk from "chalk";
+import { indent } from "../utils/helpers.js";
+import { createReportBuilder } from "../utils/report-builder.js";
+export const BlockMetaSchema = z.object({
+    acfName: z.string(),
+    fileName: z.string(),
+    slug: z.string(),
+    graphqlFieldName: z.string(),
+    title: z.string(),
+    description: z.string().optional(),
+    category: z.string().default("common"),
+    icon: z.string().optional(),
+    keywords: z.array(z.string()).optional(),
+    types: z.array(z.string()),
+    templates: z.array(z.string()).nullable().optional(),
+    mode: z.enum(["preview", "edit", "both"]).default("preview"),
+    tags: z.array(z.string()).default([]),
+    flags: z.record(z.string(), z.any()).default({}),
+    childTags: z.array(z.string()).default([]),
+    childBlocks: z.array(z.string()).default([]),
+    parent: z.array(z.string()).default([]),
+    ancestors: z.array(z.string()).default([]),
+    dynamic: z.boolean().optional().default(false),
+    cache: z.boolean().optional().default(false),
+    allowMultiple: z.boolean().default(true),
+    postMetaBlock: z
+        .object({
+        fieldName: z.string(),
+    })
+        .optional(),
+    frontendMode: z.enum(["hidden", "childrenOnly", "default"]).default("default"),
+    inserter: z.boolean().default(true),
+});
+export function describeBlock(block) {
+    let output = "";
+    output += objFormat({
+        Title: block.title,
+        "ACF Name": JSON.stringify(block.acfName),
+        "Post Types": block.types?.join(", ") ?? "Any",
+        Templates: block.templates?.length ? block.templates.join(", ") : "Any",
+    }, {
+        unfoldDepth: 2,
+        omitBrackets: true,
+        quote: "",
+        omitEolCommas: true,
+        padding: " ",
+    });
+    return output;
+}
+export function describeBlockManifest(manifest) {
+    const log = createReportBuilder();
+    log.info("Discovered " + Object.keys(manifest.blocks).length + " block(s)");
+    const totalWarnings = manifest.validationMessages.filter((m) => m.severity === "warning").length;
+    const totalErrors = manifest.validationMessages.filter((m) => m.severity === "error").length;
+    let lastFolder = "_";
+    for (let blockKey in manifest.blocks) {
+        const folder = blockKey.replace(/\/.*/, "");
+        if (folder !== lastFolder) {
+            log.log("\n" + chalk.hex("#FFA500")(`🗂️  ${folder}/ `));
+            lastFolder = folder;
+        }
+        const block = manifest.blocks[blockKey];
+        const notices = manifest.validationMessages.filter((m) => m.blockKey === blockKey);
+        const hasWarnings = notices.some((m) => m.severity === "warning");
+        const hasErrors = notices.some((m) => m.severity === "error");
+        let statusEmoji = hasWarnings || hasErrors ? "✖" : "✔";
+        let statusColor = hasErrors ? "red" : hasWarnings ? "yellow" : "greenBright";
+        log.log(indent(3, chalk[statusColor](`${statusEmoji} ${block.fileName}`)));
+        for (const notice of notices) {
+            const color = notice.severity === "error" ? "red" : "yellow";
+            log.log(indent(5, chalk[color](notice.message)));
+        }
+        log.log(indent(4, describeBlock(block)));
+    }
+    if (totalWarnings > 0)
+        log.warn(totalWarnings + " warning(s) while loading block metadata");
+    if (totalErrors > 0)
+        log.fail(totalErrors + " error(s) while loading block metadata");
+    return log.toString();
+}

package/dist/node/types/view-type.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { ViewManifest } from "../project/manifest/view-manifest.js";
+export declare const ViewMetaSchema: z.ZodObject<{
+    fileName: z.ZodString;
+    slug: z.ZodString;
+    title: z.ZodString;
+    isCustomTemplate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    routePattern: z.ZodOptional<z.ZodString>;
+    postType: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    cache: boolean;
+    fileName: string;
+    slug: string;
+    title: string;
+    isCustomTemplate: boolean;
+    routePattern?: string | undefined;
+    postType?: string[] | undefined;
+}, {
+    fileName: string;
+    slug: string;
+    title: string;
+    cache?: boolean | undefined;
+    isCustomTemplate?: boolean | undefined;
+    routePattern?: string | undefined;
+    postType?: string[] | undefined;
+}>;
+export type ViewMetadata = z.infer<typeof ViewMetaSchema>;
+export type ViewMetadataConstructor = z.input<typeof ViewMetaSchema>;
+export declare function describeView(view: ViewMetadata): string;
+export declare function describeViewManifest(manifest: ViewManifest): void;

package/dist/node/types/view-type.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { objFormat } from "obj-console";
+import chalk from "chalk";
+import { indent } from "../utils/helpers.js";
+export const ViewMetaSchema = z.object({
+    fileName: z.string(),
+    slug: z.string(),
+    title: z.string(),
+    isCustomTemplate: z.boolean().optional().default(false),
+    cache: z.boolean().optional().default(false),
+    routePattern: z.string().optional(),
+    postType: z.array(z.string()).optional(),
+});
+export function describeView(view) {
+    let output = "";
+    output += objFormat({
+        Type: view.isCustomTemplate ? "Page Template" : "Wordpress Hierarchy",
+        Title: view.title ?? "(no title)",
+        Slug: view.slug,
+    }, {
+        unfoldDepth: 2,
+        omitBrackets: true,
+        quote: "",
+        omitEolCommas: true,
+        padding: " ",
+    });
+    return output;
+}
+export function describeViewManifest(manifest) {
+    console.log("View Manifest");
+    console.info("Discovered " + Object.keys(manifest.views).length + " view(s)");
+    const totalWarnings = manifest.validationMessages.filter((m) => m.severity === "warning").length;
+    const totalErrors = manifest.validationMessages.filter((m) => m.severity === "error").length;
+    let lastFolder = "_";
+    for (let viewKey in manifest.views) {
+        const view = manifest.views[viewKey];
+        const notices = manifest.validationMessages.filter((m) => m.viewKey === viewKey);
+        const hasWarnings = notices.some((m) => m.severity === "warning");
+        const hasErrors = notices.some((m) => m.severity === "error");
+        let statusEmoji = hasWarnings || hasErrors ? "✖" : "✔";
+        let statusColor = hasErrors ? "red" : hasWarnings ? "yellow" : "blue";
+        console.log(indent(3, chalk[statusColor](`${statusEmoji} ${view.fileName}`)));
+        for (const notice of notices) {
+            const color = notice.severity === "error" ? "red" : "yellow";
+            console.log(indent(5, chalk[color](notice.message)));
+        }
+        console.log(indent(4, describeView(view)));
+    }
+    if (totalWarnings > 0)
+        console.warn(totalWarnings + " warning(s) while loading view metadata");
+    if (totalErrors > 0)
+        console.warn(totalErrors + " error(s) while loading view metadata");
+}

package/dist/node/utils/format-zod-error.d.ts

@@ -0,0 +1,3 @@
+import { ZodError } from "zod-validation-error";
+export declare function formatZodError(error: ZodError): string;
+export declare function eachFormattedZodError(error: ZodError): string[];

package/dist/node/utils/format-zod-error.js

@@ -0,0 +1,33 @@
+import * as zodFormatter from "zod-validation-error";
+export function formatZodError(error) {
+    const result = zodFormatter.fromZodError(error, {
+        issueSeparator: "\n- ",
+        prefix: "",
+        prefixSeparator: "",
+    });
+    return ("- " +
+        result.details
+            .map((d) => {
+            if (d.path.length > 0) {
+                return `'$.${d.path.join("")}': ${d.message}`;
+            }
+            else {
+                return d.message;
+            }
+        })
+            .join("\n- "));
+}
+export function eachFormattedZodError(error) {
+    const result = zodFormatter.fromZodError(error, {
+        prefix: "",
+        prefixSeparator: "",
+    });
+    return result.details.map((d) => {
+        if (d.path.length > 0) {
+            return `'$.${d.path.join("")}': ${d.message}`;
+        }
+        else {
+            return d.message;
+        }
+    });
+}

package/dist/node/utils/fs-codegen.d.ts

@@ -0,0 +1,40 @@
+import { Code } from "ts-poet";
+import { Project } from "../project/project.js";
+type VirtualFile = {
+    name: string;
+    content: string | Code;
+};
+type CodeGenerator = {
+    getFiles(): Promise<VirtualFile | VirtualFile[] | null>;
+    susbcribe?(callback: () => void): () => void;
+};
+/**
+ * A codegen utility that allows you to procedurally and reactively generate files, to be flushed to the FS.
+ */
+export declare class FSCodegen {
+    project: Project;
+    opts: {
+        outDir: string;
+    };
+    outDir: string;
+    private generators;
+    private generatorFiles;
+    private unsubscribers;
+    private flushScheduled;
+    constructor(project: Project, opts: {
+        outDir: string;
+    });
+    register(generator: CodeGenerator): void;
+    registerFile({ name, generate, subscribe, }: {
+        name: string;
+        generate: (() => string | Code | Promise<string | Code>) | string | Code;
+        subscribe?: (callback: () => void) => () => void;
+    }): void;
+    private runGenerator;
+    scheduleFlush(): void;
+    runAndWatch(): Promise<void>;
+    run(): Promise<void>;
+    private flush;
+    stop(): void;
+}
+export {};

package/dist/node/utils/fs-codegen.js

@@ -0,0 +1,97 @@
+import { Code } from "ts-poet";
+import { globby } from "globby";
+import { fs } from "./fs.js";
+import { join, resolve } from "path";
+/**
+ * A codegen utility that allows you to procedurally and reactively generate files, to be flushed to the FS.
+ */
+export class FSCodegen {
+    project;
+    opts;
+    outDir;
+    generators = new Set();
+    generatorFiles = new Map();
+    unsubscribers = new Set();
+    flushScheduled = false;
+    constructor(project, opts) {
+        this.project = project;
+        this.opts = opts;
+        this.outDir = opts.outDir;
+    }
+    register(generator) {
+        this.generators.add(generator);
+    }
+    registerFile({ name, generate, subscribe, }) {
+        this.register({
+            async getFiles() {
+                return {
+                    name,
+                    content: generate instanceof Code ? generate.toString() : typeof generate === "string" ? generate : await generate(),
+                };
+            },
+            susbcribe: subscribe,
+        });
+    }
+    async runGenerator(generator) {
+        const files = await generator.getFiles();
+        this.generatorFiles.set(generator, files ? (Array.isArray(files) ? files : [files]) : []);
+        this.scheduleFlush();
+    }
+    scheduleFlush() {
+        if (this.flushScheduled) {
+            return;
+        }
+        this.flushScheduled = true;
+        setTimeout(() => {
+            this.flushScheduled = false;
+            this.flush();
+        }, 100);
+    }
+    async runAndWatch() {
+        await Promise.all(Array.from(this.generators).map((generator) => {
+            return new Promise((resolve) => {
+                let first = true;
+                if (generator.susbcribe) {
+                    // Subscribe and run at least once
+                    this.unsubscribers.add(generator.susbcribe(() => {
+                        if (first) {
+                            first = false;
+                            this.runGenerator(generator).then(resolve);
+                        }
+                        else {
+                            this.runGenerator(generator);
+                        }
+                    }));
+                }
+                else {
+                    // Just run once, since there is no subscriber
+                    this.runGenerator(generator).then(resolve);
+                }
+            });
+        }));
+        await this.flush();
+    }
+    async run() {
+        await Promise.all(Array.from(this.generators).map((generator) => this.runGenerator(generator)));
+        await this.flush();
+    }
+    async flush() {
+        const files = Array.from(this.generatorFiles.values()).flat();
+        const existing = (await globby(this.outDir + "/**/*")).map((path) => resolve(this.project.rootDir, path));
+        const written = new Set();
+        await Promise.all(files.map(async (file) => {
+            const path = join(this.project.rootDir, this.outDir, file.name);
+            written.add(resolve(this.project.rootDir, path));
+            await fs.writeIfUnchanged(path, file.content.toString());
+        }));
+        await Promise.all(existing.map(async (path) => {
+            if (!written.has(path)) {
+                await fs.rm(path);
+            }
+        }));
+    }
+    stop() {
+        this.unsubscribers.forEach((unsub) => unsub());
+        this.unsubscribers.clear();
+    }
+}

package/dist/node/utils/fs.d.ts

@@ -0,0 +1,106 @@
+import * as nodeFs from "fs/promises";
+export declare const fs: {
+    writeIfUnchanged: (path: string, content: string) => Promise<true | undefined>;
+    writeJsonIfUnchanged: (path: string, content: any, pretty?: boolean) => Promise<true | undefined>;
+    writeJson: (path: string, content: any, pretty?: boolean) => Promise<void>;
+    readJson: (path: string) => Promise<any>;
+    exists: (path: string) => Promise<boolean>;
+    mkdirp: (path: string) => Promise<void>;
+    access(path: import("fs").PathLike, mode?: number): Promise<void>;
+    copyFile(src: import("fs").PathLike, dest: import("fs").PathLike, mode?: number): Promise<void>;
+    open(path: import("fs").PathLike, flags?: string | number, mode?: import("fs").Mode): Promise<nodeFs.FileHandle>;
+    rename(oldPath: import("fs").PathLike, newPath: import("fs").PathLike): Promise<void>;
+    truncate(path: import("fs").PathLike, len?: number): Promise<void>;
+    rmdir(path: import("fs").PathLike, options?: import("fs").RmDirOptions): Promise<void>;
+    rm(path: import("fs").PathLike, options?: import("fs").RmOptions): Promise<void>;
+    mkdir(path: import("fs").PathLike, options: import("fs").MakeDirectoryOptions & {
+        recursive: true;
+    }): Promise<string | undefined>;
+    mkdir(path: import("fs").PathLike, options?: import("fs").Mode | (import("fs").MakeDirectoryOptions & {
+        recursive?: false | undefined;
+    }) | null): Promise<void>;
+    mkdir(path: import("fs").PathLike, options?: import("fs").Mode | import("fs").MakeDirectoryOptions | null): Promise<string | undefined>;
+    readdir(path: import("fs").PathLike, options?: (import("fs").ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | BufferEncoding | null): Promise<string[]>;
+    readdir(path: import("fs").PathLike, options: {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    } | "buffer"): Promise<Buffer[]>;
+    readdir(path: import("fs").PathLike, options?: (import("fs").ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | BufferEncoding | null): Promise<string[] | Buffer[]>;
+    readdir(path: import("fs").PathLike, options: import("fs").ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Promise<import("fs").Dirent[]>;
+    readlink(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+    readlink(path: import("fs").PathLike, options: import("fs").BufferEncodingOption): Promise<Buffer>;
+    readlink(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | string | null): Promise<string | Buffer>;
+    symlink(target: import("fs").PathLike, path: import("fs").PathLike, type?: string | null): Promise<void>;
+    lstat(path: import("fs").PathLike, opts?: import("fs").StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<import("fs").Stats>;
+    lstat(path: import("fs").PathLike, opts: import("fs").StatOptions & {
+        bigint: true;
+    }): Promise<import("fs").BigIntStats>;
+    lstat(path: import("fs").PathLike, opts?: import("fs").StatOptions): Promise<import("fs").Stats | import("fs").BigIntStats>;
+    stat(path: import("fs").PathLike, opts?: import("fs").StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<import("fs").Stats>;
+    stat(path: import("fs").PathLike, opts: import("fs").StatOptions & {
+        bigint: true;
+    }): Promise<import("fs").BigIntStats>;
+    stat(path: import("fs").PathLike, opts?: import("fs").StatOptions): Promise<import("fs").Stats | import("fs").BigIntStats>;
+    statfs(path: import("fs").PathLike, opts?: import("fs").StatFsOptions & {
+        bigint?: false | undefined;
+    }): Promise<import("fs").StatsFs>;
+    statfs(path: import("fs").PathLike, opts: import("fs").StatFsOptions & {
+        bigint: true;
+    }): Promise<import("fs").BigIntStatsFs>;
+    statfs(path: import("fs").PathLike, opts?: import("fs").StatFsOptions): Promise<import("fs").StatsFs | import("fs").BigIntStatsFs>;
+    link(existingPath: import("fs").PathLike, newPath: import("fs").PathLike): Promise<void>;
+    unlink(path: import("fs").PathLike): Promise<void>;
+    chmod(path: import("fs").PathLike, mode: import("fs").Mode): Promise<void>;
+    lchmod(path: import("fs").PathLike, mode: import("fs").Mode): Promise<void>;
+    lchown(path: import("fs").PathLike, uid: number, gid: number): Promise<void>;
+    lutimes(path: import("fs").PathLike, atime: import("fs").TimeLike, mtime: import("fs").TimeLike): Promise<void>;
+    chown(path: import("fs").PathLike, uid: number, gid: number): Promise<void>;
+    utimes(path: import("fs").PathLike, atime: import("fs").TimeLike, mtime: import("fs").TimeLike): Promise<void>;
+    realpath(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+    realpath(path: import("fs").PathLike, options: import("fs").BufferEncodingOption): Promise<Buffer>;
+    realpath(path: import("fs").PathLike, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
+    mkdtemp(prefix: string, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+    mkdtemp(prefix: string, options: import("fs").BufferEncodingOption): Promise<Buffer>;
+    mkdtemp(prefix: string, options?: import("fs").ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
+    writeFile(file: import("fs").PathLike | nodeFs.FileHandle, data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView> | import("stream").Stream, options?: (import("fs").ObjectEncodingOptions & {
+        mode?: import("fs").Mode | undefined;
+        flag?: import("fs").OpenMode | undefined;
+        flush?: boolean | undefined;
+    } & import("events").Abortable) | BufferEncoding | null): Promise<void>;
+    appendFile(path: import("fs").PathLike | nodeFs.FileHandle, data: string | Uint8Array, options?: (import("fs").ObjectEncodingOptions & nodeFs.FlagAndOpenMode & {
+        flush?: boolean | undefined;
+    }) | BufferEncoding | null): Promise<void>;
+    readFile(path: import("fs").PathLike | nodeFs.FileHandle, options?: ({
+        encoding?: null | undefined;
+        flag?: import("fs").OpenMode | undefined;
+    } & import("events").Abortable) | null): Promise<Buffer>;
+    readFile(path: import("fs").PathLike | nodeFs.FileHandle, options: ({
+        encoding: BufferEncoding;
+        flag?: import("fs").OpenMode | undefined;
+    } & import("events").Abortable) | BufferEncoding): Promise<string>;
+    readFile(path: import("fs").PathLike | nodeFs.FileHandle, options?: (import("fs").ObjectEncodingOptions & import("events").Abortable & {
+        flag?: import("fs").OpenMode | undefined;
+    }) | BufferEncoding | null): Promise<string | Buffer>;
+    opendir(path: import("fs").PathLike, options?: import("fs").OpenDirOptions): Promise<import("fs").Dir>;
+    watch(filename: import("fs").PathLike, options: (import("fs").WatchOptions & {
+        encoding: "buffer";
+    }) | "buffer"): AsyncIterable<nodeFs.FileChangeInfo<Buffer>>;
+    watch(filename: import("fs").PathLike, options?: import("fs").WatchOptions | BufferEncoding): AsyncIterable<nodeFs.FileChangeInfo<string>>;
+    watch(filename: import("fs").PathLike, options: import("fs").WatchOptions | string): AsyncIterable<nodeFs.FileChangeInfo<string>> | AsyncIterable<nodeFs.FileChangeInfo<Buffer>>;
+    cp(source: string | URL, destination: string | URL, opts?: import("fs").CopyOptions): Promise<void>;
+    constants: typeof import("fs").constants;
+};

package/dist/node/utils/fs.js

@@ -0,0 +1,58 @@
+import * as nodeFs from "fs/promises";
+import { dirname } from "path";
+export const fs = {
+    ...nodeFs,
+    writeIfUnchanged: async (path, content) => {
+        await fs.mkdirp(dirname(path));
+        try {
+            const currentContent = await nodeFs.readFile(path, "utf8");
+            if (currentContent === content)
+                return;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        await nodeFs.writeFile(path, content);
+        return true;
+    },
+    writeJsonIfUnchanged: async (path, content, pretty = true) => {
+        let stringified = JSON.stringify(content, null, pretty ? 2 : 0);
+        try {
+            const currentContent = await nodeFs.readFile(path, "utf8");
+            if (currentContent === stringified)
+                return;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        await nodeFs.writeFile(path, stringified);
+        return true;
+    },
+    writeJson: async (path, content, pretty = true) => {
+        await nodeFs.writeFile(path, JSON.stringify(content, null, pretty ? 2 : 0));
+    },
+    readJson: async (path) => {
+        const contents = await nodeFs.readFile(path, "utf8");
+        return JSON.parse(contents);
+    },
+    exists: async (path) => {
+        try {
+            await nodeFs.stat(path);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    },
+    mkdirp: async (path) => {
+        try {
+            await nodeFs.mkdir(path, { recursive: true });
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+        }
+    },
+};

package/dist/node/utils/get-repo-info.d.ts

@@ -0,0 +1,7 @@
+type RepoInfo = {
+    repoURL?: string;
+    repoName: string | undefined;
+    themeName: string;
+};
+export declare function getRepoInfo(dir: string): Promise<RepoInfo>;
+export {};

package/dist/node/utils/get-repo-info.js

@@ -0,0 +1,21 @@
+import Path from "path";
+import * as fs from "fs/promises";
+export async function getRepoInfo(dir) {
+    if (process.env.VERCEL) {
+        return {
+            repoName: process.env.VERCEL_GIT_REPO_SLUG,
+            themeName: process.env.VERCEL_GIT_REPO_SLUG,
+        };
+    }
+    else {
+        const contents = await fs.readFile(Path.join(dir, ".git", "config"), "utf8");
+        const repoURL = contents.match(/url = (.*)/)?.[1];
+        const themeName = Path.basename(dir);
+        const repoName = repoURL?.match(/([^/]+)\.git$/)?.[1];
+        return {
+            repoURL,
+            repoName,
+            themeName,
+        };
+    }
+}

package/dist/node/utils/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const indentAllButFirst: (count: number, str: string) => string;
+export declare const indent: (count: number, str: string) => string;

package/dist/node/utils/helpers.js

@@ -0,0 +1,14 @@
+export const indentAllButFirst = (count, str) => {
+    const indent = " ".repeat(count);
+    return str
+        .split("\n")
+        .map((line, i) => (i === 0 ? line : indent + line))
+        .join("\n");
+};
+export const indent = (count, str) => {
+    const indent = " ".repeat(count);
+    return str
+        .split("\n")
+        .map((line) => indent + line)
+        .join("\n");
+};

package/dist/node/utils/highlight-code.d.ts

@@ -0,0 +1,10 @@
+export declare function highlightCode(opts: {
+    code: string;
+    fileName: string;
+    language?: string;
+    error?: string;
+    pointTo?: {
+        line: number;
+        column: number;
+    };
+}): string;

package/dist/node/utils/highlight-code.js

@@ -0,0 +1,30 @@
+import chalk from "chalk";
+export function highlightCode(opts) {
+    // const highlighted = highlight(opts.code, {
+    //   ignoreIllegals: true,
+    //   languageSubset: opts.language ? [opts.language] : undefined,
+    // })
+    const highlighted = opts.code;
+    let lines = highlighted.split("\n");
+    let lineNumberLength = String(lines.length).length;
+    lines = lines.map((line, i) => {
+        return `${chalk.dim(String(i + 1).padEnd(lineNumberLength, " "))} | ${line}`;
+    });
+    // If we're pointing to a line, show the last 3 lines before it
+    if (opts.pointTo) {
+        lines = lines.slice(Math.max(0, opts.pointTo.line - 5), opts.pointTo.line);
+        lines.push(" ".repeat(lineNumberLength + 2 + opts.pointTo.column) + chalk.red("^"));
+    }
+    if (opts.fileName) {
+        if (opts.pointTo) {
+            lines.unshift(chalk.dim(`${opts.fileName}:${opts.pointTo.line}:${opts.pointTo.column}`));
+        }
+        else {
+            lines.unshift(chalk.dim(`${opts.fileName}:`));
+        }
+    }
+    if (opts.error) {
+        lines.push(chalk.red(opts.error));
+    }
+    return lines.join("\n");
+}

package/dist/node/utils/is-deploying.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns true if we think that the compiler is running in a deployment context (Vercel, GitHub Actions, etc.)
+ */
+export declare function isDeploying(): boolean;

package/dist/node/utils/is-deploying.js

@@ -0,0 +1,6 @@
+/**
+ * Returns true if we think that the compiler is running in a deployment context (Vercel, GitHub Actions, etc.)
+ */
+export function isDeploying() {
+    return !!process.env.VERCEL;
+}

package/dist/node/utils/report-builder.d.ts

@@ -0,0 +1,9 @@
+export declare function createReportBuilder(): {
+    log(...values: any[]): any;
+    warn(...values: any[]): any;
+    fail(...values: any[]): any;
+    info(...values: any[]): any;
+    help(...values: any[]): any;
+    success(...values: any[]): any;
+    toString(): string;
+};