eddev 2.0.0-beta.36 → 2.0.0-beta.38

package/dist/app/server/server-context.d.ts

@@ -1,50 +0,0 @@
-import { RequestHeaders } from "vinxi/http";
-import { UrlReplacerConf } from "./utils/replace-host.js";
-import { Manifest } from "vinxi/dist/types/types/manifest";
-import { TrackerTags } from "../lib/routing/types.js";
-export type ServerContextArgs = {
-    dev: boolean;
-    origin: string;
-    replaceUrls?: UrlReplacerConf;
-};
-export type ServerContextRuntime = {
-    getManifest: (name: string) => Manifest;
-};
-/**
- * Data returned from WordPress origin /_appdata route
- */
-type ServerAppData = {
-    appData: any;
-    trackers: TrackerTags;
-};
-export declare class ServerContext {
-    dev: boolean;
-    origin: string;
-    replaceUrls?: (text: string) => string;
-    constructor(conf: ServerContextArgs);
-    get runtime(): ServerContextRuntime;
-    static setRuntime(rt: ServerContextRuntime): void;
-    getOriginUrl(url: string): string;
-    fetchOrigin(url: string, opts?: RequestInit & {
-        replaceUrls?: boolean;
-    }): Promise<Response>;
-    fetchRouteData(req: {
-        pathname: string;
-        query?: Record<string, any>;
-        headers?: RequestHeaders;
-        withAppData?: boolean;
-    }): Promise<Response>;
-    fetchAppData(): Promise<ServerAppData>;
-    extractRequestHeaders(req?: RequestHeaders): Partial<Record<import("vinxi/http").HTTPHeaderName, string | undefined>>;
-    fetchNamedQuery(req: {
-        name: string;
-        params: object;
-        headers: RequestHeaders;
-    }): Promise<Response>;
-    fetchMutation(req: {
-        name: string;
-        body: object;
-        headers: RequestHeaders;
-    }): Promise<Response>;
-}
-export {};

package/dist/app/server/server-context.js

