@ecopages/kitajs 0.2.1 → 0.3.1

package/README.md

@@ -5,31 +5,37 @@ Integration plugin for [KitaJS](https://kitajs.org/html/) HTML in Ecopages. Use
 ## Installation
 
 ```bash
-bunx jsr add @ecopages/kitajs
+bun add @ecopages/kitajs @kitajs/html @kitajs/ts-html-plugin
 ```
 
+`@kitajs/html` and `@kitajs/ts-html-plugin` are required peer dependencies for this package.
+
 ## Usage
 
 Import and register the `kitajsPlugin` in your `eco.config.ts`.
 
 ```ts
-import { ConfigBuilder } from '@ecopages/core/config-builder';
+import { defineConfig } from '@ecopages/core/config';
 import { kitajsPlugin } from '@ecopages/kitajs';
 
-const config = await new ConfigBuilder()
-	.setBaseUrl(import.meta.env.ECOPAGES_BASE_URL)
-	.setIntegrations([kitajsPlugin()])
-	.build();
-
-export default config;
+export default defineConfig({ integrations: [kitajsPlugin()] });
 ```
 
 ## What This Integration Owns
 
 - `.kita.tsx` route files.
 - Page, layout, and document shells rendered by `@kitajs/html`.
-- HTML-first outer shells that host nested component boundaries from other integrations.
+- HTML-first outer shells that host nested foreign subtrees from other integrations.
+
+The default renderer uses core's `createIntegrationRenderer()` factory. Core owns the common route and document-shell pipeline; add hooks for Kita-specific behavior, and subclass only when the hook API cannot express a needed capability.
 
 ## Mixed Rendering
 
-Kita works well as the outer renderer in mixed apps. When a Kita-owned page encounters a nested boundary from another integration, Ecopages resolves that boundary with its owning renderer and inserts the resulting HTML back into the Kita shell.
+Kita works well as the outer renderer in mixed apps. When a Kita-owned page encounters a nested foreign child from another integration, Ecopages resolves that foreign subtree with its owning renderer and inserts the resulting HTML back into the Kita shell.
+
+Important:
+
+- Components that may render foreign children must declare those children in `config.dependencies.components`.
+- Ecopages validates mixed-renderer ownership from declared dependencies during render preparation instead of inferring every foreign child from rendered HTML.
+- Route-level dependency resolvers can supply Components at request time; Kita includes those resolved roots through the shared string renderer when deciding whether a Foreign Subtree needs handoff.
+- Kita remains an HTML-first outer shell. Same-integration Kita children do not go through a separate universal child serialization contract.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/kitajs",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Kitajs plugin for Ecopages",
   "keywords": [
     "ecopages",
@@ -11,14 +11,31 @@
   "main": "./src/kitajs.plugin.js",
   "types": "./src/kitajs.plugin.d.ts",
   "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "default": "./src/kitajs.plugin.js",
+      "types": "./src/kitajs.plugin.d.ts"
+    },
+    "./eco-embed": {
+      "default": "./src/eco-embed.js",
+      "types": "./src/eco-embed.d.ts"
+    },
+    "./eco-embed.ts": {
+      "default": "./src/eco-embed.js",
+      "types": "./src/eco-embed.d.ts"
+    }
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/ecopages/ecopages.git",
+    "url": "git+https://github.com/ecopages/ecopages.git",
     "directory": "packages/integrations/kitajs"
   },
   "peerDependencies": {
-    "@ecopages/core": "0.2.1",
+    "@ecopages/core": "0.3.1",
     "@kitajs/html": "^4.1.0",
     "@kitajs/ts-html-plugin": "^4.0.1"
   }
-}
+}

package/src/eco-embed.d.ts

@@ -0,0 +1,10 @@
+import type { EcoComponent, EcoEmbedProps as CoreEcoEmbedProps, EcoPagesElement } from '@ecopages/core';
+/**
+ * Props for the Kita-owned `EcoEmbed` adapter.
+ */
+export type EcoEmbedProps<TComponent extends EcoComponent> = CoreEcoEmbedProps<TComponent>;
+/**
+ * Renders a foreign or same-integration eco component from a Kita JSX file
+ * without forcing inline mixed-JSX authoring.
+ */
+export declare function EcoEmbed<TComponent extends EcoComponent>({ component, props, children, }: EcoEmbedProps<TComponent>): EcoPagesElement;

