pudui 0.0.0

package/dist/transforms.d.mts

@@ -0,0 +1,150 @@
+//#region src/transforms.d.ts
+type HydrateCall = {
+  end: number;
+  exportName: string;
+  start: number;
+};
+type EntryCall = {
+  end: number;
+  start: number;
+};
+/**
+ * Mode-specific options for transforming `pudui/macros` calls.
+ */
+type TransformHydrateOptions = {
+  /**
+   * Removes macro calls from client build output.
+   */
+  mode: "client";
+} | {
+  /**
+   * Browser entry module used for hydrated client bundles.
+   */
+  browserEntry: string;
+  /**
+   * Creates a serializable marker for an entry macro call.
+   */
+  createEntryMarker(id: string): string;
+  /**
+   * Creates a serializable marker for a hydrate macro call.
+   */
+  createHydrateMarker(id: string, exportName: string): string;
+  /**
+   * Replaces macro calls with build markers for later manifest resolution.
+   */
+  mode: "build";
+} | {
+  /**
+   * Browser entry module used for development hydration.
+   */
+  browserEntry?: string;
+  /**
+   * Browser-served path for the development entry module.
+   */
+  browserEntryPath?: string;
+  /**
+   * JavaScript expression that evaluates to entry stylesheet URLs.
+   */
+  entryStylesExpression?: string;
+  /**
+   * Replaces macro calls with development-time metadata.
+   */
+  mode: "dev";
+  /**
+   * Browser-served path for the transformed module.
+   */
+  modulePath: string;
+};
+/**
+ * Result of transforming `hydrate()` and `entry()` macro calls.
+ */
+type HydrateTransformResult = {
+  /**
+   * Transformed JavaScript source.
+   */
+  code: string;
+  /**
+   * Source ranges for transformed `entry()` calls.
+   */
+  entryCalls: EntryCall[];
+  /**
+   * Source ranges for transformed `hydrate()` calls.
+   */
+  hydrateCalls: HydrateCall[];
+  /**
+   * Source map placeholder.
+   */
+  map: null;
+};
+/**
+ * Result of transforming a `"use client"` module.
+ */
+type UseClientTransformResult = {
+  /**
+   * Transformed JavaScript source.
+   */
+  code: string;
+  /**
+   * Source ranges for component option objects that received `hydrate()`.
+   */
+  componentOptions: Array<{
+    end: number;
+    start: number;
+  }>;
+  /**
+   * Source map placeholder.
+   */
+  map: null;
+};
+/**
+ * Injects hydration macros into exported components in a `"use client"` module.
+ *
+ * The transform looks for exported component factories that create
+ * `new Component({ ... })` and appends `hydrate: hydrate()` when needed.
+ *
+ * @param code Module source code.
+ * @param id Stable module identifier used for parsing diagnostics.
+ * @returns Transform result, or `null` when the module does not need changes.
+ *
+ * @example
+ * ```ts
+ * const result = transformUseClient('"use client"; export function App() {}', "/src/app.tsx");
+ * ```
+ */
+declare function transformUseClient(code: string, id: string): UseClientTransformResult | null;
+/**
+ * Replaces `hydrate()` and `entry()` macro calls with runtime metadata.
+ *
+ * This is the lower-level transform used by the Vite plugin. Applications
+ * usually import the macros from `pudui/macros` and let the plugin call this.
+ *
+ * @param code Module source code.
+ * @param id Stable module identifier used in hydration metadata.
+ * @param options Mode-specific transform options.
+ * @returns Transform result, or `null` when the module does not use macros.
+ */
+declare function transformHydrate(code: string, id: string, options: TransformHydrateOptions): HydrateTransformResult | null;
+/**
+ * Replaces build-time hydration marker calls with manifest-derived metadata.
+ *
+ * @param code Generated bundle code containing marker calls.
+ * @param resolveMarker Function that maps marker strings to replacement arrays.
+ * @returns Code with resolved marker calls replaced by JSON arrays.
+ */
+declare function replaceHydrateMarkers(code: string, resolveMarker: (marker: string) => readonly unknown[] | undefined): string;
+/**
+ * Quickly checks whether source may contain Pudui macro calls.
+ *
+ * @param code Module source code.
+ * @returns `true` when the source should be parsed for `hydrate()` or `entry()` macros.
+ */
+declare function shouldTransformHydrate(code: string): boolean;
+/**
+ * Quickly checks whether source may contain `"use client"` components.
+ *
+ * @param code Module source code.
+ * @returns `true` when the source should be parsed by {@link transformUseClient}.
+ */
+declare function shouldTransformUseClient(code: string): boolean;
+//#endregion
+export { HydrateTransformResult, TransformHydrateOptions, UseClientTransformResult, replaceHydrateMarkers, shouldTransformHydrate, shouldTransformUseClient, transformHydrate, transformUseClient };