@@ -1,145 +0,0 @@
-import { parseURL, stringifyParsedURL, withQuery } from "ufo";
-import { filterHeader } from "./utils/headers.js";
-import { createUrlReplacer } from "./utils/replace-host.js";
-const PROXY_RESPONSE_HEADERS = ["content-type", "set-cookie", /^x-/, "cache-control", /woocommerce/];
-const PROXY_REQUEST_HEADERS = [
-    "content-type",
-    "accept",
-    "accept-encoding",
-    "accept-language",
-    "origin",
-    "referer",
-    "user-agent",
-    "authorization",
-    "woocommerce-session",
-];
-let runtime;
-export class ServerContext {
-    dev;
-    origin;
-    replaceUrls;
-    constructor(conf) {
-        this.dev = conf.dev;
-        this.origin = conf.origin;
-        if (conf.replaceUrls) {
-            this.replaceUrls = createUrlReplacer(conf.replaceUrls);
-        }
-    }
-    get runtime() {
-        return runtime;
-    }
-    static setRuntime(rt) {
-        runtime = rt;
-    }
-    getOriginUrl(url) {
-        const parsed = parseURL(url);
-        const parsedOrigin = parseURL(this.origin);
-        parsed.host = parsedOrigin.host;
-        parsed.protocol = parsedOrigin.protocol;
-        return stringifyParsedURL(parsed);
-    }
-    async fetchOrigin(url, opts) {
-        url = this.getOriginUrl(url);
-        const response = await fetch(url, {
-            ...opts,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                ...opts?.headers,
-            },
-        });
-        if (!response.ok) {
-            return response;
-        }
-        // console.log("Response headers", response.headers)
-        const headers = {};
-        response.headers.forEach((value, key) => {
-            if (filterHeader(key, PROXY_RESPONSE_HEADERS)) {
-                headers[key] = value;
-            }
-        });
-        // console.log("Returning headers", headers)
-        let text = await response.text();
-        if (opts?.replaceUrls && this.replaceUrls) {
-            text = this.replaceUrls(text);
-        }
-        return new Response(text, {
-            status: response.status,
-            statusText: response.statusText,
-            headers,
-        });
-    }
-    async fetchRouteData(req) {
-        const fetchUrl = withQuery(req.pathname, {
-            ...req.query,
-            _props: "1",
-            _ssr: "1",
-            _debug: this.dev ? "1" : undefined,
-        });
-        // console.log("Fetching route data", req.pathname)
-        const result = this.fetchOrigin(fetchUrl, {
-            cache: "no-cache",
-            replaceUrls: true,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-            },
-        });
-        // console.log("Finished fetching route data")
-        return result;
-    }
-    async fetchAppData() {
-        // console.log("Fetching app data")
-        const response = await this.fetchOrigin("/_appdata", {
-            cache: "no-cache",
-            replaceUrls: true,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-            },
-        });
-        // console.log("Decoding app data")
-        const result = await response.json();
-        // console.log("Done with app done")
-        return result;
-    }
-    extractRequestHeaders(req) {
-        const headers = {};
-        if (req) {
-            for (let key of PROXY_REQUEST_HEADERS) {
-                if (req[key]) {
-                    headers[key] = req[key];
-                }
-            }
-        }
-        return headers;
-    }
-    async fetchNamedQuery(req) {
-        const url = `/wp-json/ed/v1/query/${req.name}?params=${encodeURIComponent(JSON.stringify(req.params))}`;
-        return this.fetchOrigin(url, {
-            cache: "no-cache",
-            replaceUrls: true,
-            headers: {
-                ...this.extractRequestHeaders(req.headers),
-                "Content-Type": "application/json",
-                Accept: "application/json",
-            },
-            redirect: "manual",
-        });
-    }
-    async fetchMutation(req) {
-        const url = `/wp-json/ed/v1/mutation/${req.name}`;
-        return this.fetchOrigin(url, {
-            method: "POST",
-            cache: "no-cache",
-            replaceUrls: true,
-            headers: {
-                ...this.extractRequestHeaders(req.headers),
-                "Content-Type": "application/json",
-                Accept: "application/json",
-            },
-            body: JSON.stringify(req.body),
-            redirect: "manual",
-        });
-    }
-}

package/dist/app/server/utils/headers.d.ts

@@ -1,5 +0,0 @@
-export declare function filterHeader(key: string, allowed: (string | RegExp)[]): boolean;
-export declare const BRANDED_HEADERS: {
-    "X-Powered-By": string;
-};
-export declare function extractHeaders(rawHeaders: Headers): Record<string, string>;

package/dist/app/server/utils/headers.js

@@ -1,28 +0,0 @@
-export function filterHeader(key, allowed) {
-    return allowed.some((allowedKey) => {
-        if (allowedKey instanceof RegExp) {
-            return allowedKey.test(key);
-        }
-        return allowedKey === key;
-    });
-}
-export const BRANDED_HEADERS = {
-    "X-Powered-By": "ed.studio",
-};
-const IGNORE_REQUEST_HEADERS = [
-    "host",
-    "connection",
-    "accept-encoding",
-    "accept-language",
-    "origin",
-    "referer",
-    "user-agent",
-];
-export function extractHeaders(rawHeaders) {
-    const headers = {};
-    rawHeaders.forEach((value, key) => {
-        headers[key] = value;
-    });
-    IGNORE_REQUEST_HEADERS.forEach((key) => delete headers[key]);
-    return headers;
-}

package/dist/app/server/utils/replace-host.d.ts

@@ -1,10 +0,0 @@
-export type UrlReplacerConf = {
-    from: string;
-    to: string;
-    /** A dictionary of prefixes (eg /wp-content), and whether to replace them (true/false) */
-    prefixes: {
-        prefix: string;
-        replace: boolean;
-    }[];
-};
-export declare function createUrlReplacer(conf: UrlReplacerConf): (text: string) => string;

