@pyric/cli 0.1.0-alpha.14 → 0.1.0-alpha.16

package/src/serve/vite-module-swap.ts

@@ -0,0 +1,119 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import type { Plugin as EsbuildPlugin } from 'esbuild';
+import type { ResolvedConfig, UserConfig } from 'vite';
+import {
+  SDK_MODULES,
+  defaultSdkEntries,
+  pyricPackageRoot,
+  NODE_BUILTIN_RE,
+  NODE_BUILTIN_SHIMS,
+} from './bundler.js';
+
+const FIREBASE_SPECIFIER = /^firebase\/([a-z-]+(?:\/[a-z-]+)*)$/;
+const SERVED_FIREBASE_SUBPATHS = new Set(
+  SDK_MODULES.map((specifier) => specifier.slice('firebase/'.length)),
+);
+const NODE_SHIM_PREFIX = '\0pyric:node-shim:';
+
+function entryKey(subpath: string): string {
+  return subpath.replaceAll('/', '-');
+}
+
+function packageRootOf(file: string): string {
+  let dir = path.dirname(file);
+  while (dir !== path.dirname(dir) && !existsSync(path.join(dir, 'package.json'))) {
+    dir = path.dirname(dir);
+  }
+  return dir;
+}
+
+export interface ViteModuleContext {
+  entries: ReturnType<typeof defaultSdkEntries>;
+  cliRoot: string;
+}
+
+export interface ViteModuleSwap {
+  config(): UserConfig;
+  configResolved(config: ResolvedConfig): void;
+  resolveId(source: string, importer: string | undefined): string | null;
+  load(id: string): string | null;
+}
+
+export function createViteModuleContext(): ViteModuleContext {
+  const entries = defaultSdkEntries();
+  return { entries, cliRoot: packageRootOf(entries.init) };
+}
+
+/** Own the Vite and optimizer forms of the Firebase-module swap. */
+export function createViteModuleSwap(context: ViteModuleContext): ViteModuleSwap {
+  const { entries, cliRoot } = context;
+  const pyricRoot = pyricPackageRoot();
+
+  const isPyricImporter = (importer: string | undefined): boolean => {
+    if (!importer) return false;
+    const file = importer.split('?')[0];
+    return file === pyricRoot || file.startsWith(pyricRoot + path.sep);
+  };
+  const isOurCode = (importer: string | undefined): boolean => {
+    if (!importer) return false;
+    if (isPyricImporter(importer)) return true;
+    const file = importer.split('?')[0];
+    return file === cliRoot || file.startsWith(cliRoot + path.sep);
+  };
+  const shimFor = (specifier: string): string =>
+    NODE_BUILTIN_SHIMS[specifier.replace(/^node:/, '')]!;
+
+  const optimizerMirror: EsbuildPlugin = {
+    name: 'pyric-sandbox-optimizer',
+    setup(build) {
+      build.onResolve({ filter: FIREBASE_SPECIFIER }, (args) => {
+        const subpath = FIREBASE_SPECIFIER.exec(args.path)![1]!;
+        if (SERVED_FIREBASE_SUBPATHS.has(subpath)) {
+          return { path: entries[entryKey(subpath)]! };
+        }
+        return null;
+      });
+      build.onResolve({ filter: NODE_BUILTIN_RE }, (args) => {
+        if (!isOurCode(args.importer)) return null;
+        return { path: args.path.replace(/^node:/, ''), namespace: 'pyric-node-shim' };
+      });
+      build.onLoad({ filter: /.*/, namespace: 'pyric-node-shim' }, (args) => ({
+        contents: NODE_BUILTIN_SHIMS[args.path]!,
+        loader: 'js',
+      }));
+    },
+  };
+
+  return {
+    config() {
+      return {
+        optimizeDeps: {
+          exclude: [...SDK_MODULES],
+          include: ['js-md5', 'js-sha256'],
+          esbuildOptions: { plugins: [optimizerMirror] },
+        },
+      } as unknown as UserConfig;
+    },
+    configResolved(config) {
+      const allow = config.server?.fs?.allow;
+      if (!allow) return;
+      for (const dir of [pyricRoot, cliRoot]) {
+        if (!allow.includes(dir)) allow.push(dir);
+      }
+    },
+    resolveId(source, importer) {
+      const firebase = FIREBASE_SPECIFIER.exec(source);
+      if (firebase) {
+        const subpath = firebase[1]!;
+        return SERVED_FIREBASE_SUBPATHS.has(subpath) ? entries[entryKey(subpath)]! : null;
+      }
+      const node = NODE_BUILTIN_RE.exec(source);
+      return node && isOurCode(importer) ? NODE_SHIM_PREFIX + node[2]! : null;
+    },
+    load(id) {
+      if (!id.startsWith(NODE_SHIM_PREFIX)) return null;
+      return shimFor(id.slice(NODE_SHIM_PREFIX.length));
+    },
+  };
+}

