eddev 0.3.35 → 2.0.0-beta.2

package/dist/node/project/manifest/manifest.js

@@ -0,0 +1,105 @@
+import { getFileTree, watchFileTree } from "../../utils/watchFileTree.js";
+import { relative } from "path";
+export function createManifestGenerator(args) {
+    let subscribers = new Set();
+    let files = [];
+    let cache = new Map();
+    let disposed = false;
+    let disposers = [];
+    let debouncer = 0;
+    disposers.push(() => {
+        clearTimeout(debouncer);
+    });
+    let value = null;
+    async function load() {
+        let resolvedFirst = false;
+        return new Promise(async (resolve) => {
+            files = [];
+            let events = [];
+            const update = async () => {
+                value = await generate(files);
+                clearTimeout(debouncer);
+                debouncer = setTimeout(() => {
+                    if (!disposed)
+                        subscribers.forEach((func) => func(value, events));
+                    events = [];
+                }, 200);
+                if (!resolvedFirst) {
+                    resolvedFirst = true;
+                    resolve(value);
+                    events = [];
+                }
+            };
+            if (args.watch) {
+                const disposer = await watchFileTree(args.pattern, (fileList, event) => {
+                    files = fileList;
+                    cache = new Map();
+                    if (args.onFileChange)
+                        fileList.forEach(args.onFileChange);
+                    update();
+                    if (event) {
+                        events.push(event);
+                    }
+                });
+                disposers.push(disposer);
+            }
+            else {
+                files = await getFileTree(args.pattern);
+                update();
+            }
+        });
+    }
+    async function generate(files) {
+        const entries = {};
+        await Promise.all(files.map(async (file) => {
+            const key = args.getKey(file);
+            if (key === null)
+                return;
+            const value = await args.loadValue(file, key);
+            entries[key] = {
+                key,
+                relativePath: relative(args.baseDir, file),
+                fullPath: file,
+                value,
+            };
+        }));
+        return args.generateManifest(entries);
+    }
+    let hasBooted = false;
+    return {
+        dispose() {
+            disposed = true;
+            disposers.forEach((disposer) => disposer());
+        },
+        subscribe(callback) {
+            if (!hasBooted) {
+                load();
+                hasBooted = true;
+            }
+            subscribers.add(callback);
+            if (value) {
+                setImmediate(() => callback(value));
+            }
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        subscribeFuture(callback) {
+            subscribers.add(callback);
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        get() {
+            return new Promise((resolve) => {
+                const disposer = this.subscribe((manifest) => {
+                    resolve(manifest);
+                    disposer();
+                });
+            });
+        },
+        getLast() {
+            return value;
+        },
+    };
+}

package/dist/node/project/manifest/view-manifest.d.ts

@@ -0,0 +1,19 @@
+import { ViewMetadata, ViewMetadataConstructor } from "../../types/view-type.js";
+import { Project } from "../project.js";
+export type ViewManifest = {
+    views: {
+        [K: string]: ViewMetadata;
+    };
+    validationMessages: {
+        viewKey: string;
+        message: string;
+        severity: "error" | "warning";
+    }[];
+};
+type ViewLoadResult = {
+    data: ViewMetadataConstructor | null;
+    error?: string;
+};
+export type ViewManifestGenerator = ReturnType<typeof loadViewManifest>;
+export declare function loadViewManifest(project: Project): import("./manifest.js").ManifestGenerator<ViewLoadResult, ViewManifest>;
+export {};

package/dist/node/project/manifest/view-manifest.js

@@ -0,0 +1,152 @@
+import { basename } from "node:path";
+import { cliMode } from "../../cli/cli-mode.js";
+import { ViewMetaSchema } from "../../types/view-type.js";
+import { metaExtractor } from "../../utils/export-extractor.js";
+import { formatZodError } from "../../utils/formatZodError.js";
+import { fs } from "../../utils/fs.js";
+import { createManifestGenerator } from "./manifest.js";
+export function loadViewManifest(project) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: "views/**/*.tsx",
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {
+                views: {},
+                validationMessages: [],
+            };
+            Object.entries(entries)
+                .sort(([b1], [b2]) => {
+                return b1.localeCompare(b2);
+            })
+                .forEach(([key, entry]) => {
+                const { data, error: initialError } = entry.value;
+                // Add the view to the manifest, even though it might be broken.
+                // Any broken views will have warnings/errors attached.
+                result.views[key] = data;
+                // If there was an error loading the view, add it to the manifest
+                if (initialError) {
+                    result.validationMessages.push({
+                        viewKey: key,
+                        message: initialError,
+                        severity: "error",
+                    });
+                    return;
+                }
+                else {
+                    // Validate the structure of the metadata
+                    const parsed = ViewMetaSchema.safeParse(data);
+                    if (parsed.success) {
+                        // The view metadata matches our schema, and may have been transformed
+                        result.views[key] = parsed.data;
+                    }
+                    else {
+                        result.validationMessages.push({
+                            viewKey: key,
+                            message: "Metadata validation error:\n" + formatZodError(parsed.error),
+                            severity: "warning",
+                        });
+                    }
+                }
+            });
+            return result;
+        },
+        getKey(path) {
+            // Strip the views folder name + extension
+            return path.replace(/\.tsx$/, "").replace(/^views\//, "");
+        },
+        onFileChange(path) {
+            metaExtractor.invalidate(path);
+        },
+        async loadValue(path, key) {
+            const contents = await fs.readFile(path, "utf8");
+            // Start with a default value
+            let metadata = {
+                fileName: path,
+                slug: key,
+                title: key,
+                cache: true,
+            };
+            let result = null;
+            /**
+             * If the project is configured to use legacy metadata, read the metadata from
+             * the comment header.
+             *
+             * Otherwise, we'll pull it as JSON straight from the .tsx file
+             */
+            if (project.config?.legacyMetadata) {
+                result = readViewDataAsComment(contents);
+            }
+            else {
+                result = readViewDataAsJSONExport(path, contents);
+            }
+            if (result) {
+                Object.assign(metadata, result);
+            }
+            // Compute the various names for this view
+            return {
+                data: metadata,
+            };
+        },
+    });
+}
+/**
+ * Rip the JSON metadata directly from the .tsx file
+ */
+function readViewDataAsJSONExport(file, contents) {
+    const userData = metaExtractor.extract(file, contents);
+    if (!userData)
+        return null;
+    const result = {};
+    if (userData.templateName) {
+        const name = basename(file);
+        result.title = userData.templateName;
+        result.isCustomTemplate = true;
+        const inferredPostTypes = name
+            .match(/^single-(.+)\.tsx$/i)?.[1]
+            .split("-")
+            .map((_frag, i, arr) => {
+            return arr.slice(0, i + 1).join("-");
+        });
+        result.postType = Array.isArray(userData.postType)
+            ? userData.postType
+            : typeof userData.postType === "string"
+                ? [userData.postType]
+                : inferredPostTypes
+                    ? inferredPostTypes
+                    : ["page"];
+    }
+    result.cache = userData.cache;
+    return result;
+}
+/**
+ * Parse as a legacy comment header
+ */
+function readViewDataAsComment(file) {
+    let meta = {};
+    // Ensure the comment header is set
+    if (!/^\/\*.+?\*\//s.test(file))
+        return null;
+    // Get the comment section
+    const commentSection = file.match(/^.+\*\//s);
+    if (!commentSection)
+        return null;
+    const lines = commentSection[0].split("\n");
+    lines.forEach((line, i) => {
+        const match = line.match(/\s*\*?\s*([^:]+):\s*(.+)\s*/);
+        if (!match)
+            return;
+        let key = match[1].replace(/\s/g, "").toLocaleLowerCase();
+        let value = match[2].trim();
+        switch (key) {
+            case "templatename":
+                meta.title = value;
+                meta.isCustomTemplate = true;
+                return;
+            case "cache":
+                meta.cache = value === "true";
+                return;
+        }
+    });
+    return meta;
+}

package/dist/node/project/manifest/widget-manifest.d.ts

@@ -0,0 +1,17 @@
+import { Project } from "../project.js";
+export type WidgetManifest = {
+    widgets: Record<string, WidgetInfo>;
+    validationMessages: {
+        fieldKey: string;
+        message: string;
+        severity: "error" | "warning";
+    }[];
+};
+type WidgetInfo = {
+    slug: string;
+    fileName: string;
+    error?: string;
+};
+export type WidgetManifestGenerator = ReturnType<typeof loadWidgetManifest>;
+export declare function loadWidgetManifest(project: Project): import("./manifest.js").ManifestGenerator<WidgetInfo, WidgetManifest>;
+export {};

package/dist/node/project/manifest/widget-manifest.js

@@ -0,0 +1,42 @@
+import { cliMode } from "../../cli/cli-mode.js";
+import { createManifestGenerator } from "./manifest.js";
+export function loadWidgetManifest(project) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: "backend/widgets/*.tsx",
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {
+                widgets: {},
+                validationMessages: [],
+            };
+            Object.entries(entries)
+                .sort(([b1], [b2]) => {
+                return b1.localeCompare(b2);
+            })
+                .forEach(([key, entry]) => {
+                const { error: initialError } = entry.value;
+                result.widgets[key] = entry.value;
+                if (initialError) {
+                    result.validationMessages.push({
+                        fieldKey: key,
+                        message: initialError,
+                        severity: "error",
+                    });
+                    return;
+                }
+            });
+            return result;
+        },
+        getKey(path) {
+            // Strip the views folder name + extension
+            return path.replace(/\.tsx$/, "").replace(/^backend\/widgets\//, "");
+        },
+        async loadValue(fileName, key) {
+            return {
+                slug: key,
+                fileName,
+            };
+        },
+    });
+}

