@absolutejs/absolute 0.19.0-beta.928 → 0.19.0-beta.929

package/dist/src/core/normalizeIslandProps.d.ts

@@ -0,0 +1,15 @@
+import type { IslandFramework, IslandHydrate } from '../../types/island';
+type RawIslandProps = {
+    component: string;
+    framework: string;
+    hydrate?: string | undefined;
+    props: unknown;
+};
+export declare const normalizeRuntimeIslandRenderProps: (raw: RawIslandProps) => {
+    component: string;
+    framework: IslandFramework;
+    hydrate: IslandHydrate | undefined;
+    props: Record<string, unknown>;
+};
+export declare const normalizeIslandProps: (value: unknown) => Record<string, unknown>;
+export {};

package/dist/src/core/vueServerModule.d.ts

@@ -0,0 +1 @@
+export declare const compileVueServerModule: (sourcePath: string) => Promise<string>;

package/dist/src/vue/Island.browser.d.ts

@@ -1,13 +1,37 @@
-export declare const Island: import("vue").DefineComponent<{
-    component: string;
-    framework: import("..").IslandFramework;
-    hydrate?: import("..").IslandHydrate | undefined;
-    props: Record<string, unknown>;
-}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+export declare const Island: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    component: {
+        required: true;
+        type: StringConstructor;
+    };
+    framework: {
+        required: true;
+        type: StringConstructor;
+    };
+    hydrate: {
+        required: false;
+        type: StringConstructor;
+    };
+    props: {
+        required: false;
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
-    component: string;
-    framework: import("..").IslandFramework;
-    hydrate?: import("..").IslandHydrate | undefined;
-    props: Record<string, unknown>;
-}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    component: {
+        required: true;
+        type: StringConstructor;
+    };
+    framework: {
+        required: true;
+        type: StringConstructor;
+    };
+    hydrate: {
+        required: false;
+        type: StringConstructor;
+    };
+    props: {
+        required: false;
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/src/vue/Island.d.ts

@@ -1,12 +1,36 @@
 import { h } from 'vue';
-export declare const Island: import("vue").DefineComponent<{
-    component: string;
-    framework: import("..").IslandFramework;
-    hydrate?: import("..").IslandHydrate | undefined;
-    props: Record<string, unknown>;
-}, () => ReturnType<typeof h>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
-    component: string;
-    framework: import("..").IslandFramework;
-    hydrate?: import("..").IslandHydrate | undefined;
-    props: Record<string, unknown>;
-}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const Island: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    component: {
+        required: true;
+        type: StringConstructor;
+    };
+    framework: {
+        required: true;
+        type: StringConstructor;
+    };
+    hydrate: {
+        required: false;
+        type: StringConstructor;
+    };
+    props: {
+        required: false;
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+}>, () => ReturnType<typeof h>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    component: {
+        required: true;
+        type: StringConstructor;
+    };
+    framework: {
+        required: true;
+        type: StringConstructor;
+    };
+    hydrate: {
+        required: false;
+        type: StringConstructor;
+    };
+    props: {
+        required: false;
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/src/vue/pageHandler.d.ts

@@ -5,6 +5,14 @@ type VuePageRenderOptions = StreamingSlotEnhancerOptions & {
     collectStreamingSlots?: boolean;
 };
 export type VuePageRequestInput<Component extends VueComponent> = VuePageRenderOptions & {
+    /** Hydration mode for the page bundle.
+     *  - `'auto'` (default): emit `<script>window.__INITIAL_PROPS__=…</script>`
+     *    plus the page's `<script type="module">` index, mounting Vue on the
+     *    client.
+     *  - `'none'`: SSR-only. Skip both scripts entirely so the page ships
+     *    pure HTML — useful for marketing / docs pages that use Vue
+     *    templating + Tailwind without paying the runtime cost. */
+    client?: 'auto' | 'none';
     headTag?: `<head>${string}</head>`;
     indexPath: string;
     pagePath: string;

package/dist/svelte/index.js

@@ -2679,6 +2679,100 @@ var init_islandSsr = __esm(() => {
   renderAngularIslandToHtml2 = renderAngularIslandToHtmlInternal;
 });
 
+// src/core/vueServerModule.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve5 } from "path";
+var {Transpiler } = globalThis.Bun;
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+}, writeIfChanged2 = async (path, content) => {
+  const targetFile = Bun.file(path);
+  if (await targetFile.exists()) {
+    const currentContent = await targetFile.text();
+    if (currentContent === content)
+      return;
+  }
+  await Bun.write(path, content);
+}, stripExports = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports = (code) => {
+  const lines = code.split(`
+`);
+  const specifierSet = new Set;
+  const vueImportRegex = /^import\s+{([^}]+)}\s+from\s+['"]vue['"];?$/;
+  lines.forEach((line) => {
+    const match = line.match(vueImportRegex);
+    if (match?.[1])
+      match[1].split(",").forEach((importSpecifier) => specifierSet.add(importSpecifier.trim()));
+  });
+  const nonVueLines = lines.filter((line) => !vueImportRegex.test(line));
+  return specifierSet.size ? [
+    `import { ${[...specifierSet].join(", ")} } from "vue";`,
+    ...nonVueLines
+  ].join(`
+`) : nonVueLines.join(`
+`);
+}, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
+  const cachedModulePath = compiledModuleCache2.get(sourcePath);
+  if (cachedModulePath)
+    return cachedModulePath;
+  const compiler = await import("@vue/compiler-sfc");
+  const source = await Bun.file(sourcePath).text();
+  const { descriptor } = compiler.parse(source, { filename: sourcePath });
+  const componentId = Bun.hash(sourcePath).toString(BASE_36_RADIX).slice(0, ISLAND_COMPONENT_ID_LENGTH);
+  const hasScript = descriptor.script || descriptor.scriptSetup;
+  const compiledScript = hasScript ? compiler.compileScript(descriptor, {
+    id: componentId,
+    inlineTemplate: false
+  }) : { bindings: {}, content: "export default {};" };
+  const renderCode = descriptor.template ? compiler.compileTemplate({
+    compilerOptions: {
+      bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      prefixIdentifiers: true,
+      isCustomElement: (tag) => tag === "absolute-island"
+    },
+    filename: sourcePath,
+    id: componentId,
+    scoped: descriptor.styles.some((styleBlock) => styleBlock.scoped),
+    source: descriptor.template.content,
+    ssr: true,
+    ssrCssVars: descriptor.cssVars
+  }).code : "const ssrRender = () => {};";
+  const childImportPaths = extractRelativeVueImports(compiledScript.content);
+  const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
+    compiledPath: await compileVueServerModule(resolve5(dirname3(sourcePath), relativeImport)),
+    spec: relativeImport
+  })));
+  const strippedScript = stripExports(compiledScript.content);
+  const transpiledScript = transpiler2.transformSync(strippedScript);
+  const assembled = mergeVueImports([
+    transpiledScript,
+    renderCode,
+    "script.ssrRender = ssrRender;",
+    "export default script;"
+  ].join(`
+`));
+  const compiledModulePath = getCachedModulePath2(sourcePath);
+  let rewritten = assembled;
+  for (const child of compiledChildren) {
+    rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
+  }
+  await mkdir2(dirname3(compiledModulePath), { recursive: true });
+  await writeIfChanged2(compiledModulePath, rewritten);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  return compiledModulePath;
+};
+var init_vueServerModule = __esm(() => {
+  init_constants();
+  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache2 = new Map;
+  transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
+});
+
 // src/core/islandManifest.ts
 var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1), collectFrameworkIslands = (manifest, prefix) => {
   const entries = {};
@@ -2765,9 +2859,17 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
   const loadPromise = loadAndCompileServerBuildComponent(buildReferencePath);
   resolvedServerBuildComponentCache.set(buildReferencePath, loadPromise);
   return loadPromise;
+}, resolveRuntimeImportTarget = async (resolvedModulePath) => {
+  if (resolvedModulePath.endsWith(".svelte")) {
+    return compileSvelteServerModule(resolvedModulePath);
+  }
+  if (resolvedModulePath.endsWith(".vue")) {
+    return compileVueServerModule(resolvedModulePath);
+  }
+  return resolvedModulePath;
 }, loadServerImportComponent = async (resolvedComponent, exportName) => {
   const resolvedModulePath = resolvedComponent.startsWith(".") ? new URL(resolvedComponent, import.meta.url).pathname : resolvedComponent;
-  const importTarget = resolvedModulePath.endsWith(".svelte") ? await compileSvelteServerModule(resolvedModulePath) : resolvedModulePath;
+  const importTarget = await resolveRuntimeImportTarget(resolvedModulePath);
   const loadedModule = await import(importTarget);
   if (exportName && exportName !== "default" && exportName in loadedModule) {
     return loadedModule[exportName];
@@ -2871,6 +2973,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
   init_svelteServerModule();
+  init_vueServerModule();
   init_islandMarkupAttributes();
   init_islands2();
   resolvedServerComponentCache = new Map;
@@ -3836,5 +3939,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=95A608C071E9664464756E2164756E21
+//# debugId=76F703206AC2F94E64756E2164756E21
 //# sourceMappingURL=index.js.map