package/dist/transforms.mjs

@@ -0,0 +1,2 @@
+import { a as transformUseClient, i as transformHydrate, n as shouldTransformHydrate, r as shouldTransformUseClient, t as replaceHydrateMarkers } from "./transforms-DUsCAPAL.mjs";
+export { replaceHydrateMarkers, shouldTransformHydrate, shouldTransformUseClient, transformHydrate, transformUseClient };

package/dist/vite-plugin.d.mts

@@ -0,0 +1,224 @@
+import { HydrateTransformResult, UseClientTransformResult, replaceHydrateMarkers, transformHydrate, transformUseClient } from "./transforms.mjs";
+
+//#region src/hmr-transform.d.ts
+/**
+ * Options for the Pudui component HMR source transform.
+ */
+type HmrTransformOptions = {
+  /**
+   * Expression used to access the module hot context.
+   */
+  importMeta?: string;
+  /**
+   * Parameter name injected into transformed component setup functions.
+   */
+  refreshParameterName?: string;
+  /**
+   * Module specifier for the HMR runtime import.
+   */
+  runtimeModule?: string;
+  /**
+   * Local binding name for the imported HMR runtime namespace.
+   */
+  runtimeName?: string;
+};
+//#endregion
+//#region src/transforms/types.d.ts
+/**
+ * Configuration for the Pudui Vite plugin.
+ */
+type Options = {
+  /**
+   * Browser entry module that starts client-side hydration.
+   *
+   * The plugin adds this entry to client builds and uses it to resolve
+   * hydration metadata for server-rendered boundaries.
+   */
+  browserEntry: string;
+  /**
+   * Hot module replacement settings.
+   *
+   * Set to `false` to disable Pudui component refresh transforms.
+   */
+  hmr?: false | HmrTransformOptions;
+};
+/**
+ * Minimal Vite resolved config shape used by Pudui transforms.
+ */
+type ViteResolvedConfig = {
+  base?: string;
+  command?: "build" | "serve";
+  root: string;
+};
+/**
+ * Minimal Vite environment shape used by Pudui transforms.
+ */
+type ViteEnvironment = {
+  mode?: "build" | "dev";
+  name?: string;
+};
+/**
+ * Minimal Vite build environment shape used by Pudui build hooks.
+ */
+type BuildEnvironment = {
+  config: {
+    build: {
+      emitAssets?: boolean;
+      outDir?: string;
+      rolldownOptions: {
+        input?: string[];
+        preserveEntrySignatures?: false | "allow-extension" | "exports-only" | "strict";
+      };
+    };
+  };
+  isBuilt: boolean;
+  name: string;
+};
+/**
+ * Module resolution result returned by Vite's plugin context.
+ */
+type ResolveResult = {
+  id: string;
+};
+/**
+ * Minimal transform context passed to Pudui transform hooks.
+ */
+type TransformContext = {
+  environment?: ViteEnvironment;
+  resolve?(source: string, importer?: string, options?: {
+    skipSelf?: boolean;
+  }): Promise<ResolveResult | null>;
+};
+/**
+ * Minimal Vite builder shape used by the Pudui macro plugin.
+ */
+type ViteBuilder = {
+  build(environment: BuildEnvironment): Promise<unknown>;
+  environments: Record<string, BuildEnvironment>;
+};
+/**
+ * Minimal generate-bundle context used by Pudui build hooks.
+ */
+type GenerateBundleContext = {
+  environment?: ViteEnvironment;
+};
+/**
+ * Output bundle map produced by Vite or Rolldown.
+ */
+type OutputBundle = Record<string, OutputAsset | OutputChunk>;
+/**
+ * Emitted asset in a build output bundle.
+ */
+type OutputAsset = {
+  fileName: string;
+  source?: string | Uint8Array;
+  type: "asset";
+};
+/**
+ * Emitted chunk in a build output bundle.
+ */
+type OutputChunk = {
+  code: string;
+  fileName: string;
+  imports: string[];
+  type: "chunk";
+};
+/**
+ * Environment-level Vite options returned by Pudui plugins.
+ */
+type EnvironmentOptions = {
+  build?: {
+    emitAssets?: boolean;
+    manifest?: boolean | string;
+  };
+};
+/**
+ * Minimal Vite plugin contract used by Pudui.
+ */
+type Plugin = {
+  buildApp?: ((builder: ViteBuilder) => Promise<void>) | {
+    handler(builder: ViteBuilder): Promise<void>;
+    order?: "pre" | "post";
+  };
+  configEnvironment?(name: string, config: EnvironmentOptions): EnvironmentOptions | void;
+  configResolved?(config: ViteResolvedConfig): void;
+  enforce?: "pre" | "post";
+  generateBundle?: ((this: GenerateBundleContext, options: unknown, bundle: OutputBundle) => void) | {
+    handler(this: GenerateBundleContext, options: unknown, bundle: OutputBundle): void;
+    order?: "pre" | "post";
+  };
+  name: string;
+  sharedDuringBuild?: boolean;
+  transform?(this: TransformContext, code: string, id: string): Promise<null | string | {
+    code: string;
+    map: null;
+  }> | null | string | {
+    code: string;
+    map: null;
+  };
+};
+/**
+ * Vite plugin option value returned by Pudui plugin factories.
+ */
+type PluginOption = Plugin | PluginOption[] | false | null | undefined;
+//#endregion
+//#region src/vite-plugin.d.ts
+/**
+ * Creates the full Pudui Vite plugin set.
+ *
+ * The returned plugins transform `"use client"` components, replace
+ * `pudui/macros` calls, wire build manifest assets, and enable component HMR in
+ * development.
+ *
+ * @param options Pudui Vite plugin options.
+ * @returns Vite plugins required for Pudui applications.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "vite";
+ * import pudui from "pudui/vite-plugin";
+ *
+ * export default defineConfig({
+ *   plugins: [pudui({ browserEntry: "app/browser.tsx" })],
+ * });
+ * ```
+ */
+declare function pudui(options: Options): Plugin[];
+/**
+ * Creates the transform that injects hydration macros for `"use client"` modules.
+ *
+ * Most applications should use the default {@link pudui} plugin set instead of
+ * composing this directly.
+ *
+ * @returns A Vite plugin that scans client modules for exported components.
+ */
+declare function useClientPlugin(): Plugin;
+/**
+ * Creates the transform and build hooks that resolve Pudui macros.
+ *
+ * The plugin replaces `hydrate()` and `entry()` macro calls, adds client build
+ * entries for hydrated modules, and copies manifest asset metadata between Vite
+ * environments.
+ *
+ * @param options Pudui Vite plugin options.
+ * @param options.browserEntry Browser entry module used for hydrated client bundles.
+ * @returns A Vite plugin for macro transformation and build metadata.
+ */
+declare function macrosPlugin(options: Options): Plugin;
+/**
+ * Creates the Pudui component HMR transform.
+ *
+ * This is exported for advanced Vite integrations that need to compose Pudui's
+ * plugin pieces manually.
+ *
+ * @param options HMR plugin options.
+ * @param options.hmr HMR options, or `false` to disable the transform.
+ * @returns A Vite plugin that rewrites components for refresh.
+ */
+declare function hrmPlugin(options?: Pick<Options, "hmr">): Plugin;
+/**
+ * Alias for {@link hrmPlugin}.
+ */
+declare const hmrPlugin: typeof hrmPlugin;
+//#endregion
+export { type HydrateTransformResult, type Options, type PluginOption, type UseClientTransformResult, pudui as default, hmrPlugin, hrmPlugin, macrosPlugin, replaceHydrateMarkers, transformHydrate, transformUseClient, useClientPlugin };