package/dist/node/project/project.d.ts

@@ -0,0 +1,57 @@
+import { EDConfig } from "./config.js";
+import { BlockManifestGenerator } from "./manifest/block-manifest.js";
+import { ViewManifestGenerator } from "./manifest/view-manifest.js";
+import { FieldManifestGenerator } from "./manifest/field-manifest.js";
+import { WidgetManifestGenerator } from "./manifest/widget-manifest.js";
+export declare const projectLog: import("../utils/statefulLog.js").StatefulLog<Project>;
+type ProjectArgs = {
+    rootDir: string;
+    reportPluginCompatibility?: boolean;
+};
+/**
+ * This class represents a single app project created using the stack.
+ * It has methods and properties that are useful for working with the project.
+ */
+export declare class Project {
+    rootDir: string;
+    themeName: string;
+    publicUrl: string;
+    repoUrl: string;
+    configFile: string;
+    config?: EDConfig;
+    blocks: BlockManifestGenerator;
+    views: ViewManifestGenerator;
+    fields: FieldManifestGenerator;
+    widgets: WidgetManifestGenerator;
+    private wp;
+    reportPluginCompatibility: boolean;
+    private constructor();
+    private load;
+    reportProjectInfo(): string;
+    getWordpressInfo(): Promise<{
+        postTypes: {
+            name: string;
+            label: string;
+            hasArchive: boolean;
+            graphqlSingleName: string;
+            graphqlPluralName: string;
+            excludeFromSearch: boolean;
+        }[];
+        plugins: {
+            name: string;
+            slug: string;
+            version: string;
+            url: string;
+        }[];
+        coreBlocks: string[];
+        blockTags: string[];
+        scalarTypes: Record<string, string>;
+        postMetaTypes: {
+            key: string;
+            isScalar: boolean;
+            typeName: string;
+        }[];
+    }>;
+    static create(args: ProjectArgs): Promise<Project>;
+}
+export {};

