@revealui/core 0.0.1-pre.0 → 0.0.1-pre.2

package/dist/plugins/vercel/functions/build.ts

@@ -1,484 +0,0 @@
-import { findRoot } from "@manypkg/find-root";
-import { getNodeVersion } from "@vercel/build-utils";
-import { nodeFileTrace } from "@vercel/nft";
-import type { Header, Rewrite } from "@vercel/routing-utils";
-import { type BuildOptions, type Plugin, build } from "esbuild";
-import glob from "fast-glob";
-import { type ASTNode, generateCode, loadFile } from "magicast";
-import fs, { copyFile } from "node:fs/promises";
-import { builtinModules } from "node:module";
-import path, { basename } from "node:path";
-import type { ResolvedConfig } from "vite";
-import { assert } from "./assert.js";
-
-import { VercelOutputIsr, ViteVercelApiEntry } from "../../../types/index.js";
-import { vercelOutputVcConfigSchema } from "../schemas/config/vc-config.js";
-import { vercelEndpointExports } from "../schemas/exports.js";
-import { getOutput, getRoot, pathRelativeTo } from "./utils.js";
-
-export async function getAdditionalEndpoints(resolvedConfig: ResolvedConfig) {
-  const userEndpoints: ViteVercelApiEntry[] = [];
-  if (Array.isArray(resolvedConfig.vercel?.additionalEndpoints)) {
-    for (const endpoint of resolvedConfig.vercel.additionalEndpoints) {
-      if (typeof endpoint === "function") {
-        const res = await endpoint();
-        if (Array.isArray(res)) {
-          userEndpoints.push(...res);
-        } else if (typeof res === "object") {
-          userEndpoints.push(res);
-        }
-      } else if (typeof endpoint === "object") {
-        userEndpoints.push(endpoint);
-      }
-    }
-  }
-
-  return userEndpoints.map((e) => ({
-    ...e,
-    route: e.route ?? true,
-    // path.resolve removes the trailing slash if any
-    destination: `${path.posix.resolve("/", e.destination)}.func`,
-  }));
-}
-
-export async function getEntries(
-  resolvedConfig: ResolvedConfig,
-): Promise<ViteVercelApiEntry[]> {
-  const apiEntries = glob
-    .sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`)
-    // from Vercel doc: Files with the underscore prefix are not turned into Serverless Functions.
-    .filter((filepath) => !path.basename(filepath).startsWith("_"));
-
-  if (apiEntries.length > 0) {
-    console.warn(
-      "@vercel/build is currently force building /api files itself, with no way to disable it. " +
-        "In order to avoid double compilation, you should temporarily rename /api to /_api while using this plugin. " +
-        "/_api functions are compiled under .vercel/output/functions/api/*.func as if they were in /api.",
-    );
-  }
-
-  const otherApiEntries = glob
-    .sync(`${getRoot(resolvedConfig)}/_api/**/*.*([a-zA-Z0-9])`)
-    // from Vercel doc: Files with the underscore prefix are not turned into Serverless Functions.
-    .filter((filepath) => !path.basename(filepath).startsWith("_"));
-
-  return [...apiEntries, ...otherApiEntries].reduce(
-    (entryPoints, filePath) => {
-      const outFilePath = pathRelativeTo(
-        filePath,
-        resolvedConfig,
-        filePath.includes("/_api/") ? "_api" : "api",
-      );
-      const parsed = path.posix.parse(outFilePath);
-
-      entryPoints.push({
-        source: filePath,
-        destination: `api/${path.posix.join(parsed.dir, parsed.name)}.func`,
-        route: true,
-      });
-
-      return entryPoints;
-    },
-    await getAdditionalEndpoints(resolvedConfig),
-  );
-}
-
-const edgeWasmPlugin: Plugin = {
-  name: "edge-wasm-vercel",
-  setup(build) {
-    build.onResolve({ filter: /\.wasm/ }, (args) => {
-      return {
-        path: args.path.replace(/\.wasm\?module$/i, ".wasm"),
-        external: true,
-      };
-    });
-  },
-};
-
-const vercelOgPlugin = (ctx: { found: boolean; index: string }): Plugin => {
-  return {
-    name: "vercel-og",
-    setup(build) {
-      build.onResolve({ filter: /@vercel\/og/ }, () => {
-        ctx.found = true;
-        return undefined;
-      });
-
-      build.onLoad({ filter: /@vercel\/og/ }, (args) => {
-        ctx.index = args.path;
-        return undefined;
-      });
-    },
-  };
-};
-
-const standardBuildOptions: BuildOptions = {
-  bundle: true,
-  target: "es2022",
-  format: "esm",
-  platform: "node",
-  logLevel: "info",
-  logOverride: {
-    "ignored-bare-import": "verbose",
-    "require-resolve-not-external": "verbose",
-  },
-  minify: false,
-  plugins: [],
-  define: {
-    "process.env.NODE_ENV": '"production"',
-    "import.meta.env.NODE_ENV": '"production"',
-  },
-};
-
-export async function buildFn(
-  resolvedConfig: ResolvedConfig,
-  entry: ViteVercelApiEntry,
-  buildOptions?: BuildOptions,
-) {
-  assert(
-    entry.destination.length > 0,
-    `Endpoint ${typeof entry.source === "string" ? entry.source : "-"} does not have build destination`,
-  );
-
-  const options = Object.assign({}, standardBuildOptions);
-
-  if (buildOptions) {
-    Object.assign(options, buildOptions);
-  }
-
-  const filename =
-    entry.edge || options.format === "cjs" ? "index.js" : "index.mjs";
-  const outfile = path.join(
-    getOutput(resolvedConfig, "functions"),
-    entry.destination,
-    filename,
-  );
-
-  Object.assign(options, { outfile });
-
-  if (!options.stdin) {
-    if (typeof entry.source === "string") {
-      options.entryPoints = [entry.source];
-    } else {
-      assert(
-        typeof entry.source === "object",
-        "`{ source }` must be a string or an object",
-      );
-      assert(
-        typeof entry.source.contents === "string",
-        "`{ contents }` must be a string",
-      );
-      options.stdin = entry.source;
-    }
-  }
-
-  if (entry.edge) {
-    options.platform = undefined;
-    options.external = [
-      ...builtinModules,
-      ...builtinModules.map((m) => `node:${m}`),
-    ];
-    options.conditions = [
-      "edge-light",
-      "worker",
-      "browser",
-      "module",
-      "import",
-      "require",
-    ];
-    options.plugins?.push(edgeWasmPlugin);
-    options.format = "esm";
-  } else if (options.format === "esm") {
-    options.banner = {
-      js: `import { createRequire as VPV_createRequire } from "node:module";
-import { fileURLToPath as VPV_fileURLToPath } from "node:url";
-import { dirname as VPV_dirname } from "node:path";
-const require = VPV_createRequire(import.meta.url);
-const __filename = VPV_fileURLToPath(import.meta.url);
-const __dirname = VPV_dirname(__filename);
-`,
-    };
-  }
-
-  const ctx = { found: false, index: "" };
-  options.plugins?.push(vercelOgPlugin(ctx));
-
-  const output = await build(options);
-
-  // guess some assets dependencies
-  if (typeof entry.source === "string") {
-    let base = resolvedConfig.root;
-    try {
-      const dir = await findRoot(resolvedConfig.root);
-      base = dir.rootDir;
-    } catch (e) {
-      // ignore error
-    }
-    const { fileList, reasons } = await nodeFileTrace([entry.source], {
-      base,
-      processCwd: resolvedConfig.root,
-      mixedModules: true,
-      ignore: [
-        "**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js",
-        "**/*.d.ts",
-        "**/*.map",
-        "**/node_modules/webpack5/**/*",
-      ],
-      async readFile(filepath) {
-        if (filepath.endsWith(".ts") || filepath.endsWith(".tsx")) {
-          const result = await build({
-            ...standardBuildOptions,
-            entryPoints: [entry.source as string],
-            bundle: false,
-            write: false,
-          });
-
-          if (result.outputFiles && result.outputFiles[0]) {
-            return result.outputFiles[0].text;
-          }
-
-          throw new Error("Build result does not contain output files");
-        }
-
-        return fs.readFile(filepath, "utf-8");
-      },
-    });
-
-    for (const file of fileList) {
-      if (
-        reasons.has(file) &&
-        reasons.get(file)?.type.includes("asset") &&
-        !file.endsWith(".js") &&
-        !file.endsWith(".cjs") &&
-        !file.endsWith(".mjs") &&
-        !file.endsWith("package.json")
-      ) {
-        await copyFile(
-          path.join(base, file),
-          path.join(
-            getOutput(resolvedConfig, "functions"),
-            entry.destination,
-            basename(file),
-          ),
-        );
-      }
-    }
-  }
-
-  await writeVcConfig(resolvedConfig, entry.destination, filename, {
-    edge: Boolean(entry.edge),
-    streaming: entry.streaming,
-  });
-
-  return output;
-}
-
-export async function writeVcConfig(
-  resolvedConfig: ResolvedConfig,
-  destination: string,
-  filename: string,
-  options: {
-    edge: boolean;
-    streaming?: boolean;
-  },
-): Promise<void> {
-  const vcConfig = path.join(
-    getOutput(resolvedConfig, "functions"),
-    destination,
-    ".vc-config.json",
-  );
-
-  const nodeVersion = await getNodeVersion(getOutput(resolvedConfig));
-
-  await fs.writeFile(
-    vcConfig,
-    JSON.stringify(
-      vercelOutputVcConfigSchema.parse(
-        options.edge
-          ? {
-              runtime: "edge",
-              entrypoint: filename,
-            }
-          : {
-              runtime: nodeVersion.runtime,
-              handler: filename,
-              maxDuration: resolvedConfig.vercel?.defaultMaxDuration,
-              launcherType: "Nodejs",
-              shouldAddHelpers: true,
-              supportsResponseStreaming: options.streaming ?? false,
-            },
-      ),
-      undefined,
-      2,
-    ),
-    "utf-8",
-  );
-}
-
-function getSourceAndDestination(destination: string) {
-  if (destination.startsWith("api/")) {
-    return path.posix.resolve("/", destination);
-  }
-  return path.posix.resolve("/", destination, ":match*");
-}
-
-const RE_BRACKETS = /^\[([^/]+)\]$/gm;
-function replaceBrackets(source: string) {
-  return source
-    .split("/")
-    .map((segment) => segment.replace(RE_BRACKETS, ":$1"))
-    .join("/");
-}
-
-function isPrimitive(test: unknown) {
-  return test !== Object(test);
-}
-
-export function _eval(code: unknown): boolean {
-  const func = new Function(`{ return function(){ return ${code} } };`);
-  return func.call(null).call(null);
-}
-
-function evalExport(exp: unknown) {
-  if (!exp) return;
-
-  const code = isPrimitive(exp) ? exp : generateCode(exp as ASTNode).code;
-
-  return _eval(code);
-}
-
-async function extractExports(filepath: string) {
-  try {
-    const mod = await loadFile(filepath);
-
-    const subject = {
-      edge: evalExport(mod.exports.edge),
-      headers: evalExport(mod.exports.headers),
-      streaming: evalExport(mod.exports.streaming),
-      isr: evalExport(mod.exports.isr),
-    };
-
-    return vercelEndpointExports.parse(subject);
-  } catch (e) {
-    console.warn(`Warning: failed to read exports of '${filepath}'`, e);
-  }
-}
-
-async function extractHeaders(resolvedConfig: ResolvedConfig) {
-  let headers: Header[] = [];
-  if (typeof resolvedConfig.vercel?.headers === "function") {
-    const result = await resolvedConfig.vercel.headers(resolvedConfig);
-    if (Array.isArray(result)) {
-      headers = result;
-    }
-  } else if (Array.isArray(resolvedConfig.vercel?.headers)) {
-    headers = resolvedConfig.vercel.headers;
-  }
-
-  return headers;
-}
-
-export async function buildEndpoints(resolvedConfig: ResolvedConfig): Promise<{
-  rewrites: Rewrite[];
-  isr: Record<string, VercelOutputIsr>;
-  headers: Header[];
-}> {
-  const entries = await getEntries(resolvedConfig);
-  const headers = await extractHeaders(resolvedConfig);
-
-  for (const entry of entries) {
-    if (typeof entry.source === "string") {
-      const exports = await extractExports(entry.source);
-
-      if (exports) {
-        if (entry.headers || exports.headers) {
-          entry.headers = {
-            ...(exports.headers as Record<string, string>),
-            ...(entry.headers as Record<string, string>),
-          } as Record<string, string>;
-        }
-
-        if (entry.edge !== undefined && exports.edge !== undefined) {
-          throw new Error(
-            `edge configuration should be defined either in the endpoint itself or through Vite config, not both ('${entry.source}')`,
-          );
-        }
-
-        if (exports.edge !== undefined) {
-          entry.edge = exports.edge;
-        }
-
-        if (entry.isr !== undefined && exports.isr !== undefined) {
-          throw new Error(
-            `isr configuration should be defined either in the endpoint itself or through Vite config, not both ('${entry.source}')`,
-          );
-        }
-
-        if (
-          (entry.isr !== undefined || exports.isr !== undefined) &&
-          (entry.edge !== undefined || exports.edge !== undefined)
-        ) {
-          throw new Error(
-            `isr cannot be enabled for edge functions ('${entry.source}')`,
-          );
-        }
-
-        if (exports.isr) {
-          entry.isr = exports.isr;
-        }
-
-        if (typeof exports.streaming === "boolean") {
-          entry.streaming = exports.streaming;
-        }
-      }
-    }
-
-    await buildFn(resolvedConfig, entry, entry.buildOptions);
-  }
-
-  const isrEntries = entries
-    .filter((e) => e.isr)
-    .map(
-      (e) =>
-        [
-          e.destination.replace(/\.func$/, ""),
-          { expiration: e.isr?.expiration },
-        ] as const,
-    );
-
-  return {
-    rewrites: entries
-      .filter((e) => {
-        if (e.route !== undefined) {
-          return e.route !== false;
-        }
-        return true;
-      })
-      .map((e) => {
-        const destination = e.destination.replace(/\.func$/, "");
-        if (typeof e.route === "string") {
-          return {
-            source: `(${e.route})`,
-            destination: `${destination}/?__original_path=$1`,
-          };
-        }
-        return {
-          source: replaceBrackets(getSourceAndDestination(destination)),
-          destination: getSourceAndDestination(destination),
-        };
-      }),
-    isr: Object.fromEntries(isrEntries) as Record<string, VercelOutputIsr>,
-    headers: [
-      ...entries
-        .filter((e) => e.headers)
-        .map((e) => ({
-          source: `/${e.destination.replace(/\.func$/, "")}`,
-          headers: Object.entries(e.headers ?? {}).map(([key, value]) => ({
-            key,
-            value,
-          })),
-        })),
-      ...headers,
-    ],
-  };
-}

package/dist/plugins/vercel/functions/config.ts

@@ -1,147 +0,0 @@
-import path from "node:path";
-import type { ResolvedConfig } from "vite";
-import { getOutput } from "./utils";
-
-import {
-  getTransformedRoutes,
-  type Header,
-  mergeRoutes,
-  normalizeRoutes,
-  Redirect,
-  type Rewrite,
-  type Route,
-} from "@vercel/routing-utils";
-import fs from "node:fs/promises";
-import type {
-  VercelOutputConfig,
-  ViteVercelRewrite,
-} from "../../../types/interfaces/host";
-import { vercelOutputConfigSchema } from "../schemas/config/vercel";
-
-function reorderEnforce<T extends { enforce?: "pre" | "post" }>(arr: T[]) {
-  return [
-    ...arr.filter((r) => r.enforce === "pre"),
-    ...arr.filter((r) => !r.enforce),
-    ...arr.filter((r) => r.enforce === "post"),
-  ];
-}
-
-export function getConfig(
-  resolvedConfig: ResolvedConfig,
-  rewrites?: ViteVercelRewrite[],
-  overrides?: VercelOutputConfig["overrides"],
-  headers?: Header[],
-): VercelOutputConfig {
-  const _rewrites: ViteVercelRewrite[] = [
-    // User provided config always comes first
-    ...((Array.isArray(resolvedConfig.vercel?.rewrites)
-      ? resolvedConfig.vercel?.rewrites
-      : []) as ViteVercelRewrite[]),
-    ...(rewrites ?? []),
-  ];
-
-  const { routes, error } = getTransformedRoutes({
-    cleanUrls: resolvedConfig.vercel?.cleanUrls ?? true,
-    trailingSlash: resolvedConfig.vercel?.trailingSlash,
-    rewrites: reorderEnforce(_rewrites),
-    redirects:
-      resolvedConfig.vercel &&
-      "redirects" in resolvedConfig.vercel &&
-      resolvedConfig.vercel.redirects
-        ? (reorderEnforce(
-            resolvedConfig.vercel.redirects.map((redirect: Redirect) => ({
-              ...redirect,
-              enforce: undefined,
-            })),
-          ) as Redirect[])
-        : undefined,
-    headers,
-  });
-
-  if (error) {
-    throw error;
-  }
-
-  if (
-    resolvedConfig.vercel?.config?.routes &&
-    resolvedConfig.vercel.config.routes.length > 0 &&
-    !resolvedConfig.vercel.config.routes.every(
-      (r: { hasOwnProperty: (arg0: string) => any }) =>
-        r &&
-        r.hasOwnProperty("continue") &&
-        typeof (r as any).continue === "boolean" &&
-        (r as any).continue,
-    )
-  ) {
-    console.warn(
-      'Did you forget to add `"continue": true` to your routes? See https://vercel.com/docs/build-output-api/v3/configuration#source-route\n' +
-        "If not, it is discouraged to use `vercel.config.routes` to override routes. " +
-        "Prefer using `vercel.rewrites` and `vercel.redirects`.",
-    );
-  }
-
-  let userRoutes: Route[] = [];
-  let buildRoutes: Route[] = [];
-
-  if (resolvedConfig.vercel?.config?.routes) {
-    const norm = normalizeRoutes(resolvedConfig.vercel.config.routes);
-
-    if (norm.error) {
-      throw norm.error;
-    }
-
-    userRoutes = norm.routes ?? [];
-  }
-
-  if (routes) {
-    const norm = normalizeRoutes(routes);
-
-    if (norm.error) {
-      throw norm.error;
-    }
-
-    buildRoutes = norm.routes ?? [];
-  }
-
-  const cleanRoutes = mergeRoutes({
-    userRoutes,
-    builds: [
-      {
-        use: "@vercel/node",
-        entrypoint: "index.js",
-        routes: buildRoutes,
-      },
-    ],
-  });
-
-  return vercelOutputConfigSchema.parse({
-    version: 3,
-    ...resolvedConfig.vercel?.config,
-    routes: cleanRoutes,
-    overrides: {
-      ...resolvedConfig.vercel?.config?.overrides,
-      ...overrides,
-    },
-  });
-}
-
-export function getConfigDestination(resolvedConfig: ResolvedConfig) {
-  return path.join(getOutput(resolvedConfig), "config.json");
-}
-
-export async function writeConfig(
-  resolvedConfig: ResolvedConfig,
-  rewrites?: Rewrite[],
-  overrides?: VercelOutputConfig["overrides"],
-  headers?: Header[],
-): Promise<void> {
-  await fs.writeFile(
-    getConfigDestination(resolvedConfig),
-    JSON.stringify(
-      getConfig(resolvedConfig, rewrites, overrides, headers),
-      undefined,
-      2,
-    ),
-    "utf-8",
-  );
-}

package/dist/plugins/vercel/functions/helpers.ts

@@ -1,70 +0,0 @@
-// scripts/copy-files.js
-import { PathLike,  promises as fs } from "fs";
-import path from "node:path";
-
-export async function copyDir(src: PathLike, dest: PathLike) {
-  await fs.mkdir(dest, { recursive: true });
-  const entries = await fs.readdir(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(src.toString(), entry.name);
-    const destPath = path.join(dest.toString(), entry.name);
-
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
-    } else {
-      await fs.copyFile(srcPath, destPath);
-    }
-  }
-}
-
-// Add directories that need to be copied
-const directories = [
-  "core",
-  "plugins",
-  "types",
-  "integration",
-  "ui",
-  "exports",
-];
-
-async function main() {
-  for (const dir of directories) {
-    const src = path.join("src", dir);
-    const dest = path.join("dist", dir);
-    await copyDir(src, dest);
-  }
-  // Copy exports/index.js to dist/index.js for main entry point
-  const exportsIndexSrc = path.join("dist", "exports", "index.js");
-  const distIndexDest = path.join("dist", "index.js");
-  try {
-    await fs.copyFile(exportsIndexSrc, distIndexDest);
-  } catch (error) {
-    console.warn("Could not copy exports/index.js to dist/index.js:", error);
-  }
-  // Create dist/index.d.ts declaration file
-  const distIndexDts = path.join("dist", "index.d.ts");
-  const indexDtsContent = `export * from "./exports/index.js";\n`;
-  try {
-    await fs.writeFile(distIndexDts, indexDtsContent, "utf-8");
-  } catch (error) {
-    console.warn("Could not create dist/index.d.ts:", error);
-  }
-}
-
-main().catch(console.error);
-
-// import fs from "node:fs/promises";
-// import path from "node:path";
-
-// export async function copyDir(src: string, dest: string) {
-//   await fs.mkdir(dest, { recursive: true });
-//   const entries = await fs.readdir(src, { withFileTypes: true });
-
-//   for (const entry of entries) {
-//     const srcPath = path.join(src, entry.name);
-//     const destPath = path.join(dest, entry.name);
-
-//     entry.isDirectory() ? await copyDir(srcPath, destPath) : await fs.copyFile(srcPath, destPath);
-//   }
-// }