dtwo 3.1.2 → 3.2.1

package/dist/app/dtwo.d.ts

@@ -1,9 +1,9 @@
 import type { App, onErrorCaptured, KNode, Ref } from 'kdu';
 import type { Hookable } from 'hookable';
-import type { RuntimeConfig, AppConfigInput } from '@dtwo/schema';
 import type { SSRContext } from 'kdu-bundle-renderer/runtime';
 import type { H3Event } from 'h3';
 import type { DtwoIslandContext } from '../core/runtime/hole/renderer';
+import type { RuntimeConfig, AppConfigInput } from 'dtwo/schema';
 type DtwoMeta = {
     htmlAttrs?: string;
     headAttrs?: string;
@@ -27,6 +27,9 @@ export interface RuntimeDtwoHooks {
     'app:error:cleared': (options: {
         redirect?: string;
     }) => HookResult;
+    'app:chunkError': (options: {
+        error: any;
+    }) => HookResult;
     'app:data:refresh': (keys?: string[]) => HookResult;
     'link:prefetch': (link: string) => HookResult;
     'page:start': (Component?: KNode) => HookResult;
@@ -72,7 +75,7 @@ interface _DtwoApp {
         rendered?: Function;
         error?: Error | {
             url: string;
-            statusCode: string;
+            statusCode: number;
             statusMessage: string;
             message: string;
             description: string;

package/dist/app/dtwo.mjs

@@ -65,6 +65,11 @@ export function createDtwoApp(options) {
       app: options.ssrContext.runtimeConfig.app
     };
   }
+  if (process.client) {
+    window.addEventListener("dtwo.preloadError", (event) => {
+      dtwoApp.callHook("app:chunkError", { error: event.payload });
+    });
+  }
   const runtimeConfig = process.server ? options.ssrContext.runtimeConfig : reactive(dtwoApp.payload.config);
   const compatibilityConfig = new Proxy(runtimeConfig, {
     get(target, prop) {

package/dist/app/entry-spa.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/dist/app/entry-spa.mjs

@@ -0,0 +1,2 @@
+export default () => {
+};

package/dist/app/entry.mjs

@@ -1,7 +1,7 @@
 import { createSSRApp, createApp, nextTick } from "kdu";
 import { $fetch } from "ofetch";
 import { baseURL } from "#build/paths.mjs";
-import { createDtwoApp, applyPlugins, normalizePlugins } from "#app";
+import { createDtwoApp, applyPlugins, normalizePlugins } from "#app/dtwo";
 import "#build/css";
 import _plugins from "#build/plugins";
 import RootComponent from "#build/root-component.mjs";

package/dist/app/index.d.ts

@@ -4,7 +4,5 @@ export * from './composables';
 export * from './components';
 export * from './config';
 export type { PageMeta } from '../pages/runtime';
-export type { MetaObject } from '../head/runtime';
-export { useHead } from '#head';
 export declare const isKdu2 = false;
 export declare const isKdu3 = true;

package/dist/app/index.mjs

@@ -2,6 +2,5 @@ export * from "./dtwo.mjs";
 export * from "./composables/index.mjs";
 export * from "./components/index.mjs";
 export * from "./config.mjs";
-export { useHead } from "#head";
 export const isKdu2 = false;
 export const isKdu3 = true;

package/dist/app/plugins/chunk-reload.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/app/plugins/chunk-reload.client.mjs

@@ -0,0 +1,26 @@
+import { defineDtwoPlugin } from "#app/dtwo";
+import { useRouter } from "#app/composables/router";
+export default defineDtwoPlugin((dtwoApp) => {
+  const router = useRouter();
+  const chunkErrors = /* @__PURE__ */ new Set();
+  router.beforeEach(() => {
+    chunkErrors.clear();
+  });
+  dtwoApp.hook("app:chunkError", ({ error }) => {
+    chunkErrors.add(error);
+  });
+  router.onError((error, to) => {
+    if (!chunkErrors.has(error)) {
+      return;
+    }
+    let handledPath = {};
+    try {
+      handledPath = JSON.parse(localStorage.getItem("dtwo:reload") || "{}");
+    } catch {
+    }
+    if (handledPath?.path !== to.fullPath || handledPath?.expires < Date.now()) {
+      localStorage.setItem("dtwo:reload", JSON.stringify({ path: to.fullPath, expires: Date.now() + 1e4 }));
+      window.location.href = to.fullPath;
+    }
+  });
+});

package/dist/app/plugins/cross-origin-prefetch.client.mjs

@@ -1,6 +1,7 @@
 import { ref } from "kdu";
 import { parseURL } from "ufo";
-import { defineDtwoPlugin, useHead } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
+import { useHead } from "#app/composables/head";
 export default defineDtwoPlugin((dtwoApp) => {
   const externalURLs = ref(/* @__PURE__ */ new Set());
   function generateRules() {

package/dist/app/plugins/debug.mjs

@@ -1,5 +1,5 @@
 import { createDebugger } from "hookable";
-import { defineDtwoPlugin } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
 export default defineDtwoPlugin((dtwoApp) => {
   createDebugger(dtwoApp.hooks, { tag: "dtwo-app" });
 });

package/dist/app/plugins/payload.client.mjs

@@ -1,5 +1,7 @@
 import { parseURL } from "ufo";
-import { defineDtwoPlugin, loadPayload, isPrerendered, useRouter } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
+import { loadPayload, isPrerendered } from "#app/composables/payload";
+import { useRouter } from "#app/composables/router";
 export default defineDtwoPlugin((dtwoApp) => {
   if (!isPrerendered()) {
     return;

package/dist/app/plugins/preload.server.mjs

@@ -1,4 +1,4 @@
-import { defineDtwoPlugin } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
 export default defineDtwoPlugin((dtwoApp) => {
   dtwoApp.kduApp.mixin({
     beforeCreate() {

package/dist/app/plugins/router.d.ts

@@ -46,7 +46,7 @@ interface Router {
     hasRoute: (name: string) => boolean;
     removeRoute: (name: string) => void;
 }
-declare const _default: import("..").Plugin<{
+declare const _default: import("../dtwo").Plugin<{
     route: Route;
     router: Router;
 }>;

package/dist/app/plugins/router.mjs

@@ -1,8 +1,11 @@
 import { reactive, h, isReadonly } from "kdu";
 import { parseURL, stringifyParsedURL, parseQuery, stringifyQuery, withoutBase, isEqual, joinURL } from "ufo";
 import { createError } from "h3";
-import { defineDtwoPlugin, clearError, navigateTo, showError, useRuntimeConfig, useState, useRequestEvent } from "../index.mjs";
-import { callWithDtwo } from "../dtwo.mjs";
+import { callWithDtwo, defineDtwoPlugin, useRuntimeConfig } from "../dtwo.mjs";
+import { clearError, showError } from "../composables/error.mjs";
+import { navigateTo } from "../composables/router.mjs";
+import { useState } from "../composables/state.mjs";
+import { useRequestEvent } from "../composables/ssr.mjs";
 import { globalMiddleware } from "#build/middleware";
 function getRouteFromPath(fullPath) {
   if (typeof fullPath === "object") {

package/dist/app/types/augments.d.ts

@@ -1,28 +1,28 @@
-import type { DtwoApp } from '../dtwo'
-
-declare global {
-  namespace NodeJS {
-    interface Process {
-      browser: boolean
-      client: boolean
-      dev: boolean
-      mode: 'spa' | 'universal'
-      server: boolean
-      static: boolean
-    }
-  }
-
-  interface Window {
-    __DTWO__?: Record<string, any>
-  }
-}
-
-declare module 'kdu' {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  interface App<HostElement> {
-    $dtwo: DtwoApp
-  }
-  interface ComponentInternalInstance {
-    _dtwoOnBeforeMountCbs: Function[]
-  }
-}
+import type { DtwoApp } from '../dtwo'
+
+declare global {
+  namespace NodeJS {
+    interface Process {
+      browser: boolean
+      client: boolean
+      dev: boolean
+      mode: 'spa' | 'universal'
+      server: boolean
+      static: boolean
+    }
+  }
+
+  interface Window {
+    __DTWO__?: Record<string, any>
+  }
+}
+
+declare module 'kdu' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface App<HostElement> {
+    $dtwo: DtwoApp
+  }
+  interface ComponentInternalInstance {
+    _dtwoOnBeforeMountCbs: Function[]
+  }
+}

package/dist/components/runtime/server-component.mjs

@@ -2,7 +2,10 @@ import { defineComponent, createStaticKNode, computed, h, watch } from "kdu";
 import { debounce } from "perfect-debounce";
 import { hash } from "ohash";
 import { appendHeader } from "h3";
-import { useAsyncData, useHead, useDtwoApp, useRequestEvent } from "#app";
+import { useDtwoApp } from "#app/dtwo";
+import { useRequestEvent } from "#app/composables/ssr";
+import { useAsyncData } from "#app/composables/asyncData";
+import { useHead } from "#app/composables/head";
 const pKey = "_islandPromises";
 export const createServerComponent = (name) => {
   return defineComponent({

package/dist/core/runtime/hole/renderer.mjs

@@ -4,8 +4,9 @@ import devalue from "@d2js/devalue";
 import destr from "destr";
 import { joinURL } from "ufo";
 import { renderToString as _renderToString } from "kdu/server-renderer";
-import { useRuntimeConfig, useHoleApp, defineRenderHandler, getRouteRules } from "#internal/hole";
+import { useRuntimeConfig, defineRenderHandler, getRouteRules } from "#internal/hole";
 import { hash } from "ohash";
+import { useHoleApp } from "#internal/hole/app";
 import { appRootId, appRootTag } from "#internal/dtwo.config.mjs";
 import { buildAssetsURL, publicAssetsURL } from "#paths";
 globalThis.__buildAssetsURL = buildAssetsURL;
@@ -31,7 +32,7 @@ const getSSRRenderer = lazyCachedFunction(async () => {
   const renderer = createRenderer(createSSRApp, options);
   async function renderToString(input, context) {
     const html = await _renderToString(input, context);
-    if (process.dev && process.env.DTWO_WITE_NODE_OPTIONS) {
+    if (process.dev && process.env.DTWO_LAHM_NODE_OPTIONS) {
       renderer.rendererContext.updateManifest(await getClientManifest());
     }
     return `<${appRootTag} id="${appRootId}">${html}</${appRootTag}>`;
@@ -86,6 +87,9 @@ const PRERENDER_NO_SSR_ROUTES = /* @__PURE__ */ new Set(["/index.html", "/200.ht
 export default defineRenderHandler(async (event) => {
   const holeApp = useHoleApp();
   const ssrError = event.node.req.url?.startsWith("/__dtwo_error") ? getQuery(event) : null;
+  if (ssrError && ssrError.statusCode) {
+    ssrError.statusCode = parseInt(ssrError.statusCode);
+  }
   if (ssrError && event.node.req.socket.readyState !== "readOnly") {
     throw createError("Cannot directly render error page!");
   }

package/dist/head/runtime/composables.d.ts

@@ -1,6 +1,6 @@
 import type { HeadEntryOptions, UseHeadInput, ActiveHeadEntry } from '@kduse/head';
-import type { HeadAugmentations } from '@dtwo/schema';
 import { useSeoMeta as _useSeoMeta } from '@kduse/head';
+import type { HeadAugmentations } from 'dtwo/schema';
 /**
  * You can pass in a meta object, which has keys corresponding to meta tags:
  * `title`, `base`, `script`, `style`, `meta` and `link`, as well as `htmlAttrs` and `bodyAttrs`.

package/dist/head/runtime/composables.mjs

@@ -1,5 +1,5 @@
 import { useSeoMeta as _useSeoMeta } from "@kduse/head";
-import { useDtwoApp } from "#app";
+import { useDtwoApp } from "#app/dtwo";
 export function useHead(input, options) {
   return useDtwoApp()._useHead(input, options);
 }

package/dist/head/runtime/index.d.ts

@@ -1,4 +1,4 @@
 import type { UseHeadInput } from '@kduse/head';
-import type { HeadAugmentations } from '@dtwo/schema';
+import type { HeadAugmentations } from 'dtwo/schema';
 export * from './composables';
 export type MetaObject = UseHeadInput<HeadAugmentations>;

package/dist/head/runtime/lib/kduse-head.plugin.mjs

@@ -1,6 +1,6 @@
 import { createHead, useHead } from "@kduse/head";
 import { renderSSRHead } from "@kdhead/ssr";
-import { defineDtwoPlugin } from "#app";
+import { defineDtwoPlugin } from "#app/dtwo";
 import { appHead } from "#build/dtwo.config.mjs";
 export default defineDtwoPlugin((dtwoApp) => {
   const head = createHead();

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { DtwoOptions, Dtwo } from '@dtwo/schema';
 import { LoadDtwoOptions } from '@dtwo/kit';
+import { DtwoOptions, Dtwo } from 'dtwo/schema';
 
 declare function createDtwo(options: DtwoOptions): Dtwo;
 declare function loadDtwo(opts: LoadDtwoOptions): Promise<Dtwo>;