package/src/serve/vite-page-runtime.ts

@@ -0,0 +1,100 @@
+import type { ConfigEnv, UserConfig } from 'vite';
+import { SANDBOX_BUILD_META } from './sandbox-marker.js';
+import {
+  loadViteAiEnv,
+  resolveViteAiConfig,
+  type PyricAiOptions,
+  type ResolvedViteAiConfig,
+} from './vite-ai-config.js';
+import type { ViteWorkerRuntime } from './vite-worker-runtime.js';
+import {
+  PYRIC_RUNTIME_CHIP_META,
+  runtimeChipMetaValue,
+  type PyricRuntimeChipOption,
+} from './runtime/chip-config.js';
+
+export interface VitePageRuntimeOptions {
+  runtimeChip?: PyricRuntimeChipOption;
+  swapInBuild?: boolean;
+  ai?: PyricAiOptions;
+}
+
+export interface VitePageRuntime {
+  applies(env: ConfigEnv): boolean;
+  config(config: UserConfig, env: ConfigEnv): UserConfig;
+  ai(): ResolvedViteAiConfig;
+  buildStart(emitFile: (chunk: { type: 'chunk'; id: string; name: string }) => string): void;
+  generateBundle(getFileName: (referenceId: string) => string): void;
+  transformIndexHtml(html: string): string;
+}
+
+function swapsInBuild(env: ConfigEnv, override: boolean | undefined): boolean {
+  return override ?? env.mode !== 'production';
+}
+
+function injectIntoHead(html: string, tags: string): string {
+  if (html.includes('</head>')) return html.replace('</head>', `${tags}</head>`);
+  return tags + html;
+}
+
+/** Own build-generation and served-page state for one plugin instance. */
+export function createVitePageRuntime(input: {
+  options: VitePageRuntimeOptions;
+  studioEnabled: boolean;
+  initEntry: string;
+  workerRuntime: ViteWorkerRuntime;
+}): VitePageRuntime {
+  const { options, studioEnabled, initEntry, workerRuntime } = input;
+  let resolvedAi = resolveViteAiConfig(options.ai, {});
+  let sandboxBuild = false;
+  let initChunkRef: string | undefined;
+  let initChunkFile: string | undefined;
+
+  return {
+    applies(env) {
+      return env.command === 'serve' || swapsInBuild(env, options.swapInBuild);
+    },
+    config(config, env) {
+      sandboxBuild = env.command === 'build';
+      const loadedEnv = loadViteAiEnv(env.mode, config.root, config.envDir);
+      resolvedAi = resolveViteAiConfig(options.ai, loadedEnv);
+      return sandboxBuild ? { build: { target: 'esnext' } } : {};
+    },
+    ai() {
+      return resolvedAi;
+    },
+    buildStart(emitFile) {
+      if (!sandboxBuild) return;
+      initChunkRef = emitFile({
+        type: 'chunk',
+        id: initEntry,
+        name: 'pyric-sandbox-init',
+      });
+    },
+    generateBundle(getFileName) {
+      if (initChunkRef) initChunkFile = getFileName(initChunkRef);
+    },
+    transformIndexHtml(html) {
+      const marker = 'data-pyric-sandbox';
+      const runtimeChipTag = `<meta name="${PYRIC_RUNTIME_CHIP_META}" content="${runtimeChipMetaValue(options.runtimeChip)}" data-studio="${studioEnabled ? 'on' : 'off'}" ${marker}>`;
+      if (sandboxBuild) {
+        if (html.includes(SANDBOX_BUILD_META)) return html;
+        let initTag = '';
+        if (initChunkFile) {
+          initTag = `<script type="module" crossorigin src="/${initChunkFile}" data-pyric-sandbox-init></script>`;
+        }
+        const tags = SANDBOX_BUILD_META + runtimeChipTag + initTag;
+        return injectIntoHead(html, tags);
+      }
+      if (html.includes(marker)) return html;
+      const head = workerRuntime.headTag(marker);
+      let aiEngineTag = '';
+      if (resolvedAi.engineWire) {
+        aiEngineTag = `<script ${marker}>globalThis.__PYRIC_AI_ENGINE__=${JSON.stringify(resolvedAi.engineWire).replace(/</g, '\\u003c')};</script>`;
+      }
+      const tag = head + aiEngineTag + runtimeChipTag +
+        `<script type="module" src="/@fs/${initEntry}" ${marker}></script>`;
+      return injectIntoHead(html, tag);
+    },
+  };
+}