dtwo 2.17.0 → 3.0.0-rc.14

package/dist/app/composables/fetch.mjs

@@ -0,0 +1,66 @@
+import { computed, unref, reactive } from "kdu";
+import { hash } from "ohash";
+import { useAsyncData } from "./asyncData.mjs";
+export function useFetch(request, arg1, arg2) {
+  const [opts = {}, autoKey] = typeof arg1 === "string" ? [{}, arg1] : [arg1, arg2];
+  const _key = opts.key || hash([autoKey, unref(opts.baseURL), typeof request === "string" ? request : "", unref(opts.params)]);
+  if (!_key || typeof _key !== "string") {
+    throw new TypeError("[dtwo] [useFetch] key must be a string: " + _key);
+  }
+  if (!request) {
+    throw new Error("[dtwo] [useFetch] request is missing.");
+  }
+  const key = _key === autoKey ? "$f" + _key : _key;
+  const _request = computed(() => {
+    let r = request;
+    if (typeof r === "function") {
+      r = r();
+    }
+    return unref(r);
+  });
+  const {
+    server,
+    lazy,
+    default: defaultFn,
+    transform,
+    pick,
+    watch,
+    immediate,
+    ...fetchOptions
+  } = opts;
+  const _fetchOptions = reactive({
+    ...fetchOptions,
+    cache: typeof opts.cache === "boolean" ? void 0 : opts.cache
+  });
+  const _asyncDataOptions = {
+    server,
+    lazy,
+    default: defaultFn,
+    transform,
+    pick,
+    immediate,
+    watch: [
+      _fetchOptions,
+      _request,
+      ...watch || []
+    ]
+  };
+  let controller;
+  const asyncData = useAsyncData(key, () => {
+    controller?.abort?.();
+    controller = typeof AbortController !== "undefined" ? new AbortController() : {};
+    return $fetch(_request.value, { signal: controller.signal, ..._fetchOptions });
+  }, _asyncDataOptions);
+  return asyncData;
+}
+export function useLazyFetch(request, arg1, arg2) {
+  const [opts, autoKey] = typeof arg1 === "string" ? [{}, arg1] : [arg1, arg2];
+  return useFetch(
+    request,
+    {
+      ...opts,
+      lazy: true
+    },
+    autoKey
+  );
+}

package/dist/app/composables/hydrate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Allows full control of the hydration cycle to set and receive data from the server.
+ *
+ * @param key a unique key to identify the data in the Dtwo payload
+ * @param get a function that returns the value to set the initial data
+ * @param set a function that will receive the data on the client-side
+ */
+export declare const useHydration: <T>(key: string, get: () => T, set: (value: T) => void) => void;

package/dist/app/composables/hydrate.mjs

@@ -0,0 +1,14 @@
+import { useDtwoApp } from "../dtwo.mjs";
+export const useHydration = (key, get, set) => {
+  const dtwo = useDtwoApp();
+  if (process.server) {
+    dtwo.hooks.hook("app:rendered", () => {
+      dtwo.payload[key] = get();
+    });
+  }
+  if (process.client) {
+    dtwo.hooks.hook("app:created", () => {
+      set(dtwo.payload[key]);
+    });
+  }
+};

package/dist/app/composables/index.d.ts

@@ -0,0 +1,16 @@
+export { defineDtwoComponent } from './component';
+export { useAsyncData, useLazyAsyncData, refreshDtwoData, clearDtwoData } from './asyncData';
+export type { AsyncDataOptions, AsyncData } from './asyncData';
+export { useHydration } from './hydrate';
+export { useState } from './state';
+export { clearError, createError, isDtwoError, showError, useError } from './error';
+export type { DtwoError } from './error';
+export { useFetch, useLazyFetch } from './fetch';
+export type { FetchResult, UseFetchOptions } from './fetch';
+export { useCookie } from './cookie';
+export type { CookieOptions, CookieRef } from './cookie';
+export { useRequestHeaders, useRequestEvent, setResponseStatus } from './ssr';
+export { abortNavigation, addRouteMiddleware, defineDtwoRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter } from './router';
+export type { AddRouteMiddlewareOptions, RouteMiddleware } from './router';
+export { preloadComponents, prefetchComponents, preloadRouteComponents } from './preload';
+export { isPrerendered, loadPayload, preloadPayload } from './payload';

package/dist/app/composables/index.mjs