package/src/eco-embed.js

@@ -0,0 +1,9 @@
+/** @jsxImportSource @kitajs/html */
+import { eco } from '@ecopages/core';
+/**
+ * Renders a foreign or same-integration eco component from a Kita JSX file
+ * without forcing inline mixed-JSX authoring.
+ */
+export function EcoEmbed({ component, props, children, }) {
+    return eco.embed(component, props, children);
+}

package/src/kitajs-renderer.d.ts

@@ -2,24 +2,9 @@
  * This module contains the Kita.js renderer
  * @module
  */
-import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoPagesElement, IntegrationRendererRenderOptions, RouteRendererBody } from '@ecopages/core';
-import { IntegrationRenderer, type RenderToResponseContext } from '@ecopages/core/route-renderer/integration-renderer';
 /**
- * A renderer for the Kita.js integration.
- * It renders a page using the HtmlTemplate and Page components.
+ * A renderer for the Kita.js integration, backed by core's shared route pipeline.
  */
-export declare class KitaRenderer extends IntegrationRenderer<EcoPagesElement> {
+export declare const KitaRenderer: new (options: import("@ecopages/core/integration").IntegrationRendererOptions) => import("@ecopages/core/integration").IntegrationRenderer<import("@ecopages/core").EcoPagesElement> & {
     name: string;
-    /**
-     * Renders a Kita component boundary for component-level orchestration.
-     *
-     * Includes component-scoped dependency assets when declared.
-     */
-    renderComponent(input: ComponentRenderInput): Promise<ComponentRenderResult>;
-    protected createComponentBoundaryRuntime(options: {
-        boundaryInput: ComponentRenderInput;
-        rendererCache: Map<string, IntegrationRenderer<any>>;
-    }): import("@ecopages/core").ComponentBoundaryRuntime;
-    render({ params, query, props, locals, pageLocals, metadata, Page, Layout, HtmlTemplate, }: IntegrationRendererRenderOptions): Promise<RouteRendererBody>;
-    renderToResponse<P = Record<string, unknown>>(view: EcoComponent<P>, props: P, ctx: RenderToResponseContext): Promise<Response>;
-}
+};

package/src/kitajs-renderer.js

