@zubyjs/preact 1.0.30 → 1.0.32

package/index.js

@@ -1,4 +1,3 @@
-import render from './render.js';
 import { fileURLToPath } from 'url';
 import { dirname, resolve } from 'path';
 import { normalizePath } from 'zuby/utils/pathUtils.js';
@@ -12,6 +11,6 @@ export default () => ({
     layoutTemplateFile: normalizePath(resolve(__dirname, 'templates', 'layout.js')),
     innerLayoutTemplateFile: normalizePath(resolve(__dirname, 'templates', 'innerLayout.js')),
     errorTemplateFile: normalizePath(resolve(__dirname, 'templates', 'error.js')),
-    render,
+    renderFile: normalizePath(resolve(__dirname, 'render.js')),
     getPlugins: () => preact(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zubyjs/preact",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "Zuby.js JsxProvider for Preact",
   "type": "module",
   "main": "index.js",
@@ -8,6 +8,7 @@
     "release": "cd ./dist && npm publish --access public && cd ..",
     "bump-version": "npm version patch",
     "build": "rm -rf dist/ stage/ && mkdir dist && tsc && cp -rf package.json README.md stage/preact/src/* dist/ && rm -rf stage/",
+    "push-build": "npm run build && cd dist && yalc push --force && cd ..",
     "test": "exit 0"
   },
   "publishConfig": {

package/render.d.ts

@@ -1,13 +1,12 @@
-import { h } from 'preact';
-interface PrerenderOptions {
-    maxDepth?: number;
-    props?: object;
-}
+import { RenderToString, RenderToStream } from 'zuby/types.js';
 /**
  * @param {ReturnType<h>} vnode The root JSX element to render (eg: `<App />`)
  * @param {PrerenderOptions} [options]
  * @param {number} [options.maxDepth = 10] The maximum number of nested asynchronous operations to wait for before flushing
  * @param {object} [options.props] Additional props to merge into the root JSX element
  */
-export default function render(vnode: ReturnType<typeof h>, options?: PrerenderOptions): Promise<string>;
-export {};
+export declare const renderToString: RenderToString;
+/**
+ * @param {ReturnType<typeof h>} vnode The root JSX element to render (eg: `<App />`)
+ */
+export declare const renderToStream: RenderToStream;

package/render.js

@@ -1,5 +1,6 @@
 import { h, options, cloneElement } from 'preact';
-import { render as renderToString } from 'preact-render-to-string';
+import { render as preactRenderToString } from 'preact-render-to-string';
+import { Readable } from 'stream';
 let vnodeHook;
 const old = options.vnode;
 options.vnode = (vnode) => {
@@ -14,7 +15,7 @@ options.vnode = (vnode) => {
  * @param {number} [options.maxDepth = 10] The maximum number of nested asynchronous operations to wait for before flushing
  * @param {object} [options.props] Additional props to merge into the root JSX element
  */
-export default async function render(vnode, options) {
+export const renderToString = async (vnode, options) => {
     options = options || {};
     const maxDepth = options.maxDepth || 10;
     const props = options.props;
@@ -33,7 +34,7 @@ export default async function render(vnode, options) {
         }
         try {
             // @ts-ignore
-            return renderToString(vnode);
+            return preactRenderToString(vnode);
         }
         catch (e) {
             if (e instanceof Promise) {
@@ -44,4 +45,10 @@ export default async function render(vnode, options) {
         }
     };
     return await renderNode();
-}
+};
+/**
+ * @param {ReturnType<typeof h>} vnode The root JSX element to render (eg: `<App />`)
+ */
+export const renderToStream = async (vnode) => {
+    return Readable.from([await renderToString(vnode)]);
+};

package/router.d.ts

@@ -1,5 +1,9 @@
+export { useRoute, useRouter, useParams, useLocation, Link, LinkProps, Redirect, RedirectProps, } from 'wouter-preact';
 import { createElement } from 'preact';
+import { ZubyPageContext } from 'zuby/pageContext/index.js';
 /**
  * Zuby's Router component provides support for file-system based routing.
  */
-export default function Router(): createElement.JSX.Element;
+export default function Router({ context }: {
+    context: ZubyPageContext;
+}): createElement.JSX.Element;

package/router.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
 import { Router as WouterRouter, Route as WouterRoute, Switch as WouterSwitch, } from 'wouter-preact';
+export { useRoute, useRouter, useParams, useLocation, Link, Redirect, } from 'wouter-preact';
 import { Suspense, lazy } from 'preact/compat';
-import { getContext } from 'zuby/context/index.js';
 import { createElement } from 'preact';
 let pages;
 let apps;
@@ -9,29 +9,28 @@ let errors;
 /**
  * Zuby's Router component provides support for file-system based routing.
  */
-export default function Router() {
-    const zubyContext = getContext();
+export default function Router({ context }) {
     const loadTemplates = (templates) => templates?.map((pageTemplate) => ({
         ...pageTemplate,
         component: lazy(pageTemplate.component),
     })) || [];
     if (!pages) {
-        pages = loadTemplates(zubyContext.templates?.pages);
+        pages = loadTemplates(context.templates?.pages);
     }
     if (!apps) {
-        apps = loadTemplates(zubyContext.templates?.apps);
+        apps = loadTemplates(context.templates?.apps);
     }
     if (!errors) {
-        errors = loadTemplates(zubyContext.templates?.errors);
+        errors = loadTemplates(context.templates?.errors);
     }
     const app = apps.find(({ pathRegex }) => {
-        return pathRegex.test(zubyContext.currentPath ?? '');
+        return pathRegex.test(context.url.pathname ?? '');
     });
     const error = errors.find(({ pathRegex }) => {
-        return pathRegex.test(zubyContext.currentPath ?? '');
+        return pathRegex.test(context.url.pathname ?? '');
     });
-    const page = (_jsx(WouterSwitch, { children: pages.map((page) => (_jsx(WouterRoute, { path: page.path, component: page.component }))) }));
-    return (_jsx(WouterRouter, { ssrPath: zubyContext.currentPath, children: _jsx(Suspense, { fallback: _jsx("div", { children: "Loading..." }), children: createElement(app?.component, {
+    const page = (_jsx(WouterSwitch, { children: pages.map((page) => (_jsx(WouterRoute, { path: page.path, children: _jsx(page.component, { context: context }) }))) }));
+    return (_jsx(WouterRouter, { ssrPath: context.url.pathname, children: _jsx(Suspense, { fallback: _jsx("div", { children: "Loading..." }), children: createElement(app?.component, {
                 children: page,
             }) }) }));
 }

package/templates/entry.js

@@ -3,9 +3,11 @@ import { jsx as _jsx } from "preact/jsx-runtime";
 // @ts-nocheck
 import { render, hydrate } from 'preact';
 import Router from '@zubyjs/preact/router.js';
+import { ZubyPageContext } from 'zuby/pageContext/index.js';
 if (typeof window !== 'undefined') {
+    const pageContext = new ZubyPageContext();
     const appElement = document.getElementById('app');
     const renderMethod = appElement.hasChildNodes() ? hydrate : render;
-    renderMethod(_jsx(Router, {}), appElement);
+    renderMethod(_jsx(Router, { context: pageContext }), appElement);
 }
 export default Router;

package/templates/error.d.ts

@@ -1,4 +1,4 @@
 import { ComponentChildren } from 'preact';
-export default function App({ children }: {
+export default function Error({ children }: {
     children: ComponentChildren;
 }): import("preact").JSX.Element;

package/templates/error.js

@@ -1,4 +1,4 @@
 import { Fragment as _Fragment, jsx as _jsx } from "preact/jsx-runtime";
-export default function App({ children }) {
+export default function Error({ children }) {
     return _jsx(_Fragment, { children: children });
 }

package/templates/innerLayout.d.ts

@@ -1,4 +1,3 @@
-import { ComponentChildren } from 'preact';
-export default function InnerLayout({ children }: {
-    children: ComponentChildren;
+export default function InnerLayout({ innerHtml }: {
+    innerHtml: string;
 }): import("preact").JSX.Element;

package/templates/innerLayout.js

@@ -1,4 +1,4 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
-export default function InnerLayout({ children }) {
-    return _jsx("div", { id: "app", children: children });
+export default function InnerLayout({ innerHtml }) {
+    return _jsx("div", { id: "app", dangerouslySetInnerHTML: { __html: innerHtml } });
 }

package/templates/layout.d.ts

@@ -1,4 +1,6 @@
 import { ComponentChildren } from 'preact';
-export default function Layout({ children }: {
+import { ZubyPageContext } from 'zuby/pageContext/index.js';
+export default function Layout({ children, context, }: {
     children: ComponentChildren;
+    context: ZubyPageContext;
 }): import("preact").JSX.Element;

package/templates/layout.js

@@ -1,4 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
-export default function Layout({ children }) {
-    return (_jsxs("html", { children: [_jsxs("head", { children: [_jsx("meta", { charset: "UTF-8" }), _jsx("title", { children: "Something" })] }), _jsx("body", { children: children })] }));
+export default function Layout({ children, context, }) {
+    return (_jsxs("html", { children: [_jsxs("head", { children: [_jsx("meta", { charset: "UTF-8" }), _jsx("title", { children: context.title })] }), _jsx("body", { children: children })] }));
 }