@@ -0,0 +1,11 @@
+export { defineDtwoComponent } from "./component.mjs";
+export { useAsyncData, useLazyAsyncData, refreshDtwoData, clearDtwoData } from "./asyncData.mjs";
+export { useHydration } from "./hydrate.mjs";
+export { useState } from "./state.mjs";
+export { clearError, createError, isDtwoError, showError, useError } from "./error.mjs";
+export { useFetch, useLazyFetch } from "./fetch.mjs";
+export { useCookie } from "./cookie.mjs";
+export { useRequestHeaders, useRequestEvent, setResponseStatus } from "./ssr.mjs";
+export { abortNavigation, addRouteMiddleware, defineDtwoRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter } from "./router.mjs";
+export { preloadComponents, prefetchComponents, preloadRouteComponents } from "./preload.mjs";
+export { isPrerendered, loadPayload, preloadPayload } from "./payload.mjs";

package/dist/app/composables/payload.d.ts

@@ -0,0 +1,8 @@
+interface LoadPayloadOptions {
+    fresh?: boolean;
+    hash?: string;
+}
+export declare function loadPayload(url: string, opts?: LoadPayloadOptions): any;
+export declare function preloadPayload(url: string, opts?: LoadPayloadOptions): void;
+export declare function isPrerendered(): boolean;
+export {};

package/dist/app/composables/payload.mjs

@@ -0,0 +1,58 @@
+import { joinURL } from "ufo";
+import { useDtwoApp } from "../dtwo.mjs";
+import { useHead, useRuntimeConfig } from "../index.mjs";
+export function loadPayload(url, opts = {}) {
+  if (process.server) {
+    return null;
+  }
+  const payloadURL = _getPayloadURL(url, opts);
+  const dtwoApp = useDtwoApp();
+  const cache = dtwoApp._payloadCache = dtwoApp._payloadCache || {};
+  if (cache[url]) {
+    return cache[url];
+  }
+  cache[url] = _importPayload(payloadURL).then((payload) => {
+    if (!payload) {
+      delete cache[url];
+      return null;
+    }
+    return payload;
+  });
+  return cache[url];
+}
+export function preloadPayload(url, opts = {}) {
+  const payloadURL = _getPayloadURL(url, opts);
+  useHead({
+    link: [
+      { rel: "modulepreload", href: payloadURL }
+    ]
+  });
+}
+function _getPayloadURL(url, opts = {}) {
+  const u = new URL(url, "http://localhost");
+  if (u.search) {
+    throw new Error("Payload URL cannot contain search params: " + url);
+  }
+  if (u.host !== "localhost") {
+    throw new Error("Payload URL cannot contain host: " + url);
+  }
+  const hash = opts.hash || (opts.fresh ? Date.now() : "");
+  return joinURL(useRuntimeConfig().app.baseURL, u.pathname, hash ? `_payload.${hash}.js` : "_payload.js");
+}
+async function _importPayload(payloadURL) {
+  if (process.server) {
+    return null;
+  }
+  const res = await import(
+    /* webpackIgnore: true */
+    /* @wite-ignore */
+    payloadURL
+  ).catch((err) => {
+    console.warn("[dtwo] Cannot load payload ", payloadURL, err);
+  });
+  return res?.default || null;
+}
+export function isPrerendered() {
+  const dtwoApp = useDtwoApp();
+  return !!dtwoApp.payload.prerenderedAt;
+}

package/dist/app/composables/preload.d.ts

@@ -0,0 +1,17 @@
+import type { Router } from 'kdu-router';
+/**
+ * Preload a component or components that have been globally registered.
+ *
+ * @param components Pascal-cased name or names of components to prefetch
+ */
+export declare const preloadComponents: (components: string | string[]) => Promise<void>;
+/**
+ * Prefetch a component or components that have been globally registered.
+ *
+ * @param components Pascal-cased name or names of components to prefetch
+ */
+export declare const prefetchComponents: (components: string | string[]) => Promise<void>;
+export declare function preloadRouteComponents(to: string, router?: Router & {
+    _routePreloaded?: Set<string>;
+    _preloadPromises?: Array<Promise<any>>;
+}): Promise<void>;

package/dist/app/composables/preload.mjs