@@ -1,66 +1,10 @@
-import { IntegrationRenderer } from "@ecopages/core/route-renderer/integration-renderer";
-import { PLUGIN_NAME } from "./kitajs.plugin.js";
-class KitaRenderer extends IntegrationRenderer {
-  name = PLUGIN_NAME;
-  /**
-   * Renders a Kita component boundary for component-level orchestration.
-   *
-   * Includes component-scoped dependency assets when declared.
-   */
-  async renderComponent(input) {
-    return this.renderStringComponentBoundaryWithQueuedForeignBoundaries(
-      input,
-      input.component
-    );
-  }
-  createComponentBoundaryRuntime(options) {
-    return this.createQueuedBoundaryRuntime({
-      boundaryInput: options.boundaryInput,
-      rendererCache: options.rendererCache
-    });
-  }
-  async render({
-    params,
-    query,
-    props,
-    locals,
-    pageLocals,
-    metadata,
-    Page,
-    Layout,
-    HtmlTemplate
-  }) {
-    try {
-      return await this.renderPageWithDocumentShell({
-        page: {
-          component: Page,
-          props: { params, query, ...props, locals: pageLocals }
-        },
-        layout: Layout ? {
-          component: Layout,
-          props: locals ? { locals } : {}
-        } : void 0,
-        htmlTemplate: HtmlTemplate,
-        metadata,
-        pageProps: props ?? {}
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering page", error);
-    }
-  }
-  async renderToResponse(view, props, ctx) {
-    try {
-      return await this.renderViewWithDocumentShell({
-        view,
-        props,
-        ctx,
-        layout: view.config?.layout
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering view", error);
-    }
-  }
-}
-export {
-  KitaRenderer
-};
+/**
+ * This module contains the Kita.js renderer
+ * @module
+ */
+import { createIntegrationRenderer } from '@ecopages/core/integration';
+import { KITAJS_PLUGIN_NAME } from './kitajs.constants.js';
+/**
+ * A renderer for the Kita.js integration, backed by core's shared route pipeline.
+ */
+export const KitaRenderer = createIntegrationRenderer(KITAJS_PLUGIN_NAME);

package/src/kitajs.constants.d.ts

@@ -0,0 +1 @@
+export declare const KITAJS_PLUGIN_NAME = "kitajs";

package/src/kitajs.constants.js

@@ -0,0 +1 @@
+export const KITAJS_PLUGIN_NAME = 'kitajs';

package/src/kitajs.plugin.d.ts

@@ -1,20 +1,8 @@
-import { IntegrationPlugin, type IntegrationPluginConfig } from '@ecopages/core/plugins/integration-plugin';
-import { KitaRenderer } from './kitajs-renderer.js';
+import { type DefinedIntegration } from '@ecopages/core/integration';
 /**
  * The name of the Kita.js plugin
  */
 export declare const PLUGIN_NAME = "kitajs";
-/**
- * The Kita.js plugin class
- * This plugin provides support for Kita.js components in Ecopages
- */
-export declare class KitaHtmlPlugin extends IntegrationPlugin {
-    renderer: typeof KitaRenderer;
-    constructor(options?: Omit<IntegrationPluginConfig, 'name'>);
-}
-/**
- * Factory function to create a Kita.js plugin instance.
- * @param options Configuration options for the Kita.js plugin
- * @returns A new KitaHtmlPlugin instance
- */
-export declare function kitajsPlugin(options?: Omit<IntegrationPluginConfig, 'name'>): KitaHtmlPlugin;
+export declare const kitajsPlugin: DefinedIntegration;
+/** @deprecated Use {@link kitajsPlugin.Plugin} or {@link kitajsPlugin} instead. */
+export declare const KitaHtmlPlugin: new (options?: Omit<import("@ecopages/core/integration").IntegrationPluginConfig, "name">) => import("@ecopages/core/integration").IntegrationPlugin<import("@ecopages/core").EcoPagesElement>;

package/src/kitajs.plugin.js

@@ -1,22 +1,15 @@
-import { IntegrationPlugin } from "@ecopages/core/plugins/integration-plugin";
-import { KitaRenderer } from "./kitajs-renderer.js";
-const PLUGIN_NAME = "kitajs";
-class KitaHtmlPlugin extends IntegrationPlugin {
-  renderer = KitaRenderer;
-  constructor(options) {
-    super({
-      name: PLUGIN_NAME,
-      extensions: [".kita.tsx"],
-      jsxImportSource: "@kitajs/html",
-      ...options
-    });
-  }
-}
-function kitajsPlugin(options) {
-  return new KitaHtmlPlugin(options);
-}
-export {
-  KitaHtmlPlugin,
-  PLUGIN_NAME,
-  kitajsPlugin
-};
+import { defineIntegration } from '@ecopages/core/integration';
+import { KitaRenderer } from './kitajs-renderer.js';
+import { KITAJS_PLUGIN_NAME } from './kitajs.constants.js';
+/**
+ * The name of the Kita.js plugin
+ */
+export const PLUGIN_NAME = KITAJS_PLUGIN_NAME;
+export const kitajsPlugin = defineIntegration({
+    name: PLUGIN_NAME,
+    extensions: ['.kita.tsx'],
+    jsxImportSource: '@kitajs/html',
+    renderer: KitaRenderer,
+});
+/** @deprecated Use {@link kitajsPlugin.Plugin} or {@link kitajsPlugin} instead. */
+export const KitaHtmlPlugin = kitajsPlugin.Plugin;

package/CHANGELOG.md

@@ -1,19 +0,0 @@
-# Changelog
-
-All notable changes to `@ecopages/kitajs` are documented here.
-
-> **Note:** Changelog tracking begins at version `0.2.0`. Changes prior to this release are not recorded here but are available in the git history.
-
-## [0.2.1] — 2026-04-16
-
-### Bug Fixes
-
-- Fixed Kita full-route and direct `ctx.render()` rendering to stay on the renderer-owned page/layout/document path while resolving mixed boundaries inside the owning renderer.
-
-### Documentation
-
-- Updated the README to document `.kita.tsx` route ownership and Kita's role as an outer shell in mixed-renderer apps.
-
-### Tests
-
-- Updated integration coverage for explicit boundary composition and Node and esbuild compatibility.