package/dist/node/project/project.js

@@ -0,0 +1,115 @@
+import * as clack from "@clack/prompts";
+import { relative, resolve } from "path";
+import { undent } from "undent";
+import { cliMode } from "../cli/cli-mode.js";
+// import { console } from "../utils/console.js"
+import { objFormat } from "obj-console";
+import { getRepoInfo } from "../utils/getRepoInfo.js";
+import { isDeploying } from "../utils/isDeploying.js";
+import { createConsole } from "../utils/statefulLog.js";
+import { Configurator } from "./config.js";
+import { loadBlockManifest } from "./manifest/block-manifest.js";
+import { loadViewManifest } from "./manifest/view-manifest.js";
+import { WPInfo } from "./wp-info.js";
+import { ProjectEnvUtils } from "./env.js";
+import { loadFieldManifest } from "./manifest/field-manifest.js";
+import { loadWidgetManifest } from "./manifest/widget-manifest.js";
+const console = createConsole("Project", "project");
+export const projectLog = console;
+/**
+ * This class represents a single app project created using the stack.
+ * It has methods and properties that are useful for working with the project.
+ */
+export class Project {
+    rootDir = "";
+    themeName = "";
+    publicUrl = "";
+    repoUrl = "";
+    configFile = "";
+    config;
+    blocks;
+    views;
+    fields;
+    widgets;
+    wp;
+    reportPluginCompatibility = false;
+    constructor(opts) {
+        this.rootDir = opts.rootDir;
+        this.reportPluginCompatibility = opts.reportPluginCompatibility || false;
+        this.blocks = loadBlockManifest(this);
+        this.views = loadViewManifest(this);
+        this.fields = loadFieldManifest(this);
+        this.widgets = loadWidgetManifest(this);
+        this.wp = new WPInfo(ProjectEnvUtils.get("SITE_URL"));
+    }
+    async load() {
+        console.setWorking(true);
+        console.setState(this);
+        const repoInfo = await getRepoInfo(this.rootDir);
+        this.themeName = repoInfo.themeName;
+        this.publicUrl = `/wp-content/themes/${repoInfo.themeName}/`;
+        this.configFile = relative(process.cwd(), resolve(this.rootDir, "ed.config.json"));
+        this.repoUrl = repoInfo.repoURL?.replace("git@github.com:", "https://github.com/").replace(".git", "") || "";
+        this.reportProjectInfo();
+        /**
+         * Make sure the git repo name matches
+         */
+        if (repoInfo.repoName && repoInfo.repoName !== repoInfo.themeName && !isDeploying()) {
+            console.warn(undent `
+          Theme ↔ Repo Name Mismatch!
+          The folder ('${repoInfo.themeName}') and repo name ('${repoInfo.repoName}') should be the same.
+          The repo name is used for generating the public theme URL, used by assets.
+          
+          You should rename the folder to match the repo name, or vice versa.
+        `);
+            if (cliMode.interactive) {
+                await clack.confirm({
+                    message: `Ignore and continue anyway?`,
+                });
+            }
+            else {
+                console.flush();
+                process.exit(1);
+            }
+        }
+        /**
+         * Load configuration
+         */
+        const configurator = await Configurator.create(this);
+        this.config = configurator.config;
+        /**
+         * Report plugins errors
+         **/
+        if (this.reportPluginCompatibility) {
+            const issues = await this.wp.getPluginIssues().catch(() => []);
+            if (issues.length) {
+                issues.forEach((issue) => console.warn(issue));
+            }
+        }
+        console.setWorking(false);
+        console.info(this.reportProjectInfo());
+    }
+    reportProjectInfo() {
+        return objFormat({
+            "Theme Name": this.themeName,
+            "Theme URL": this.publicUrl,
+            "Repo URL": this.repoUrl,
+            "Config File": this.configFile,
+        }, {
+            unfoldDepth: 2,
+            omitBrackets: true,
+            quote: "",
+            omitEolCommas: true,
+            padding: "",
+        }).trim();
+    }
+    async getWordpressInfo() {
+        const info = await this.wp.getInfo();
+        return info;
+    }
+    static async create(args) {
+        const project = new Project(args);
+        await project.load();
+        return project;
+    }
+}