@@ -0,0 +1,41 @@
+import { useDtwoApp } from "../dtwo.mjs";
+import { useRouter } from "./router.mjs";
+export const preloadComponents = async (components) => {
+  if (process.server) {
+    return;
+  }
+  const dtwoApp = useDtwoApp();
+  components = Array.isArray(components) ? components : [components];
+  await Promise.all(components.map((name) => _loadAsyncComponent(dtwoApp.kduApp._context.components[name])));
+};
+export const prefetchComponents = (components) => {
+  return preloadComponents(components);
+};
+function _loadAsyncComponent(component) {
+  if (component?.__asyncLoader && !component.__asyncResolved) {
+    return component.__asyncLoader();
+  }
+}
+export async function preloadRouteComponents(to, router = useRouter()) {
+  if (process.server) {
+    return;
+  }
+  if (!router._routePreloaded) {
+    router._routePreloaded = /* @__PURE__ */ new Set();
+  }
+  if (router._routePreloaded.has(to)) {
+    return;
+  }
+  router._routePreloaded.add(to);
+  const promises = router._preloadPromises = router._preloadPromises || [];
+  if (promises.length > 4) {
+    return Promise.all(promises).then(() => preloadRouteComponents(to, router));
+  }
+  const components = router.resolve(to).matched.map((component) => component.components?.default).filter((component) => typeof component === "function");
+  for (const component of components) {
+    const promise = Promise.resolve(component()).catch(() => {
+    }).finally(() => promises.splice(promises.indexOf(promise)));
+    promises.push(promise);
+  }
+  await Promise.all(promises);
+}

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

@@ -0,0 +1,28 @@
+import type { NavigationGuard, RouteLocationNormalized, RouteLocationRaw, NavigationFailure } from 'kdu-router';
+import { DtwoError } from './error';
+export declare const useRouter: () => Router;
+export declare const useRoute: () => RouteLocationNormalizedLoaded;
+export declare const onBeforeRouteLeave: (guard: NavigationGuard) => void;
+export declare const onBeforeRouteUpdate: (guard: NavigationGuard) => void;
+export interface RouteMiddleware {
+    (to: RouteLocationNormalized, from: RouteLocationNormalized): ReturnType<NavigationGuard>;
+}
+export declare const defineDtwoRouteMiddleware: (middleware: RouteMiddleware) => RouteMiddleware;
+export interface AddRouteMiddlewareOptions {
+    global?: boolean;
+}
+interface AddRouteMiddleware {
+    (name: string, middleware: RouteMiddleware, options?: AddRouteMiddlewareOptions): void;
+    (middleware: RouteMiddleware): void;
+}
+export declare const addRouteMiddleware: AddRouteMiddleware;
+export interface NavigateToOptions {
+    replace?: boolean;
+    redirectCode?: number;
+    external?: boolean;
+}
+export declare const navigateTo: (to: RouteLocationRaw | undefined | null, options?: NavigateToOptions) => Promise<void | NavigationFailure> | RouteLocationRaw;
+/** This will abort navigation within a Dtwo route middleware handler. */
+export declare const abortNavigation: (err?: string | Partial<DtwoError>) => boolean;
+export declare const setPageLayout: (layout: string) => void;
+export {};

package/dist/app/composables/router.mjs