package/dist/app/server/utils/replace-host.js

@@ -1,61 +0,0 @@
-export function createUrlReplacer(conf) {
-    // Create a regular expression to match the URL
-    // Note that that the regex doesn't necessarily match the entire URL
-    const lookup = new RegExp(conf.from.replace(/https?[:\\\/]+/, "https?[:\\/\\\\]+") + "([a-z0-9\\-_/\\\\]+)", "ig");
-    return (text) => {
-        return text.replace(lookup, (url) => {
-            // Strip out the origin, to create a relative path
-            const path = url.replace(/https?:[\/\\]+[^\/\\]+/, "");
-            const isEscaped = url.includes(":\\/\\/");
-            const key = "/" +
-                path
-                    .split(/[\/\\]+/g)
-                    .filter((v) => v)
-                    .join("/");
-            for (let item of conf.prefixes) {
-                if (key.startsWith(item.prefix)) {
-                    if (item.replace) {
-                        return url;
-                    }
-                    else {
-                        return path;
-                    }
-                }
-            }
-            return path;
-            // if (path.startsWith("/wp-content/uploads/")) {
-            //   if (!conf.ignoreUploads) {
-            //     return path
-            //   } else {
-            //     return url
-            //   }
-            //   // } else if (path.startsWith("/wp-content/themes/")) {
-            //   //   if (settings?.uploads === "proxy") {
-            //   //     return path
-            //   //   } else if (settings?.uploads === "remote") {
-            //   //     return url
-            //   //   }
-            //   // } else if (path.startsWith("/wp-content/plugins/")) {
-            //   //   if (settings?.uploads === "proxy") {
-            //   //     return path
-            //   //   } else if (settings?.uploads === "remote") {
-            //   //     return url
-            //   //   }
-            // } else {
-            //   return path
-            // }
-        });
-    };
-    // const from = conf.from
-    // const to = conf.to
-    // const https = conf.https
-    // const ignoreUploads = conf.ignoreUploads
-    // const ignorePlugins = conf.ignorePlugins
-    // const replaceTargetString = from.replaceAll(/https?:/g, "https?:").replaceAll("/", "\\/")
-    // const replaceTargetEscapedString = from.replaceAll(/https?:/g, "https?:").replaceAll("/", "\\\\/")
-    // const replaceTarget = new RegExp(replaceTargetString, "g")
-    // const replaceTargetEscaped = new RegExp(replaceTargetEscapedString, "g")
-    // return (value: string) => {
-    //   return value.replaceAll(replaceTarget, to).replace(replaceTargetEscaped, to.replaceAll("/", "\\/"))
-    // }
-}

package/dist/app/utils/wp.d.ts

@@ -1,26 +0,0 @@
-import type * as BlockEditor from "@wordpress/block-editor";
-import type * as Blocks from "@wordpress/blocks";
-import type * as Hooks from "@wordpress/hooks";
-import type * as Element from "@wordpress/element";
-import type * as Components from "@wordpress/components";
-import type * as Data from "@wordpress/data";
-import type * as CoreData from "@wordpress/core-data";
-import type * as Editor from "@wordpress/editor";
-import type * as Compose from "@wordpress/compose";
-import type * as RichText from "@wordpress/rich-text";
-type WordPressGlobal = {
-    blockEditor: typeof BlockEditor;
-    blocks: typeof Blocks;
-    hooks: typeof Hooks;
-    element: typeof Element;
-    data: typeof Data;
-    components: typeof Components;
-    compose: typeof Compose;
-    coreData: typeof CoreData;
-    editor: typeof Editor;
-    richText: typeof RichText;
-};
-declare global {
-    const wp: WordPressGlobal;
-}
-export {};

package/dist/app/utils/wp.js

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