@rpcbase/vite 0.113.0 → 0.115.0

package/dist/dotEnvExpand.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dotEnvExpand.d.ts.map

package/dist/dotEnvExpand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dotEnvExpand.d.ts","sourceRoot":"","sources":["../src/dotEnvExpand.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { createServer as viteCreateServer, UserConfigExport, UserConfigFn } from 'vite';
+declare const resolveAliases: Record<string, string>;
+export { resolveAliases };
+export declare const extendConfig: (userConfig: UserConfigExport) => UserConfigFn;
+export declare const extendSpecConfig: (userConfig: UserConfigExport) => UserConfigFn;
+export declare const createServer: typeof viteCreateServer;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,CAAA;AAKvB,OAAO,EACL,YAAY,IAAI,gBAAgB,EAGjC,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAyB,gBAAgB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAoEjF,QAAA,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAM1C,CAAA;AA4BD,OAAO,EAAE,cAAc,EAAE,CAAA;AAgIzB,eAAO,MAAM,YAAY,GAAI,YAAY,gBAAgB,KAAG,YAW3D,CAAA;AA4CD,eAAO,MAAM,gBAAgB,GAAI,YAAY,gBAAgB,KAAG,YAW/D,CAAA;AAED,eAAO,MAAM,YAAY,yBAAmB,CAAA"}

package/dist/index.js