@@ -0,0 +1,111 @@
+import { getCurrentInstance, inject, onUnmounted } from "kdu";
+import { sendRedirect } from "h3";
+import { hasProtocol, joinURL, parseURL } from "ufo";
+import { useDtwoApp, useRuntimeConfig } from "../dtwo.mjs";
+import { createError } from "./error.mjs";
+import { useState } from "./state.mjs";
+export const useRouter = () => {
+  return useDtwoApp()?.$router;
+};
+export const useRoute = () => {
+  if (getCurrentInstance()) {
+    return inject("_route", useDtwoApp()._route);
+  }
+  return useDtwoApp()._route;
+};
+export const onBeforeRouteLeave = (guard) => {
+  const unsubscribe = useRouter().beforeEach((to, from, next) => {
+    if (to === from) {
+      return;
+    }
+    return guard(to, from, next);
+  });
+  onUnmounted(unsubscribe);
+};
+export const onBeforeRouteUpdate = (guard) => {
+  const unsubscribe = useRouter().beforeEach(guard);
+  onUnmounted(unsubscribe);
+};
+export const defineDtwoRouteMiddleware = (middleware) => middleware;
+export const addRouteMiddleware = (name, middleware, options = {}) => {
+  const dtwoApp = useDtwoApp();
+  if (options.global || typeof name === "function") {
+    dtwoApp._middleware.global.push(typeof name === "function" ? name : middleware);
+  } else {
+    dtwoApp._middleware.named[name] = middleware;
+  }
+};
+const isProcessingMiddleware = () => {
+  try {
+    if (useDtwoApp()._processingMiddleware) {
+      return true;
+    }
+  } catch {
+    return true;
+  }
+  return false;
+};
+export const navigateTo = (to, options) => {
+  if (!to) {
+    to = "/";
+  }
+  const toPath = typeof to === "string" ? to : to.path || "/";
+  const isExternal = hasProtocol(toPath, true);
+  if (isExternal && !options?.external) {
+    throw new Error("Navigating to external URL is not allowed by default. Use `nagivateTo (url, { external: true })`.");
+  }
+  if (isExternal && parseURL(toPath).protocol === "script:") {
+    throw new Error("Cannot navigate to an URL with script protocol.");
+  }
+  if (process.client && !isExternal && isProcessingMiddleware()) {
+    return to;
+  }
+  const router = useRouter();
+  if (process.server) {
+    const dtwoApp = useDtwoApp();
+    if (dtwoApp.ssrContext && dtwoApp.ssrContext.event) {
+      const redirectLocation = isExternal ? toPath : joinURL(useRuntimeConfig().app.baseURL, router.resolve(to).fullPath || "/");
+      return dtwoApp.callHook("app:redirected").then(() => sendRedirect(dtwoApp.ssrContext.event, redirectLocation, options?.redirectCode || 302));
+    }
+  }
+  if (isExternal) {
+    if (options?.replace) {
+      location.replace(toPath);
+    } else {
+      location.href = toPath;
+    }
+    return Promise.resolve();
+  }
+  return options?.replace ? router.replace(to) : router.push(to);
+};
+export const abortNavigation = (err) => {
+  if (process.dev && !isProcessingMiddleware()) {
+    throw new Error("abortNavigation() is only usable inside a route middleware handler.");
+  }
+  if (err) {
+    throw createError(err);
+  }
+  return false;
+};
+export const setPageLayout = (layout) => {
+  if (process.server) {
+    if (process.dev && getCurrentInstance() && useState("_layout").value !== layout) {
+      console.warn("[warn] [dtwo] `setPageLayout` should not be called to change the layout on the server within a component as this will cause hydration errors.");
+    }
+    useState("_layout").value = layout;
+  }
+  const dtwoApp = useDtwoApp();
+  if (process.dev && dtwoApp.isHydrating && useState("_layout").value !== layout) {
+    console.warn("[warn] [dtwo] `setPageLayout` should not be called to change the layout during hydration as this will cause hydration errors.");
+  }
+  const inMiddleware = isProcessingMiddleware();
+  if (inMiddleware || process.server || dtwoApp.isHydrating) {
+    const unsubscribe = useRouter().beforeResolve((to) => {
+      to.meta.layout = layout;
+      unsubscribe();
+    });
+  }
+  if (!inMiddleware) {
+    useRoute().meta.layout = layout;
+  }
+};

package/dist/app/composables/ssr.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+import { DtwoApp } from '../dtwo';
+export declare function useRequestHeaders<K extends string = string>(include: K[]): Record<Lowercase<K>, string | undefined>;
+export declare function useRequestHeaders(): Readonly<Record<string, string | undefined>>;
+export declare function useRequestEvent(dtwoApp?: DtwoApp): H3Event;
+export declare function setResponseStatus(code: number, message?: string): void;

package/dist/app/composables/ssr.mjs

@@ -0,0 +1,23 @@
+import { useDtwoApp } from "../dtwo.mjs";
+export function useRequestHeaders(include) {
+  if (process.client) {
+    return {};
+  }
+  const headers = useDtwoApp().ssrContext?.event.node.req.headers ?? {};
+  if (!include) {
+    return headers;
+  }
+  return Object.fromEntries(include.map((key) => key.toLowerCase()).filter((key) => headers[key]).map((key) => [key, headers[key]]));
+}
+export function useRequestEvent(dtwoApp = useDtwoApp()) {
+  return dtwoApp.ssrContext?.event;
+}
+export function setResponseStatus(code, message) {
+  const event = process.server && useRequestEvent();
+  if (event) {
+    event.node.res.statusCode = code;
+    if (message) {
+      event.node.res.statusMessage = message;
+    }
+  }
+}

package/dist/app/composables/state.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'kdu';
+/**
+ * Create a global reactive ref that will be hydrated but not shared across ssr requests
+ *
+ * @param key a unique key ensuring that data fetching can be properly de-duplicated across requests
+ * @param init a function that provides initial value for the state when it's not initiated
+ */
+export declare function useState<T>(key?: string, init?: (() => T | Ref<T>)): Ref<T>;
+export declare function useState<T>(init?: (() => T | Ref<T>)): Ref<T>;