package/dist/node/project/wp-info.d.ts

@@ -0,0 +1,32 @@
+type WPInfoData = {
+    postTypes: {
+        name: string;
+        label: string;
+        hasArchive: boolean;
+        graphqlSingleName: string;
+        graphqlPluralName: string;
+        excludeFromSearch: boolean;
+    }[];
+    plugins: {
+        name: string;
+        slug: string;
+        version: string;
+        url: string;
+    }[];
+    coreBlocks: string[];
+    blockTags: string[];
+    scalarTypes: Record<string, string>;
+    postMetaTypes: {
+        key: string;
+        isScalar: boolean;
+        typeName: string;
+    }[];
+};
+export declare class WPInfo {
+    siteUrl: string;
+    private cached?;
+    constructor(siteUrl: string);
+    getInfo(force?: boolean): Promise<WPInfoData>;
+    getPluginIssues(): Promise<string[]>;
+}
+export {};

package/dist/node/project/wp-info.js

@@ -0,0 +1,34 @@
+import { resolveURL } from "ufo";
+import { getUnsafeFetch } from "../utils/unsafe-fetch.js";
+export class WPInfo {
+    siteUrl;
+    cached;
+    constructor(siteUrl) {
+        this.siteUrl = siteUrl;
+    }
+    async getInfo(force = false) {
+        if (this.cached && !force)
+            return this.cached;
+        const url = resolveURL(this.siteUrl, "/wp-json/ed/v1/dev/site-info");
+        const fetch = getUnsafeFetch(this.siteUrl);
+        const response = await fetch(url);
+        const result = (await response.json());
+        this.cached = result;
+        return result;
+    }
+    async getPluginIssues() {
+        const info = await this.getInfo();
+        if (!info)
+            return [];
+        const issues = [];
+        info.plugins.forEach((plugin) => {
+            if (plugin.name.includes("Disable Comments")) {
+                issues.push(`The "Disable Comments" plugin is not needed, as comments are now disabled by default.`);
+            }
+            else if (plugin.name.includes("Better Admin Bar")) {
+                issues.push(`The "Better Admin Bar" plugin is not needed, as this functionality is handled by the stack.`);
+            }
+        });
+        return issues;
+    }
+}

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

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { BlockManifest } from "../project/manifest/block-manifest.js";
+export declare const BlockMetaSchema: z.ZodObject<{
+    acfName: z.ZodString;
+    fileName: z.ZodString;
+    slug: z.ZodString;
+    graphqlFieldName: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodDefault<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    types: z.ZodArray<z.ZodString, "many">;
+    templates: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    mode: z.ZodDefault<z.ZodEnum<["preview", "edit", "both"]>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    flags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    childTags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    childBlocks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    parent: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    ancestors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    dynamic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    allowMultiple: z.ZodDefault<z.ZodBoolean>;
+    postMetaBlock: z.ZodOptional<z.ZodObject<{
+        fieldName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        fieldName: string;
+    }, {
+        fieldName: string;
+    }>>;
+    frontendMode: z.ZodDefault<z.ZodEnum<["hidden", "childrenOnly", "default"]>>;
+    inserter: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    cache: boolean;
+    acfName: string;
+    fileName: string;
+    slug: string;
+    graphqlFieldName: string;
+    title: string;
+    category: string;
+    types: string[];
+    mode: "preview" | "edit" | "both";
+    tags: string[];
+    flags: Record<string, any>;
+    childTags: string[];
+    childBlocks: string[];
+    parent: string[];
+    ancestors: string[];
+    dynamic: boolean;
+    allowMultiple: boolean;
+    frontendMode: "hidden" | "childrenOnly" | "default";
+    inserter: boolean;
+    description?: string | undefined;
+    icon?: string | undefined;
+    keywords?: string[] | undefined;
+    templates?: string[] | null | undefined;
+    postMetaBlock?: {
+        fieldName: string;
+    } | undefined;
+}, {
+    acfName: string;
+    fileName: string;
+    slug: string;
+    graphqlFieldName: string;
+    title: string;
+    types: string[];
+    cache?: boolean | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+    icon?: string | undefined;
+    keywords?: string[] | undefined;
+    templates?: string[] | null | undefined;
+    mode?: "preview" | "edit" | "both" | undefined;
+    tags?: string[] | undefined;
+    flags?: Record<string, any> | undefined;
+    childTags?: string[] | undefined;
+    childBlocks?: string[] | undefined;
+    parent?: string[] | undefined;
+    ancestors?: string[] | undefined;
+    dynamic?: boolean | undefined;
+    allowMultiple?: boolean | undefined;
+    postMetaBlock?: {
+        fieldName: string;
+    } | undefined;
+    frontendMode?: "hidden" | "childrenOnly" | "default" | undefined;
+    inserter?: boolean | undefined;
+}>;
+export type BlockMetadata = z.infer<typeof BlockMetaSchema>;
+export type BlockMetadataConstructor = z.input<typeof BlockMetaSchema>;
+export declare function describeBlock(block: BlockMetadata): string;
+export declare function describeBlockManifest(manifest: BlockManifest): string;