@@ -0,0 +1,566 @@
+import fs, { existsSync, readFileSync } from "node:fs";
+import path from "path";
+import dotenv from "dotenv";
+import { expand } from "dotenv-expand";
+import { createServer as createServer$1, mergeConfig, loadEnv } from "vite";
+import { viteSingleFile } from "vite-plugin-singlefile";
+import react from "@vitejs/plugin-react";
+import { createHtmlPlugin } from "vite-plugin-html";
+import { globSync } from "glob";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import path$1 from "node:path";
+import { fileURLToPath } from "node:url";
+import { Project } from "ts-morph";
+import * as ts from "typescript";
+const envFilePath = path.resolve(process.cwd(), ".env");
+if (fs.existsSync(envFilePath)) {
+  const parsedFile = dotenv.parse(fs.readFileSync(envFilePath));
+  const expanded = expand({ parsed: parsedFile }).parsed || {};
+  Object.assign(process.env, expanded);
+}
+const require$1 = createRequire(import.meta.url);
+const splitPackageSpecifier = (specifier) => {
+  if (!specifier) return { pkgName: specifier, subpath: "" };
+  if (specifier.startsWith("@")) {
+    const segments = specifier.split("/");
+    if (segments.length < 2) return { pkgName: specifier, subpath: "" };
+    return {
+      pkgName: `${segments[0]}/${segments[1]}`,
+      subpath: segments.slice(2).join("/")
+    };
+  }
+  const [pkgName, ...rest] = specifier.split("/");
+  return { pkgName, subpath: rest.join("/") };
+};
+const withTrailingSep = (p) => p.endsWith(path.sep) ? p : p + path.sep;
+const resolvePackageRoot = (pkg) => {
+  const { pkgName } = splitPackageSpecifier(pkg);
+  if (!pkgName) return pkg;
+  try {
+    const pkgJson = require$1.resolve(`${pkgName}/package.json`);
+    return path.dirname(pkgJson);
+  } catch (err) {
+    const entry = require$1.resolve(pkgName);
+    let dir = path.dirname(entry);
+    while (true) {
+      const pkgJsonPath = path.join(dir, "package.json");
+      if (existsSync(pkgJsonPath)) {
+        try {
+          const json = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+          if (json && json.name === pkgName) return dir;
+        } catch {
+        }
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    const nmMarker = `${path.sep}node_modules${path.sep}`;
+    const idx = entry.lastIndexOf(nmMarker);
+    if (idx !== -1) {
+      const nmRoot = entry.slice(0, idx + nmMarker.length);
+      return path.join(nmRoot, pkgName);
+    }
+    throw err;
+  }
+};
+const resolveIntegratedPackagePath = (specifier) => {
+  const { pkgName, subpath } = splitPackageSpecifier(specifier);
+  if (!pkgName) return specifier;
+  const root = resolvePackageRoot(pkgName);
+  if (!subpath) {
+    return withTrailingSep(root);
+  }
+  const subDir = path.join(root, subpath);
+  const pkgJsonPath = path.join(subDir, "package.json");
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+      const entry = pkgJson.module || pkgJson.main;
+      if (entry) {
+        return path.join(subDir, entry);
+      }
+    } catch {
+    }
+  }
+  try {
+    return require$1.resolve(specifier);
+  } catch {
+    return withTrailingSep(subDir);
+  }
+};
+const __dirname$1 = path$1.dirname(fileURLToPath(import.meta.url));
+function run(bin, args) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(bin, args, { stdio: "inherit" });
+    p.on("close", (code) => code === 0 ? resolve() : reject(new Error(`posthog-cli exited ${code}`)));
+  });
+}
+function resolvePosthogCliBin() {
+  const binName = "posthog-cli";
+  const fromCwd = path$1.join(process.cwd(), "node_modules", ".bin", binName);
+  if (fs.existsSync(fromCwd)) return fromCwd;
+  let dir = __dirname$1;
+  while (true) {
+    const candidate = path$1.join(dir, "node_modules", ".bin", binName);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path$1.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return binName;
+}
+function posthogSourcemapsPlugin(opts = {}) {
+  const {
+    directory = "build/dist",
+    version,
+    host = process.env.RB_PUBLIC_POSTHOG_HOST || "https://eu.posthog.com",
+    deleteAfterUpload = true
+  } = opts;
+  const bin = resolvePosthogCliBin();
+  const globalArgs = ["--host", host];
+  return {
+    name: "posthog-sourcemaps",
+    apply: "build",
+    closeBundle: async () => {
+      const orange = "\x1B[38;5;208m";
+      const reset = "\x1B[0m";
+      const envId = process.env.POSTHOG_CLI_ENV_ID;
+      const token = process.env.POSTHOG_CLI_TOKEN;
+      if (!envId || !token) {
+        console.warn(`${orange}posthog-sourcemaps: plugin is enabled but no env vars for auth configured (POSTHOG_CLI_ENV_ID/POSTHOG_CLI_TOKEN). Skipping without failing.${reset}`);
+        return;
+      }
+      const injectArgs = ["sourcemap", "inject", "--directory", directory];
+      if (version) injectArgs.push("--version", version);
+      const uploadArgs = ["sourcemap", "upload", "--directory", directory];
+      if (deleteAfterUpload) uploadArgs.push("--delete-after");
+      await run(bin, [...globalArgs, ...injectArgs]);
+      await run(bin, [...globalArgs, ...uploadArgs]);
+    }
+  };
+}
+function isForbiddenModuleSource(source) {
+  if (source === "mongoose") return true;
+  if (source.startsWith("node:")) return true;
+  if (source.endsWith("/extendMongooseSchema") || source.endsWith("./extendMongooseSchema") || source.endsWith("extendMongooseSchema")) {
+    return true;
+  }
+  return false;
+}
+function getImportValueLocals(importDeclaration) {
+  if (importDeclaration.isTypeOnly()) return [];
+  const locals = [];
+  const defaultImport = importDeclaration.getDefaultImport();
+  if (defaultImport) locals.push(defaultImport.getText());
+  const namespaceImport = importDeclaration.getNamespaceImport();
+  if (namespaceImport) locals.push(namespaceImport.getText());
+  for (const specifier of importDeclaration.getNamedImports()) {
+    if (specifier.isTypeOnly()) continue;
+    const alias = specifier.getAliasNode()?.getText();
+    locals.push(alias ?? specifier.getName());
+  }
+  return locals;
+}
+function rewriteRpcbaseDbImport(importDeclaration, forbiddenIdentifiers) {
+  const valueLocals = getImportValueLocals(importDeclaration);
+  const zLocals = /* @__PURE__ */ new Set();
+  for (const specifier of importDeclaration.getNamedImports()) {
+    if (importDeclaration.isTypeOnly() || specifier.isTypeOnly()) continue;
+    if (specifier.getName() !== "z") continue;
+    const local = specifier.getAliasNode()?.getText() ?? "z";
+    zLocals.add(local);
+  }
+  for (const local of valueLocals) {
+    if (!zLocals.has(local)) forbiddenIdentifiers.add(local);
+  }
+  if (zLocals.size === 0) {
+    importDeclaration.remove();
+    return;
+  }
+  const specifierText = Array.from(zLocals).map((local) => local === "z" ? "z" : `z as ${local}`).join(", ");
+  importDeclaration.replaceWithText(`import { ${specifierText} } from "@rpcbase/db"`);
+}
+function collectBindingNames(name, out) {
+  if (ts.isIdentifier(name)) {
+    out.push(name.text);
+    return;
+  }
+  for (const element of name.elements) {
+    if (ts.isOmittedExpression(element)) continue;
+    collectBindingNames(element.name, out);
+  }
+}
+function getTopLevelBindings(statement) {
+  if (ts.isVariableStatement(statement)) {
+    const names = [];
+    for (const decl of statement.declarationList.declarations) {
+      collectBindingNames(decl.name, names);
+    }
+    return names;
+  }
+  if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) {
+    return statement.name ? [statement.name.text] : [];
+  }
+  return [];
+}
+function isRuntimeReferenceIdentifier(identifier) {
+  const parent = identifier.parent;
+  if (!parent) return true;
+  if (ts.isVariableDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isParameter(parent) && parent.name === identifier) return false;
+  if ((ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(parent)) && parent.name === identifier) return false;
+  if ((ts.isClassDeclaration(parent) || ts.isClassExpression(parent)) && parent.name === identifier) return false;
+  if (ts.isEnumDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isTypeAliasDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isInterfaceDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isModuleDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isTypeParameterDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isImportClause(parent) && parent.name === identifier) return false;
+  if (ts.isNamespaceImport(parent) && parent.name === identifier) return false;
+  if (ts.isImportSpecifier(parent) && parent.name === identifier) return false;
+  if (ts.isImportEqualsDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isBindingElement(parent)) {
+    if (parent.name === identifier) return false;
+    if (parent.propertyName === identifier) return false;
+  }
+  if (ts.isPropertyAccessExpression(parent) && parent.name === identifier) return false;
+  if (ts.isQualifiedName(parent)) return false;
+  if (ts.isPropertyAssignment(parent) && parent.name === identifier) return false;
+  if (ts.isPropertyDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isPropertySignature(parent) && parent.name === identifier) return false;
+  if (ts.isMethodDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isMethodSignature(parent) && parent.name === identifier) return false;
+  if (ts.isGetAccessorDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isSetAccessorDeclaration(parent) && parent.name === identifier) return false;
+  if (ts.isShorthandPropertyAssignment(parent) && parent.name === identifier) return true;
+  if (ts.isExportSpecifier(parent)) {
+    const local = parent.propertyName ?? parent.name;
+    return identifier === local;
+  }
+  if (ts.isLabeledStatement(parent) && parent.label === identifier) return false;
+  if ((ts.isBreakStatement(parent) || ts.isContinueStatement(parent)) && parent.label === identifier) return false;
+  return true;
+}
+function referencesForbiddenRuntime(statement, forbidden) {
+  if (forbidden.size === 0) return false;
+  if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) return false;
+  let found = false;
+  const visit = (node) => {
+    if (found) return;
+    if (ts.isTypeNode(node)) return;
+    if (ts.isHeritageClause(node) && node.token === ts.SyntaxKind.ImplementsKeyword) return;
+    if (ts.isIdentifier(node)) {
+      if (forbidden.has(node.text) && isRuntimeReferenceIdentifier(node)) {
+        found = true;
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(statement);
+  return found;
+}
+function createTransformSource() {
+  const project = new Project({ compilerOptions: { noUnusedLocals: true } });
+  return ({ code, filePath }) => {
+    const sourceFile = project.createSourceFile(filePath, code, { overwrite: true });
+    const forbiddenIdentifiers = /* @__PURE__ */ new Set();
+    for (const importDeclaration of sourceFile.getImportDeclarations()) {
+      const source = importDeclaration.getModuleSpecifierValue();
+      if (source === "@rpcbase/db") {
+        rewriteRpcbaseDbImport(importDeclaration, forbiddenIdentifiers);
+        continue;
+      }
+      if (!isForbiddenModuleSource(source)) continue;
+      getImportValueLocals(importDeclaration).forEach((local) => forbiddenIdentifiers.add(local));
+      importDeclaration.remove();
+    }
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const statement of sourceFile.getStatements()) {
+        const compilerStatement = statement.compilerNode;
+        if (ts.isImportDeclaration(compilerStatement)) continue;
+        if (!referencesForbiddenRuntime(compilerStatement, forbiddenIdentifiers)) continue;
+        getTopLevelBindings(compilerStatement).forEach((name) => forbiddenIdentifiers.add(name));
+        statement.remove();
+        changed = true;
+      }
+    }
+    sourceFile.fixUnusedIdentifiers();
+    sourceFile.organizeImports();
+    const nextCode = sourceFile.getFullText();
+    return nextCode === code ? null : nextCode;
+  };
+}
+function inferIsSsrTransform(transformOptions) {
+  if (typeof transformOptions === "boolean") return transformOptions;
+  if (!transformOptions || typeof transformOptions !== "object") return false;
+  return transformOptions.ssr === true;
+}
+function pruneModelsForClientPlugin() {
+  const modelsDir = `${path$1.resolve(process.cwd(), "src/models")}${path$1.sep}`;
+  const prune = createTransformSource();
+  return {
+    name: "lz-models-prune-for-browser",
+    enforce: "pre",
+    transform(code, id, transformOptions) {
+      if (inferIsSsrTransform(transformOptions)) return;
+      const filePath = id.split("?", 1)[0] ?? id;
+      if (!filePath.startsWith(modelsDir)) return;
+      const nextCode = prune({ code, filePath });
+      if (!nextCode) return;
+      return { code: nextCode };
+    }
+  };
+}
+const ensureEnvPolyfillInjectPath = () => {
+  const injectDir = path.resolve(process.cwd(), "node_modules/.rpcbase");
+  const injectPath = path.join(injectDir, "rb-env-polyfill-inject.js");
+  const injectContents = 'import "@rpcbase/env/polyfill"\n';
+  fs.mkdirSync(injectDir, { recursive: true });
+  try {
+    const existing = fs.readFileSync(injectPath, "utf8");
+    if (existing === injectContents) {
+      return injectPath;
+    }
+  } catch {
+  }
+  fs.writeFileSync(injectPath, injectContents, "utf8");
+  return injectPath;
+};
+const esbuildInjectPath = ensureEnvPolyfillInjectPath();
+const esbuildInject = [esbuildInjectPath];
+const esbuildInjectPlugins = [
+  {
+    name: "rb-env-polyfill-inject",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (args.path === esbuildInjectPath) {
+          return { path: esbuildInjectPath, namespace: "file" };
+        }
+        return void 0;
+      });
+    }
+  }
+];
+const isProduction = process.env.NODE_ENV === "production";
+const ALLOWED_DEV_ENV = ["NODE_ENV", "APP_NAME"];
+const ALLOWED_ENV_PREFIXES = [
+  "RB_PUBLIC_",
+  ...isProduction ? [] : ALLOWED_DEV_ENV
+];
+const htmlMinifyOptions = {
+  collapseWhitespace: true,
+  keepClosingSlash: true,
+  removeComments: false,
+  removeRedundantAttributes: true,
+  removeScriptTypeAttributes: true,
+  removeStyleLinkTypeAttributes: true,
+  useShortDoctype: true,
+  minifyCSS: true
+};
+const resolveAliases = {
+  "@/api": path.resolve(process.cwd(), "./src/api/"),
+  "@/models": path.resolve(process.cwd(), "./src/models/"),
+  "@/shared": path.resolve(process.cwd(), "./src/shared/"),
+  "@/types": path.resolve(process.cwd(), "./src/types/"),
+  "@": path.resolve(process.cwd(), "./src/client/")
+};
+const integratedPackages = [
+  "@hookform/resolvers",
+  "axios",
+  "events",
+  "libphonenumber-js",
+  "posthog-js",
+  "posthog-js/react",
+  "posthog-node",
+  "react-router",
+  "react-hook-form"
+];
+integratedPackages.forEach((pkg) => {
+  const resolved = resolveIntegratedPackagePath(pkg);
+  resolveAliases[pkg] = resolved;
+});
+resolveAliases["node:events"] = resolveIntegratedPackagePath("events");
+const posthogReactEsm = resolveIntegratedPackagePath("posthog-js/react/dist/esm/index.js");
+resolveAliases["posthog-js/react"] = posthogReactEsm;
+resolveAliases["posthog-js/react/dist/esm/index.js"] = posthogReactEsm;
+const rbPackagesNeedingEnvPolyfill = [
+  "@rpcbase/auth",
+  "@rpcbase/env",
+  // "@rpcbase/env/polyfill",
+  "@rpcbase/server",
+  "@rpcbase/client",
+  "@rpcbase/form",
+  "@rpcbase/router"
+];
+const createRuntimeEnv = (args) => {
+  const { env, configEnv } = args;
+  const { command, mode, isSsrBuild } = configEnv;
+  const isDevCommand = command === "serve";
+  const mergedEnv = {
+    ...env
+  };
+  return {
+    ...mergedEnv,
+    BASE_URL: mergedEnv.BASE_URL ?? "/",
+    MODE: mode,
+    DEV: isDevCommand,
+    PROD: !isDevCommand,
+    SSR: Boolean(isSsrBuild)
+  };
+};
+const getBaseConfig = (configEnv) => {
+  const { mode } = configEnv;
+  const env = loadEnv(mode, process.cwd(), ALLOWED_ENV_PREFIXES);
+  const runtimeEnv = createRuntimeEnv({ env, configEnv });
+  return {
+    clearScreen: false,
+    plugins: [
+      pruneModelsForClientPlugin(),
+      react(),
+      createHtmlPlugin({
+        // IMPORTANT: minify removes comments by default, which are used by the app ssr
+        minify: htmlMinifyOptions
+      }),
+      viteSingleFile({
+        useRecommendedBuildConfig: false,
+        deleteInlinedFiles: true,
+        inlinePattern: ["**/*.css"],
+        removeViteModuleLoader: false
+      }),
+      isProduction && posthogSourcemapsPlugin({})
+    ].filter(Boolean),
+    define: {
+      __vite_env__: runtimeEnv
+    },
+    envPrefix: ALLOWED_ENV_PREFIXES,
+    publicDir: path.join(process.cwd(), "./src/client/public"),
+    build: {
+      sourcemap: isProduction ? "hidden" : false,
+      cssCodeSplit: false,
+      outDir: "./build/dist/",
+      rollupOptions: {
+        input: {
+          app: "./src/client/index.html"
+        }
+      },
+      commonjsOptions: { transformMixedEsModules: true }
+    },
+    server: {
+      allowedHosts: true,
+      headers: {
+        "Cache-Control": "no-store"
+      },
+      watch: {
+        ignored: ["**/build/playwright/**"]
+      }
+    },
+    resolve: {
+      alias: {
+        ...resolveAliases
+      },
+      dedupe: ["react", "react-dom", "react-router", "react-hook-form"],
+      preserveSymlinks: true
+    },
+    ssr: {
+      external: [
+        // "react", "react-dom",
+        "cookie",
+        "mongoose",
+        "mongodb"
+      ],
+      noExternal: [
+        ...rbPackagesNeedingEnvPolyfill
+        // "react-use",
+      ]
+    },
+    optimizeDeps: {
+      include: [
+        // Force RPC Base packages through esbuild so rb-env-polyfill injects before their dist code touches globalThis.__rb_env__
+        ...rbPackagesNeedingEnvPolyfill,
+        "hoist-non-react-statics"
+        // "react", "react-dom", "react-dom/server"
+        // "cookie"
+      ],
+      exclude: [
+        "@radix-ui/*",
+        "@rpcbase/ui"
+        // TMP only in sample app?
+        // "react", "react-dom/server",
+        // "react-hook-form",
+        // "react-dom"
+      ],
+      esbuildOptions: {
+        inject: esbuildInject,
+        plugins: esbuildInjectPlugins
+      }
+    }
+    // future: {
+    //   removeSsrLoadModule: true
+    // },
+  };
+};
+const extendConfig = (userConfig) => {
+  return async (configEnv) => {
+    const config = typeof userConfig === "function" ? await userConfig(configEnv) : userConfig;
+    const baseConfig = getBaseConfig(configEnv);
+    return mergeConfig(baseConfig, config);
+  };
+};
+const getSpecBaseConfig = (configEnv) => {
+  const { mode } = configEnv;
+  const env = loadEnv(mode, process.cwd(), ALLOWED_ENV_PREFIXES);
+  const runtimeEnv = createRuntimeEnv({ env, configEnv });
+  const input = globSync("spec/**/*.spec.ts").reduce(
+    (inputs, file) => {
+      const relativePath = path.relative("spec", file);
+      const outputName = relativePath.replace(/\.ts$/, "");
+      inputs[outputName] = file;
+      return inputs;
+    },
+    {}
+  );
+  return {
+    clearScreen: false,
+    define: {
+      __vite_env__: runtimeEnv
+    },
+    envPrefix: ALLOWED_ENV_PREFIXES,
+    build: {
+      outDir: "./build/spec/",
+      ssr: true,
+      rollupOptions: {
+        input
+      },
+      commonjsOptions: { transformMixedEsModules: true }
+    },
+    resolve: {
+      alias: {
+        ...resolveAliases
+      },
+      preserveSymlinks: true
+    },
+    ssr: {
+      external: ["mongoose"],
+      noExternal: ["@rpcbase/*"]
+    }
+  };
+};
+const extendSpecConfig = (userConfig) => {
+  return async (configEnv) => {
+    const config = typeof userConfig === "function" ? await userConfig(configEnv) : userConfig;
+    const baseConfig = getSpecBaseConfig(configEnv);
+    return mergeConfig(baseConfig, config);
+  };
+};
+const createServer = createServer$1;
+export {
+  createServer,
+  extendConfig,
+  extendSpecConfig,
+  resolveAliases
+};