package/dist/app/composables/state.mjs

@@ -0,0 +1,27 @@
+import { isRef, toRef } from "kdu";
+import { useDtwoApp } from "../dtwo.mjs";
+export function useState(...args) {
+  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
+  if (typeof args[0] !== "string") {
+    args.unshift(autoKey);
+  }
+  const [_key, init] = args;
+  if (!_key || typeof _key !== "string") {
+    throw new TypeError("[dtwo] [useState] key must be a string: " + _key);
+  }
+  if (init !== void 0 && typeof init !== "function") {
+    throw new Error("[dtwo] [useState] init must be a function: " + init);
+  }
+  const key = "$s" + _key;
+  const dtwo = useDtwoApp();
+  const state = toRef(dtwo.payload.state, key);
+  if (state.value === void 0 && init) {
+    const initialValue = init();
+    if (isRef(initialValue)) {
+      dtwo.payload.state[key] = initialValue;
+      return initialValue;
+    }
+    state.value = initialValue;
+  }
+  return state;
+}

package/dist/app/config.d.ts

@@ -0,0 +1,13 @@
+import type { AppConfig } from '@dtwo/schema';
+type DeepPartial<T> = T extends Function ? T : T extends Record<string, any> ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare const _getAppConfig: () => AppConfig;
+export declare function useAppConfig(): AppConfig;
+/**
+ * Deep assign the current appConfig with the new one.
+ *
+ * Will preserve existing properties.
+ */
+export declare function updateAppConfig(appConfig: DeepPartial<AppConfig>): void;
+export {};

package/dist/app/config.mjs

@@ -0,0 +1,56 @@
+import { reactive } from "kdu";
+import { useDtwoApp } from "./dtwo.mjs";
+import __appConfig from "#build/app.config.mjs";
+export const _getAppConfig = () => __appConfig;
+function deepDelete(obj, newObj) {
+  for (const key in obj) {
+    const val = newObj[key];
+    if (!(key in newObj)) {
+      delete obj[key];
+    }
+    if (val !== null && typeof val === "object") {
+      deepDelete(obj[key], newObj[key]);
+    }
+  }
+}
+function deepAssign(obj, newObj) {
+  for (const key in newObj) {
+    const val = newObj[key];
+    if (val !== null && typeof val === "object") {
+      deepAssign(obj[key], val);
+    } else {
+      obj[key] = val;
+    }
+  }
+}
+export function useAppConfig() {
+  const dtwoApp = useDtwoApp();
+  if (!dtwoApp._appConfig) {
+    dtwoApp._appConfig = reactive(__appConfig);
+  }
+  return dtwoApp._appConfig;
+}
+export function updateAppConfig(appConfig) {
+  const _appConfig = useAppConfig();
+  deepAssign(_appConfig, appConfig);
+}
+if (process.dev) {
+  let applyHMR = function(newConfig) {
+    const appConfig = useAppConfig();
+    if (newConfig && appConfig) {
+      deepAssign(appConfig, newConfig);
+      deepDelete(appConfig, newConfig);
+    }
+  };
+  if (import.meta.hot) {
+    import.meta.hot.accept((newModule) => {
+      const newConfig = newModule._getAppConfig();
+      applyHMR(newConfig);
+    });
+  }
+  if (import.meta.webpackHot) {
+    import.meta.webpackHot.accept("#build/app.config.mjs", () => {
+      applyHMR(__appConfig);
+    });
+  }
+}

package/dist/app/dtwo.d.ts

