zuby 1.0.13 → 1.0.14

package/components/Router/index.js

@@ -1,6 +1,8 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
-import { Router as WouterRouter, Route as WouterRoute, } from "wouter-preact";
+import { Router as WouterRouter, Route as WouterRoute, Switch as WouterSwitch, } from 'wouter-preact';
 import { Suspense, lazy } from 'preact/compat';
+import { getContext } from '../../context/index.js';
+let pages = undefined;
 /**
  * Zuby's Router component provides support for file-system based routing.
  */
@@ -9,13 +11,12 @@ export default function Router({ children, headerComponent, footerComponent, loa
     headerComponent = headerComponent || (_jsx(_Fragment, {}));
     footerComponent = footerComponent || (_jsx(_Fragment, {}));
     loaderComponent = loaderComponent || (_jsx(_Fragment, { children: "Loading..." }));
-    const Zuby = globalThis?.Zuby || {};
-    const currentPath = Zuby?.currentPath;
-    // Retrieve the pages generated during the build process.
-    const pages = (Zuby?.pages || [])
-        .map((page) => ({
-        ...page,
-        component: lazy(page.component),
-    }));
-    return (_jsx("div", { children: _jsxs(WouterRouter, { ssrPath: currentPath, children: [headerComponent, children, _jsx(Suspense, { fallback: loaderComponent, children: pages.map((page) => (_jsx(WouterRoute, { path: page.path, component: page.component }))) }), footerComponent] }) }));
+    const zubyContext = getContext();
+    if (!pages) {
+        pages = zubyContext.pages?.map((page) => ({
+            ...page,
+            component: lazy(page.component),
+        })) || [];
+    }
+    return (_jsxs(WouterRouter, { ssrPath: zubyContext.currentPath, children: [headerComponent, children, _jsx(Suspense, { fallback: loaderComponent, children: _jsx(WouterSwitch, { children: pages.map((page) => (_jsx(WouterRoute, { path: page.path, component: page.component }))) }) }), footerComponent] }));
 }

package/config.d.ts

@@ -1,5 +1,22 @@
 import { ZubyConfig } from './types.js';
 import { UserConfig as ViteUserConfig } from 'vite';
+/**
+ * This function loads the config file and returns the config object with default values.
+ * It also caches the config object for future use.
+ * @param configFile
+ */
 export declare const getZubyConfig: (configFile?: string, cache?: boolean) => Promise<ZubyConfig>;
+/**
+ * Adds default values to the config object.
+ * @param config
+ */
+export declare const mergeDefaultConfig: (config?: ZubyConfig) => Promise<ZubyConfig>;
+/**
+ * This function returns the array of built-in Zuby plugins.
+ * Check which framework components are relying on each plugin
+ * before removing any of them.
+ * @param config
+ */
+export declare const getBuiltInPlugins: (config: ZubyConfig) => import("vite").PluginOption[];
 export declare const getViteConfig: (config: ZubyConfig) => ViteUserConfig;
 export declare const getZubyPackageJson: (cache?: boolean) => any;

package/config.js

@@ -3,9 +3,20 @@ import { fileURLToPath } from 'url';
 import { existsSync, readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
 import { bundleRequire } from 'bundle-require';
-import { getPages } from './pages.js';
+import { getPages } from './pages/index.js';
+import { createLogger } from './logger.js';
+import { preact as preactPlugin } from '@preact/preset-vite';
+import contextPlugin from './plugins/contextPlugin/index.js';
+import compileTimePlugin from './plugins/compileTimePlugin/index.js';
+import chunkNamingPlugin from './plugins/chunkNamingPlugin/index.js';
+import prerenderPlugin from './plugins/prerenderPlugin/index.js';
 let zubyConfig;
 let packageJson;
+/**
+ * This function loads the config file and returns the config object with default values.
+ * It also caches the config object for future use.
+ * @param configFile
+ */
 export const getZubyConfig = async (configFile = ZUBY_CONFIG_FILE, cache = true) => {
     // Return the cached config if it exists
     if (cache && zubyConfig)
@@ -30,9 +41,62 @@ export const getZubyConfig = async (configFile = ZUBY_CONFIG_FILE, cache = true)
     if (!zubyConfig) {
         throw new Error(`No valid default export found in config file: ${foundConfigFile}`);
     }
-    zubyConfig.pages = await getPages();
+    zubyConfig = await mergeDefaultConfig(zubyConfig);
     return zubyConfig;
 };
+/**
+ * Adds default values to the config object.
+ * @param config
+ */
+export const mergeDefaultConfig = async (config = {}) => {
+    // Set default values
+    config.srcDir = config.srcDir ?? './';
+    config.publicDir = config.publicDir ?? 'public';
+    config.outDir = config.outDir ?? 'build';
+    config.output = config.output ?? 'static';
+    config.prerenderPaths = config.prerenderPaths ?? [];
+    config.pageExtensions = config.pageExtensions ?? ['tsx', 'jsx', 'ts', 'js', 'mjs'];
+    // Add minification
+    config.minifyCSS = config.minifyCSS ?? true;
+    config.minifyHTML = config.minifyHTML ?? true;
+    config.minifyJS = config.minifyJS ?? true;
+    // Add logger
+    config.customLogger =
+        config.customLogger ??
+            createLogger(config.logLevel, {
+                allowClearScreen: false,
+                prefix: '[Zuby]',
+            });
+    config.logLevel = config.logLevel ?? 'info';
+    // Transform to vite config
+    config.vite = config.vite ?? {};
+    config.vite.build = config.vite?.build ?? {};
+    config.vite.build.cssMinify = config.vite.build.cssMinify ?? config.minifyCSS;
+    config.vite.build.minify = config.vite.build.minify ?? config.minifyJS;
+    // Merge built-in plugins with user plugins
+    config.vite.plugins = [
+        ...getBuiltInPlugins(config),
+        ...(config.vite?.plugins ?? []),
+    ];
+    // Load pages
+    config.pages = await getPages();
+    return config;
+};
+/**
+ * This function returns the array of built-in Zuby plugins.
+ * Check which framework components are relying on each plugin
+ * before removing any of them.
+ * @param config
+ */
+export const getBuiltInPlugins = (config) => {
+    return [
+        preactPlugin(),
+        contextPlugin(),
+        compileTimePlugin(),
+        chunkNamingPlugin(),
+        prerenderPlugin(),
+    ];
+};
 export const getViteConfig = (config) => {
     // Generates valid vite build config from the zuby config
     return {

package/context/index.d.ts

@@ -0,0 +1,12 @@
+import { ZubyRawContext } from './types.js';
+declare class ZubyContext {
+    readonly rawContext: ZubyRawContext;
+    constructor(rawContext: ZubyRawContext);
+    get title(): string | undefined;
+    set title(title: string | undefined);
+    get currentPath(): string | undefined;
+    get pages(): import("../pages/types.js").Page[] | undefined;
+    update: (newContext: ZubyRawContext) => this;
+}
+export declare const getContext: () => ZubyContext;
+export {};

package/context/index.js

@@ -0,0 +1,37 @@
+class ZubyContext {
+    constructor(rawContext) {
+        this.update = (newContext) => {
+            Object.assign(this.rawContext, newContext);
+            return this;
+        };
+        this.rawContext = rawContext;
+    }
+    get title() {
+        if (typeof document !== 'undefined' && document.title) {
+            this.rawContext.title = document.title;
+            return document.title;
+        }
+        return this.rawContext.title;
+    }
+    set title(title) {
+        if (typeof document !== 'undefined' && document.title) {
+            this.rawContext.title = document.title = title || '';
+        }
+        this.rawContext.title = title;
+    }
+    get currentPath() {
+        return this.rawContext.currentPath;
+    }
+    get pages() {
+        return this.rawContext.pages;
+    }
+}
+const getRawContext = () => {
+    return globalThis.ZubyRawContext;
+};
+export const getContext = () => {
+    if (!getRawContext()) {
+        globalThis.ZubyRawContext = {};
+    }
+    return new ZubyContext(getRawContext());
+};

package/context/types.d.ts

@@ -0,0 +1,15 @@
+import { Page } from '../pages/types.js';
+export interface ZubyRawContext {
+    /**
+     * The array with pages.
+     */
+    pages?: Page[];
+    /**
+     * The current path of the page in both client and server env.
+     */
+    currentPath?: string;
+    /**
+     * The current title of the page in both client and server env.
+     */
+    title?: string;
+}

package/context/types.js

@@ -0,0 +1 @@
+export {};

package/defineConfig.d.ts

@@ -1,14 +1,13 @@
 import { ZubyConfig } from './types.js';
 /**
- * This function returns a ZubyConfig object with default values.
- * ZubyConfig is framework-specific config, which includes valid vite config.
+ * This helper function is used to define the Zuby config in zuby.config.mjs.
+ *
+ * It is not required, but it provides type safety and autocompletion in your IDE.
+ * See the full Zuby Configuration API Documentation
  * @param config
+ * @example defineConfig({
+ *   outDir: 'build',
+ *   srcDir: './',
+ * })
  */
 export declare const defineConfig: (config: ZubyConfig) => ZubyConfig;
-/**
- * This function adds all built-in Zuby plugins to the config.
- * Check which framework components are relying on each plugin
- * before removing any of them.
- * @param config
- */
-export declare const getBuiltInPlugins: (config: ZubyConfig) => import("vite").PluginOption[];

package/defineConfig.js

@@ -1,58 +1,14 @@
-import { createLogger } from './logger.js';
-import { preact as preactPlugin } from '@preact/preset-vite';
-import zubyGlobalPlugin from './plugins/zubyGlobalPlugin/index.js';
-import compileTimePlugin from './plugins/compileTimePlugin/index.js';
-import chunkNamingPlugin from './plugins/chunkNamingPlugin/index.js';
-import prerenderPlugin from './plugins/prerenderPlugin/index.js';
 /**
- * This function returns a ZubyConfig object with default values.
- * ZubyConfig is framework-specific config, which includes valid vite config.
+ * This helper function is used to define the Zuby config in zuby.config.mjs.
+ *
+ * It is not required, but it provides type safety and autocompletion in your IDE.
+ * See the full Zuby Configuration API Documentation
  * @param config
+ * @example defineConfig({
+ *   outDir: 'build',
+ *   srcDir: './',
+ * })
  */
 export const defineConfig = (config) => {
-    // Default values
-    config.srcDir = config.srcDir ?? './';
-    config.publicDir = config.publicDir ?? 'public';
-    config.outDir = config.outDir ?? 'build';
-    config.output = config.output ?? 'static';
-    config.prerenderPaths = config.prerenderPaths ?? [];
-    config.pageExtensions = config.pageExtensions ?? ['tsx', 'jsx', 'ts', 'js', 'mjs'];
-    // Add minification
-    config.minifyCSS = config.minifyCSS ?? true;
-    config.minifyHTML = config.minifyHTML ?? true;
-    config.minifyJS = config.minifyJS ?? true;
-    // Add logger
-    config.customLogger =
-        config.customLogger ??
-            createLogger(config.logLevel, {
-                allowClearScreen: false,
-                prefix: '[Zuby]',
-            });
-    config.logLevel = config.logLevel ?? 'info';
-    // Transform to vite config
-    config.vite = config.vite ?? {};
-    config.vite.build = config.vite?.build ?? {};
-    config.vite.build.cssMinify = config.vite.build.cssMinify ?? config.minifyCSS;
-    config.vite.build.minify = config.vite.build.minify ?? config.minifyJS;
-    // Merge built-in plugins with user plugins
-    config.vite.plugins = [
-        ...getBuiltInPlugins(config),
-        ...(config.vite?.plugins ?? []),
-    ];
     return config;
 };
-/**
- * This function adds all built-in Zuby plugins to the config.
- * Check which framework components are relying on each plugin
- * before removing any of them.
- * @param config
- */
-export const getBuiltInPlugins = (config) => {
-    return [
-        preactPlugin(),
-        zubyGlobalPlugin(),
-        compileTimePlugin(),
-        chunkNamingPlugin(),
-        prerenderPlugin(),
-    ];
-};

package/hooks/useZuby.d.ts

@@ -0,0 +1,7 @@
+export declare const useZuby: () => {
+    readonly rawContext: import("../context/types.js").ZubyRawContext;
+    title: string | undefined;
+    readonly currentPath: string | undefined;
+    readonly pages: import("../pages/types.js").Page[] | undefined;
+    update: (newContext: import("../context/types.js").ZubyRawContext) => any;
+};

package/hooks/useZuby.js

@@ -0,0 +1,4 @@
+import { getContext } from '../context/index.js';
+export const useZuby = () => {
+    return getContext();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuby",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "Zuby.js is Preact Framework for building SPA apps using Vite",
   "type": "module",
   "main": "index.js",
@@ -21,7 +21,6 @@
     "es-module-lexer": "^1.3.1",
     "html-minifier": "^4.0.0",
     "magic-string": "^0.30.5",
-    "preact-iso": "^2.3.2",
     "preact-render-to-string": "^6.2.2",
     "preact-ssr-prepass": "^1.2.0",
     "rea": "^0.0.1",

package/{pages.d.ts → pages/index.d.ts}

@@ -2,11 +2,11 @@ import { Page } from './types.js';
 /**
  * Returns the array of pages with static path.
  */
-export declare function getStaticPages(): Promise<Page[]>;
+export declare function getStaticPages(pages?: Page[]): Promise<Page[]>;
 /**
  * Returns the array of pages with dynamic path.
  */
-export declare function getDynamicPages(): Promise<Page[]>;
+export declare function getDynamicPages(pages?: Page[]): Promise<Page[]>;
 /**
  * Returns the array of all pages
  * The pages are already sorted from the least dynamic path to the most dynamic.
@@ -32,3 +32,10 @@ export declare function sortPages(pages: Page[]): Page[];
  * @example /products/[id].tsx -> /products/:id
  */
 export declare function toPath(filename: string): string;
+/**
+ * Returns the matching page for the given path.
+ */
+export declare function findMatchingPage(pages: Page[], path: string): {
+    page: Page;
+    params: Record<string, string>;
+} | undefined;

package/{pages.js → pages/index.js}

@@ -1,20 +1,21 @@
 import { PATH_TYPES } from './types.js';
-import { getZubyConfig } from './config.js';
+import { getZubyConfig } from '../config.js';
 import { join, resolve } from 'path';
 import { glob } from 'glob';
-import { normalizePath } from './utils/pathUtils.js';
+import { normalizePath } from '../utils/pathUtils.js';
+import { pathToRegexp } from './pathUtils.js';
 /**
  * Returns the array of pages with static path.
  */
-export async function getStaticPages() {
-    const pages = await getPages();
+export async function getStaticPages(pages) {
+    pages = pages || await getPages();
     return pages.filter(page => page.pathType === PATH_TYPES.static);
 }
 /**
  * Returns the array of pages with dynamic path.
  */
-export async function getDynamicPages() {
-    const pages = await getPages();
+export async function getDynamicPages(pages) {
+    pages = pages || await getPages();
     return pages.filter(page => page.pathType === PATH_TYPES.dynamic);
 }
 /**
@@ -49,7 +50,11 @@ export async function getPages() {
             ...page,
             path: `/${locale}${page.path}`.replace(/(.+)\/+$/, '$1')
         }))
-    ]);
+    ])
+        .map(page => ({
+        ...page,
+        ...pathToRegexp(page.path)
+    }));
     return sortPages(pages);
 }
 /**
@@ -110,3 +115,22 @@ export function toPath(filename) {
         // Param syntax
         .replace(/\[(\w+)]/, ':$1');
 }
+/**
+ * Returns the matching page for the given path.
+ */
+export function findMatchingPage(pages, path) {
+    for (const page of pages) {
+        const match = page.pathRegex.exec(path);
+        if (!match)
+            continue;
+        const matchedParams = page.pathParams.reduce((params, key, i) => {
+            params[key] = match[i + 1];
+            return params;
+        }, {});
+        return {
+            page,
+            params: matchedParams
+        };
+    }
+    return undefined;
+}

package/pages/pathUtils.d.ts

@@ -0,0 +1,4 @@
+export declare const pathToRegexp: (pathPattern: string) => {
+    pathParams: string[];
+    pathRegex: RegExp;
+};

package/pages/pathUtils.js

@@ -0,0 +1,34 @@
+export const pathToRegexp = (pathPattern) => {
+    const groupRx = /:([A-Za-z0-9_]+)([?+*]?)/g;
+    let match = null, lastIndex = 0, keys = [], result = "";
+    while ((match = groupRx.exec(pathPattern)) !== null) {
+        const [_, segment, mod] = match;
+        // :foo  [1]      (  )
+        // :foo? [0 - 1]  ( o)
+        // :foo+ [1 - ∞]  (r )
+        // :foo* [0 - ∞]  (ro)
+        const repeat = mod === "+" || mod === "*";
+        const optional = mod === "?" || mod === "*";
+        const prefix = optional && pathPattern[match.index - 1] === "/" ? 1 : 0;
+        const prev = pathPattern.substring(lastIndex, match.index - prefix);
+        keys.push(segment);
+        lastIndex = groupRx.lastIndex;
+        result += escapeRx(prev) + rxForSegment(repeat, optional, prefix);
+    }
+    result += escapeRx(pathPattern.substring(lastIndex));
+    return {
+        pathParams: keys,
+        pathRegex: new RegExp("^" + result + "(?:\\/)?$", "i")
+    };
+};
+// escapes a regexp string (borrowed from path-to-regexp sources)
+// https://github.com/pillarjs/path-to-regexp/blob/v3.0.0/index.js#L202
+const escapeRx = (str) => str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+// returns a segment representation in RegExp based on flags
+// adapted and simplified version from path-to-regexp sources
+const rxForSegment = (repeat, optional, prefix) => {
+    let capture = repeat ? "((?:[^\\/]+?)(?:\\/(?:[^\\/]+?))*)" : "([^\\/]+?)";
+    if (optional && prefix)
+        capture = "(?:\\/" + capture + ")";
+    return capture + (optional ? "?" : "");
+};

package/pages/types.d.ts

@@ -0,0 +1,13 @@
+export declare const PATH_TYPES: {
+    static: string;
+    dynamic: string;
+};
+export type PathType = (typeof PATH_TYPES)[keyof typeof PATH_TYPES];
+export interface Page {
+    path: string;
+    pathRegex: RegExp;
+    pathParams: string[];
+    pathType: PathType;
+    filename: string;
+    weight: number;
+}

package/pages/types.js

@@ -0,0 +1,5 @@
+// Pages
+export const PATH_TYPES = {
+    static: 'static',
+    dynamic: 'dynamic',
+};

package/plugins/{zubyGlobalPlugin → contextPlugin}/index.d.ts

@@ -1,4 +1,4 @@
 import type { PluginOption } from 'vite';
 export default function index(): PluginOption;
-export declare function generateGlobalCode(): Promise<string>;
+export declare function generateCompileTimeContextCode(): Promise<string>;
 export declare function generatePagesCode(): Promise<string>;

package/plugins/{zubyGlobalPlugin → contextPlugin}/index.js

@@ -1,22 +1,21 @@
 import { getZubyConfig } from '../../config.js';
 export default function index() {
     return {
-        name: "zuby-global",
+        name: "compile-time-context",
         enforce: 'pre',
         async transform(code, id) {
             if ((id.includes("node_modules") && !id.includes("zuby")) ||
-                !/\.(js|ts|jsx|tsx|mjs|cjs)(\?.+)?$/.test(id) ||
-                !id.includes("app")) {
+                !/\.(js|ts|jsx|tsx|mjs|cjs)(\?.+)?$/.test(id)) {
                 return;
             }
-            const newCode = await generateGlobalCode();
-            return newCode + code;
+            const contextCode = await generateCompileTimeContextCode();
+            return contextCode + code;
         }
     };
 }
-export async function generateGlobalCode() {
-    return `globalThis.Zuby = {
-        ...(globalThis.Zuby || {}),
+export async function generateCompileTimeContextCode() {
+    return `globalThis.ZubyRawContext = {
+        ...(globalThis.ZubyRawContext || {}),
         pages: ${await generatePagesCode()},
     };`;
 }

package/plugins/prerenderPlugin/index.js

@@ -1,9 +1,10 @@
 import { createServer } from 'vite';
-import { getStaticPages } from '../../pages.js';
+import { findMatchingPage, getStaticPages } from '../../pages/index.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
-import { prerender } from './prerender.js';
 import { getZubyConfig } from '../../config.js';
+import { getContext } from '../../context/index.js';
+import { prerender } from './prerender.js';
 /**
  * This is internal plugin
  * that pre-renders the pages during the build.
@@ -17,7 +18,8 @@ export default function prerenderPlugin() {
             const zubyConfig = await getZubyConfig();
             const srcDir = zubyConfig.srcDir || '';
             const outDir = zubyConfig.outDir || '';
-            const staticPages = await getStaticPages();
+            const pages = zubyConfig.pages || [];
+            const staticPages = await getStaticPages(pages);
             const prerenderPaths = [
                 ...(zubyConfig.prerenderPaths || []),
                 ...staticPages.map(page => page.path)
@@ -28,22 +30,29 @@ export default function prerenderPlugin() {
                     ...(zubyConfig.vite?.server || {}),
                     middlewareMode: true
                 },
+                optimizeDeps: {
+                    include: ["zuby"]
+                }
             });
             await viteServer.close();
-            const appPath = resolve(srcDir, 'src', 'app.tsx');
+            const appPath = resolve(srcDir, 'src', 'main.tsx');
             const templatePath = resolve(outDir, 'index.html');
             const template = readFileSync(templatePath, 'utf-8');
+            const appModule = await viteServer.ssrLoadModule(appPath);
+            const app = appModule.default || appModule;
             for (const path of prerenderPaths) {
-                const Zuby = globalThis.Zuby || {};
-                Zuby.currentPath = path;
-                globalThis.Zuby = Zuby;
-                const appModule = await viteServer.ssrLoadModule(appPath);
-                const app = appModule.default || appModule;
+                const page = findMatchingPage(pages, path);
+                const zubyContext = getContext().update({
+                    currentPath: path,
+                    title: undefined
+                });
                 const { html } = await prerender(app(), {
-                    maxDepth: 100
+                    maxDepth: 50,
                 });
-                //console.log("renderedPage", renderedPage)
-                const renderedPageHtml = template.replace(/(<div id="app">)(<\/div>)/, `$1${html ?? ''}$2`);
+                const { title } = zubyContext;
+                const renderedPageHtml = template
+                    .replace(/(<div id="app">)(<\/div>)/, `$1${html ?? ''}$2`)
+                    .replace(/(<title>)(<\/title>)/, `$1${title ?? ''}$2`);
                 const target = join(outDir, path, "index.html");
                 const directory = dirname(target);
                 if (!existsSync(directory)) {

package/plugins/prerenderPlugin/prerender.d.ts

@@ -10,6 +10,6 @@ interface PrerenderOptions {
  * @param {object} [options.props] Additional props to merge into the root JSX element
  */
 export declare function prerender(vnode: ReturnType<typeof h>, options?: PrerenderOptions): Promise<{
-    html: any;
+    html: string;
 }>;
 export {};

package/plugins/prerenderPlugin/prerender.js

@@ -20,32 +20,29 @@ export async function prerender(vnode, options) {
     const props = options.props;
     let tries = 0;
     if (typeof vnode === 'function') {
-        // @ts-ignore
         vnode = h(vnode, props);
     }
     else if (props) {
         vnode = cloneElement(vnode, props);
     }
-    const render = () => {
-        if (++tries > maxDepth)
-            return;
+    const render = async () => {
+        if (++tries > maxDepth) {
+            console.warn(`WARNING: Maximum depth of ${maxDepth} of lazy components exceeded while prerendering page.`);
+            console.warn(`This may indicate a circular dependency in your code.`);
+            return '';
+        }
         try {
             // @ts-ignore
             return renderToString(vnode);
         }
         catch (e) {
-            // @ts-ignore
-            if (e && e.then)
-                return e.then(render);
+            if (e instanceof Promise) {
+                await e;
+                return render();
+            }
             throw e;
         }
     };
-    try {
-        let html = await render();
-        return { html };
-    }
-    finally {
-        // @ts-ignore
-        vnodeHook = null;
-    }
+    let html = await render();
+    return { html };
 }

package/types.d.ts

@@ -1,17 +1,6 @@
 import { UserConfig as ViteUserConfig } from 'vite';
 import type { Plugin as VitePlugin } from "vite";
-export interface ZubyGlobalContext {
-    /**
-     * The array with pages.
-     * @private
-     */
-    pages?: Page[];
-    /**
-     * The current path of the page in both client and server env.
-     * @private
-     */
-    currentPath?: string;
-}
+import { Page } from './pages/types.js';
 export interface ZubyConfig {
     /**
      * The relative path to directory were your zuby project is located in.
@@ -123,17 +112,6 @@ export declare const MODES: {
     production: string;
 };
 export type Mode = (typeof MODES)[keyof typeof MODES];
-export declare const PATH_TYPES: {
-    static: string;
-    dynamic: string;
-};
-export type PathType = (typeof PATH_TYPES)[keyof typeof PATH_TYPES];
-export interface Page {
-    path: string;
-    pathType: PathType;
-    filename: string;
-    weight: number;
-}
 export interface ZubyPlugin extends VitePlugin {
 }
 export type LogType = 'error' | 'warn' | 'info';

package/types.js

@@ -3,11 +3,6 @@ export const MODES = {
     development: 'development',
     production: 'production',
 };
-// Pages
-export const PATH_TYPES = {
-    static: 'static',
-    dynamic: 'dynamic',
-};
 export const LogLevels = {
     silent: 0,
     error: 1,

package/components/Hello/index.d.ts

@@ -1 +0,0 @@
-export default function Hello(): import("preact").JSX.Element;

package/components/Hello/index.js

@@ -1,6 +0,0 @@
-import { jsx as _jsx } from "preact/jsx-runtime";
-import { useState as Us2 } from 'preact/hooks';
-export default function Hello() {
-    const [count, setCount] = Us2(0);
-    return (_jsx("h1", { children: "Hello, world!" }));
-}

package/hooks/useTitle.d.ts

@@ -1 +0,0 @@
-export default function useTitle(): (string | ((title: string) => void) | undefined)[];

package/hooks/useTitle.js

@@ -1,19 +0,0 @@
-import { PAGE_TITLE_ENV_VAR } from "../constants.js";
-export default function useTitle() {
-    const getTitle = () => {
-        if (typeof document !== 'undefined' && document.title) {
-            return document.title;
-        }
-        return process?.env[PAGE_TITLE_ENV_VAR];
-    };
-    const setTitle = (title) => {
-        if (typeof document !== 'undefined' && document.title) {
-            document.title = title;
-        }
-        process.env[PAGE_TITLE_ENV_VAR] = title;
-    };
-    return [
-        getTitle(),
-        setTitle
-    ];
-}