package/dist/plugins/posthog-sourcemaps/index.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+export declare function posthogSourcemapsPlugin(opts?: {
+    directory?: string;
+    version?: string;
+    host?: string;
+    deleteAfterUpload?: boolean;
+}): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/posthog-sourcemaps/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/posthog-sourcemaps/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AA+BlC,wBAAgB,uBAAuB,CAAC,IAAI,GAAE;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iBAAiB,CAAC,EAAE,OAAO,CAAA;CACvB,GAAG,MAAM,CAyCd"}

package/dist/plugins/prune-models-for-client/fixtures/alias-and-types.input.d.ts

@@ -0,0 +1,9 @@
+import { z as zz } from '../../../../../db/src';
+export declare const ZThing: zz.ZodObject<{
+    value: zz.ZodNumber;
+}, zz.core.$strip>;
+type Thing = DbSchema;
+export declare const x: Thing;
+export declare const leaked: import('../../../../../db/src').ModelsClient<import('../../../../../db/src/registerModels').ModelModules, Record<string, never>>;
+export {};
+//# sourceMappingURL=alias-and-types.input.d.ts.map

package/dist/plugins/prune-models-for-client/fixtures/alias-and-types.input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-and-types.input.d.ts","sourceRoot":"","sources":["../../../../src/plugins/prune-models-for-client/fixtures/alias-and-types.input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,IAAI,EAAE,EAAoC,MAAM,aAAa,CAAA;AAGvE,eAAO,MAAM,MAAM;;kBAAoC,CAAA;AAEvD,KAAK,KAAK,GAAG,QAAQ,CAAA;AACrB,eAAO,MAAM,CAAC,EAAmB,KAAK,CAAA;AAGtC,eAAO,MAAM,MAAM,wHAAS,CAAA"}

package/dist/plugins/prune-models-for-client/fixtures/alias-and-types.output.d.ts

@@ -0,0 +1,8 @@
+import { z as zz } from '../../../../../db/src';
+export declare const ZThing: zz.ZodObject<{
+    value: zz.ZodNumber;
+}, zz.core.$strip>;
+type Thing = DbSchema;
+export declare const x: Thing;
+export {};
+//# sourceMappingURL=alias-and-types.output.d.ts.map

package/dist/plugins/prune-models-for-client/fixtures/alias-and-types.output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-and-types.output.d.ts","sourceRoot":"","sources":["../../../../src/plugins/prune-models-for-client/fixtures/alias-and-types.output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,MAAM,aAAa,CAAA;AAGrC,eAAO,MAAM,MAAM;;kBAAoC,CAAA;AAEvD,KAAK,KAAK,GAAG,QAAQ,CAAA;AACrB,eAAO,MAAM,CAAC,EAAmB,KAAK,CAAA"}