@@ -0,0 +1,122 @@
+import { Ref } from 'kdu';
+import type { App, onErrorCaptured, KNode } from 'kdu';
+import { Hookable } from 'hookable';
+import type { RuntimeConfig, AppConfigInput } from '@dtwo/schema';
+import type { SSRContext } from 'kdu-bundle-renderer/runtime';
+import type { H3Event } from 'h3';
+type DtwoMeta = {
+    htmlAttrs?: string;
+    headAttrs?: string;
+    bodyAttrs?: string;
+    headTags?: string;
+    bodyScriptsPrepend?: string;
+    bodyScripts?: string;
+};
+type HookResult = Promise<void> | void;
+type AppRenderedContext = {
+    ssrContext: DtwoApp['ssrContext'];
+};
+export interface RuntimeDtwoHooks {
+    'app:created': (app: App<Element>) => HookResult;
+    'app:beforeMount': (app: App<Element>) => HookResult;
+    'app:mounted': (app: App<Element>) => HookResult;
+    'app:rendered': (ctx: AppRenderedContext) => HookResult;
+    'app:redirected': () => HookResult;
+    'app:suspense:resolve': (Component?: KNode) => HookResult;
+    'app:error': (err: any) => HookResult;
+    'app:error:cleared': (options: {
+        redirect?: string;
+    }) => HookResult;
+    'app:data:refresh': (keys?: string[]) => HookResult;
+    'link:prefetch': (link: string) => HookResult;
+    'page:start': (Component?: KNode) => HookResult;
+    'page:finish': (Component?: KNode) => HookResult;
+    'page:transition:finish': (Component?: KNode) => HookResult;
+    'kdu:setup': () => void;
+    'kdu:error': (...args: Parameters<Parameters<typeof onErrorCaptured>[0]>) => HookResult;
+}
+export interface DtwoSSRContext extends SSRContext {
+    url: string;
+    event: H3Event;
+    runtimeConfig: RuntimeConfig;
+    noSSR: boolean;
+    /** whether we are rendering an SSR error */
+    error?: boolean;
+    dtwo: _DtwoApp;
+    payload: _DtwoApp['payload'];
+    teleports?: Record<string, string>;
+    renderMeta?: () => Promise<DtwoMeta> | DtwoMeta;
+}
+interface _DtwoApp {
+    kduApp: App<Element>;
+    globalName: string;
+    hooks: Hookable<RuntimeDtwoHooks>;
+    hook: _DtwoApp['hooks']['hook'];
+    callHook: _DtwoApp['hooks']['callHook'];
+    [key: string]: any;
+    _asyncDataPromises: Record<string, Promise<any> | undefined>;
+    _asyncData: Record<string, {
+        data: Ref<any>;
+        pending: Ref<boolean>;
+        error: Ref<any>;
+    } | undefined>;
+    isHydrating?: boolean;
+    deferHydration: () => () => void | Promise<void>;
+    ssrContext?: DtwoSSRContext;
+    payload: {
+        serverRendered?: boolean;
+        prerenderedAt?: number;
+        data: Record<string, any>;
+        state: Record<string, any>;
+        rendered?: Function;
+        error?: Error | {
+            url: string;
+            statusCode: string;
+            statusMessage: string;
+            message: string;
+            description: string;
+            data?: any;
+        } | null;
+        [key: string]: any;
+    };
+    static: {
+        data: Record<string, any>;
+    };
+    provide: (name: string, value: any) => void;
+}
+export interface DtwoApp extends _DtwoApp {
+}
+export declare const DtwoPluginIndicator = "__dtwo_plugin";
+export interface Plugin<Injections extends Record<string, any> = Record<string, any>> {
+    (dtwo: _DtwoApp): Promise<void> | Promise<{
+        provide?: Injections;
+    }> | void | {
+        provide?: Injections;
+    };
+    [DtwoPluginIndicator]?: true;
+}
+export interface CreateOptions {
+    kduApp: DtwoApp['kduApp'];
+    ssrContext?: DtwoApp['ssrContext'];
+    globalName?: DtwoApp['globalName'];
+}
+export declare function createDtwoApp(options: CreateOptions): DtwoApp;
+export declare function applyPlugin(dtwoApp: DtwoApp, plugin: Plugin): Promise<void>;
+export declare function applyPlugins(dtwoApp: DtwoApp, plugins: Plugin[]): Promise<void>;
+export declare function normalizePlugins(_plugins: Plugin[]): Plugin<Record<string, any>>[];
+export declare function defineDtwoPlugin<T extends Record<string, any>>(plugin: Plugin<T>): Plugin<T>;
+export declare function isDtwoPlugin(plugin: unknown): boolean;
+/**
+ * Ensures that the setup function passed in has access to the Dtwo instance via `useDtwo`.
+ *
+ * @param dtwo A Dtwo instance
+ * @param setup The function to call
+ */
+export declare function callWithDtwo<T extends (...args: any[]) => any>(dtwo: DtwoApp | _DtwoApp, setup: T, args?: Parameters<T>): any;
+/**
+ * Returns the current Dtwo instance.
+ */
+export declare function useDtwoApp(): DtwoApp;
+export declare function useRuntimeConfig(): RuntimeConfig;
+export declare function defineAppConfig<C extends AppConfigInput>(config: C): C;
+export {};