eddev 0.3.35 → 2.0.0-beta.2

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,54 @@
+import { z } from "zod";
+import { objFormat } from "obj-console";
+import { console } from "../utils/console.js";
+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.heading("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.failish(totalWarnings + " warning(s) while loading view metadata");
+    if (totalErrors > 0)
+        console.fail(totalErrors + " error(s) while loading view metadata");
+}

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

@@ -0,0 +1,21 @@
+import { ConsolaInstance, LogLevel } from "consola";
+export declare const logger: ConsolaInstance;
+export declare const console: {
+    setLevel: (level: LogLevel) => void;
+    failish: (message: string) => void;
+    heading: (message: string) => void;
+    log: (message: any, ...args: any[]) => void;
+    verbose: (message: any, ...args: any[]) => void;
+    info: (message: any, ...args: any[]) => void;
+    warn: (message: any, ...args: any[]) => void;
+    error: (message: any, ...args: any[]) => void;
+    fail: (message: any, ...args: any[]) => void;
+    success: (message: any, ...args: any[]) => void;
+    ready: (message: any, ...args: any[]) => void;
+    silent: (message: any, ...args: any[]) => void;
+    fatal: (message: any, ...args: any[]) => void;
+    start: (message: any, ...args: any[]) => void;
+    box: (message: any, ...args: any[]) => void;
+    debug: (message: any, ...args: any[]) => void;
+    trace: (message: any, ...args: any[]) => void;
+};

package/dist/node/utils/console.js

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+import { createConsola } from "consola";
+import { box } from "consola/utils";
+export const logger = createConsola({
+    formatOptions: {
+        date: false,
+    },
+});
+const funcs = logger;
+export const console = {
+    ...funcs,
+    setLevel: (level) => {
+        logger.level = level;
+    },
+    failish: (message) => {
+        console.log(chalk.hex("#FFA500")("⚠") + " " + message);
+    },
+    heading: (message) => {
+        logger.log(box(" " + message + " ", {
+            style: {
+                borderColor: "magenta",
+                padding: 0,
+                marginLeft: 0,
+                marginBottom: 0,
+            },
+        }));
+    },
+};

package/dist/node/utils/export-extractor.d.ts

@@ -0,0 +1,9 @@
+export declare class ExportExtractor {
+    exportName: string;
+    cache: Map<string, any>;
+    constructor(exportName: string);
+    extract(file: string, contents: string, force?: boolean): any;
+    private extractExpressionValue;
+    invalidate(name: string): void;
+}
+export declare const metaExtractor: ExportExtractor;

package/dist/node/utils/export-extractor.js

@@ -0,0 +1,71 @@
+import ts from "typescript";
+export class ExportExtractor {
+    exportName;
+    cache = new Map();
+    constructor(exportName) {
+        this.exportName = exportName;
+        // this.program
+    }
+    extract(file, contents, force = false) {
+        if (this.cache.has(file) && !force)
+            return this.cache.get(file);
+        let result = null;
+        // const program = ts.createProgram([file], {
+        //   jsx: ts.JsxEmit.React,
+        // })
+        const source = ts.createSourceFile(file, contents, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+        if (source) {
+            ts.forEachChild(source, (node) => {
+                /**
+                 * export const meta = any
+                 */
+                if (ts.isVariableStatement(node) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+                    node.declarationList.declarations.forEach((node) => {
+                        if (ts.isIdentifier(node.name) && node.name.text === this.exportName) {
+                            if (node.initializer) {
+                                result = this.extractExpressionValue(node.initializer);
+                            }
+                        }
+                    });
+                }
+            });
+        }
+        this.cache.set(file, result);
+        return result;
+    }
+    extractExpressionValue(node) {
+        if (ts.isObjectLiteralExpression(node)) {
+            const obj = {};
+            for (const prop of node.properties) {
+                if (ts.isPropertyAssignment(prop)) {
+                    if (ts.isIdentifier(prop.name)) {
+                        obj[prop.name.text] = this.extractExpressionValue(prop.initializer);
+                    }
+                }
+            }
+            return obj;
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            return node.elements.map((e) => this.extractExpressionValue(e));
+        }
+        else if (ts.isStringLiteral(node)) {
+            return node.text;
+        }
+        else if (ts.isNumericLiteral(node)) {
+            return parseFloat(node.text);
+        }
+        else if (node.kind === ts.SyntaxKind.TrueKeyword) {
+            return true;
+        }
+        else if (node.kind === ts.SyntaxKind.FalseKeyword) {
+            return false;
+        }
+        else {
+            return undefined;
+        }
+    }
+    invalidate(name) {
+        this.cache.delete(name);
+    }
+}
+export const metaExtractor = new ExportExtractor("meta");

package/dist/node/utils/formatZodError.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/formatZodError.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.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,56 @@
+import * as nodeFs from "fs/promises";
+export const fs = {
+    ...nodeFs,
+    writeIfUnchanged: async (path, content) => {
+        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/getRepoInfo.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/getRepoInfo.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/highlightCode.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/highlightCode.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/isDeploying.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/isDeploying.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;
+};