dtwo 2.17.0 → 3.0.0

package/dist/app/components/dtwo-loading-indicator.mjs

@@ -0,0 +1,107 @@
+import { computed, defineComponent, h, onBeforeUnmount, ref } from "kdu";
+import { useDtwoApp } from "#app";
+export default defineComponent({
+  name: "DtwoLoadingIndicator",
+  props: {
+    throttle: {
+      type: Number,
+      default: 200
+    },
+    duration: {
+      type: Number,
+      default: 2e3
+    },
+    height: {
+      type: Number,
+      default: 3
+    },
+    color: {
+      type: String,
+      default: "repeating-linear-gradient(to right,#d7555d 0%,#e5757b 50%,#0047e1 100%)"
+    }
+  },
+  setup(props, { slots }) {
+    const indicator = useLoadingIndicator({
+      duration: props.duration,
+      throttle: props.throttle
+    });
+    const dtwoApp = useDtwoApp();
+    dtwoApp.hook("page:start", indicator.start);
+    dtwoApp.hook("page:finish", indicator.finish);
+    onBeforeUnmount(() => indicator.clear);
+    return () => h("div", {
+      class: "dtwo-loading-indicator",
+      style: {
+        position: "fixed",
+        top: 0,
+        right: 0,
+        left: 0,
+        pointerEvents: "none",
+        width: `${indicator.progress.value}%`,
+        height: `${props.height}px`,
+        opacity: indicator.isLoading.value ? 1 : 0,
+        background: props.color,
+        backgroundSize: `${100 / indicator.progress.value * 100}% auto`,
+        transition: "width 0.1s, height 0.4s, opacity 0.4s",
+        zIndex: 999999
+      }
+    }, slots);
+  }
+});
+function useLoadingIndicator(opts) {
+  const progress = ref(0);
+  const isLoading = ref(false);
+  const step = computed(() => 1e4 / opts.duration);
+  let _timer = null;
+  let _throttle = null;
+  function start() {
+    clear();
+    progress.value = 0;
+    isLoading.value = true;
+    if (opts.throttle) {
+      if (process.client) {
+        _throttle = setTimeout(_startTimer, opts.throttle);
+      }
+    } else {
+      _startTimer();
+    }
+  }
+  function finish() {
+    progress.value = 100;
+    _hide();
+  }
+  function clear() {
+    clearInterval(_timer);
+    clearTimeout(_throttle);
+    _timer = null;
+    _throttle = null;
+  }
+  function _increase(num) {
+    progress.value = Math.min(100, progress.value + num);
+  }
+  function _hide() {
+    clear();
+    if (process.client) {
+      setTimeout(() => {
+        isLoading.value = false;
+        setTimeout(() => {
+          progress.value = 0;
+        }, 400);
+      }, 500);
+    }
+  }
+  function _startTimer() {
+    if (process.client) {
+      _timer = setInterval(() => {
+        _increase(step.value);
+      }, 100);
+    }
+  }
+  return {
+    progress,
+    isLoading,
+    start,
+    finish,
+    clear
+  };
+}

package/dist/app/components/dtwo-root.kdu

@@ -0,0 +1,35 @@
+<template>
+  <Suspense @resolve="onResolve">
+    <ErrorComponent k-if="error" :error="error" />
+    <AppComponent k-else />
+  </Suspense>
+</template>
+
+<script setup>
+import { defineAsyncComponent, onErrorCaptured, provide } from 'kdu'
+import { callWithDtwo, isDtwoError, showError, useError, useRoute, useDtwoApp } from '#app'
+import AppComponent from '#build/app-component.mjs'
+
+const ErrorComponent = defineAsyncComponent(() => import('#build/error-component.mjs').then(r => r.default || r))
+
+const dtwoApp = useDtwoApp()
+const onResolve = dtwoApp.deferHydration()
+
+// Inject default route (outside of pages) as active route
+provide('_route', useRoute())
+
+// kdu:setup hook
+const results = dtwoApp.hooks.callHookWith(hooks => hooks.map(hook => hook()), 'kdu:setup')
+if (process.dev && results && results.some(i => i && 'then' in i)) {
+  console.error('[dtwo] Error in `kdu:setup`. Callbacks must be synchronous.')
+}
+
+// error handling
+const error = useError()
+onErrorCaptured((err, target, info) => {
+  dtwoApp.hooks.callHook('kdu:error', err, target, info).catch(hookError => console.error('[dtwo] Error in `kdu:error` hook', hookError))
+  if (process.server || (isDtwoError(err) && (err.fatal || err.unhandled))) {
+    callWithDtwo(dtwoApp, showError, [err])
+  }
+})
+</script>

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

@@ -0,0 +1,2 @@
+export { defineDtwoLink } from './dtwo-link';
+export type { DtwoLinkOptions, DtwoLinkProps } from './dtwo-link';

package/dist/app/components/index.mjs

@@ -0,0 +1 @@
+export { defineDtwoLink } from "./dtwo-link.mjs";

package/dist/app/components/layout.d.ts

@@ -0,0 +1,17 @@
+import { Ref, KNode } from 'kdu';
+declare const _default: import("kdu").DefineComponent<{
+    name: {
+        type: () => string | false | Ref<string | false>;
+        default: null;
+    };
+}, () => KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+    name: {
+        type: () => string | false | Ref<string | false>;
+        default: null;
+    };
+}>>, {
+    name: string | false | Ref<string | false>;
+}>;
+export default _default;

package/dist/app/components/layout.mjs

@@ -0,0 +1,66 @@
+import { computed, defineComponent, h, inject, nextTick, onMounted, Transition, unref } from "kdu";
+import { _wrapIf } from "./utils.mjs";
+import { useRoute } from "#app";
+import { useRoute as useKduRouterRoute } from "#build/pages";
+import layouts from "#build/layouts";
+import { appLayoutTransition as defaultLayoutTransition } from "#build/dtwo.config.mjs";
+const LayoutLoader = defineComponent({
+  props: {
+    name: String,
+    ...process.dev ? { hasTransition: Boolean } : {}
+  },
+  async setup(props, context) {
+    let knode;
+    if (process.dev && process.client) {
+      onMounted(() => {
+        nextTick(() => {
+          if (props.name && ["#comment", "#text"].includes(knode?.el?.nodeName)) {
+            console.warn(`[dtwo] \`${props.name}\` layout does not have a single root node and will cause errors when navigating between routes.`);
+          }
+        });
+      });
+    }
+    const LayoutComponent = await layouts[props.name]().then((r) => r.default || r);
+    return () => {
+      if (process.dev && process.client && props.hasTransition) {
+        knode = h(LayoutComponent, {}, context.slots);
+        return knode;
+      }
+      return h(LayoutComponent, {}, context.slots);
+    };
+  }
+});
+export default defineComponent({
+  props: {
+    name: {
+      type: [String, Boolean, Object],
+      default: null
+    }
+  },
+  setup(props, context) {
+    const injectedRoute = inject("_route");
+    const route = injectedRoute === useRoute() ? useKduRouterRoute() : injectedRoute;
+    const layout = computed(() => unref(props.name) ?? route.meta.layout ?? "default");
+    let knode;
+    let _layout;
+    if (process.dev && process.client) {
+      onMounted(() => {
+        nextTick(() => {
+          if (_layout && _layout in layouts && ["#comment", "#text"].includes(knode?.el?.nodeName)) {
+            console.warn(`[dtwo] \`${_layout}\` layout does not have a single root node and will cause errors when navigating between routes.`);
+          }
+        });
+      });
+    }
+    return () => {
+      const hasLayout = layout.value && layout.value in layouts;
+      if (process.dev && layout.value && !hasLayout && layout.value !== "default") {
+        console.warn(`Invalid layout \`${layout.value}\` selected.`);
+      }
+      const transitionProps = route.meta.layoutTransition ?? defaultLayoutTransition;
+      return _wrapIf(Transition, hasLayout && transitionProps, {
+        default: () => _wrapIf(LayoutLoader, hasLayout && { key: layout.value, name: layout.value, hasTransition: process.dev ? !!transitionProps : void 0 }, context.slots).default()
+      }).default();
+    };
+  }
+});

package/dist/app/components/server-placeholder.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("kdu").DefineComponent<{}, {}, {}, {}, {}, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/dist/app/components/server-placeholder.mjs

@@ -0,0 +1,7 @@
+import { defineComponent, createElementBlock } from "kdu";
+export default defineComponent({
+  name: "ServerPlaceholder",
+  render() {
+    return createElementBlock("div");
+  }
+});

package/dist/app/components/utils.d.ts

@@ -0,0 +1,11 @@
+import type { Component } from 'kdu';
+/**
+ * Internal utility
+ *
+ * @private
+ */
+export declare const _wrapIf: (component: Component, props: any, slots: any) => {
+    default: () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
+        [key: string]: any;
+    }>;
+};

package/dist/app/components/utils.mjs

@@ -0,0 +1,9 @@
+import { defineComponent, h } from "kdu";
+const Fragment = defineComponent({
+  setup(_props, { slots }) {
+    return () => slots.default?.();
+  }
+});
+export const _wrapIf = (component, props, slots) => {
+  return { default: () => props ? h(component, props === true ? {} : props, slots) : h(Fragment, {}, slots) };
+};

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

@@ -0,0 +1,40 @@
+import type { Ref, WatchSource } from 'kdu';
+import { DtwoApp } from '../dtwo';
+export type _Transform<Input = any, Output = any> = (input: Input) => Output;
+export type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : Pick<T, K[number]> : T;
+export type KeysOf<T> = Array<T extends T ? keyof T extends string ? keyof T : string : never>;
+export type KeyOfRes<Transform extends _Transform> = KeysOf<ReturnType<Transform>>;
+type MultiWatchSources = (WatchSource<unknown> | object)[];
+export interface AsyncDataOptions<DataT, Transform extends _Transform<DataT, any> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<_Transform> = KeyOfRes<Transform>> {
+    server?: boolean;
+    lazy?: boolean;
+    default?: () => DataT | Ref<DataT> | null;
+    transform?: Transform;
+    pick?: PickKeys;
+    watch?: MultiWatchSources;
+    immediate?: boolean;
+}
+export interface AsyncDataExecuteOptions {
+    _initial?: boolean;
+    /**
+     * Force a refresh, even if there is already a pending request. Previous requests will
+     * not be cancelled, but their result will not affect the data/pending state - and any
+     * previously awaited promises will not resolve until this new request resolves.
+     */
+    dedupe?: boolean;
+}
+export interface _AsyncData<DataT, ErrorT> {
+    data: Ref<DataT | null>;
+    pending: Ref<boolean>;
+    refresh: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+    execute: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+    error: Ref<ErrorT | null>;
+}
+export type AsyncData<Data, Error> = _AsyncData<Data, Error> & Promise<_AsyncData<Data, Error>>;
+export declare function useAsyncData<DataT, DataE = Error, Transform extends _Transform<DataT> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(handler: (ctx?: DtwoApp) => Promise<DataT>, options?: AsyncDataOptions<DataT, Transform, PickKeys>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, DataE | null>;
+export declare function useAsyncData<DataT, DataE = Error, Transform extends _Transform<DataT> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(key: string, handler: (ctx?: DtwoApp) => Promise<DataT>, options?: AsyncDataOptions<DataT, Transform, PickKeys>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, DataE | null>;
+export declare function useLazyAsyncData<DataT, DataE = Error, Transform extends _Transform<DataT> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(handler: (ctx?: DtwoApp) => Promise<DataT>, options?: Omit<AsyncDataOptions<DataT, Transform, PickKeys>, 'lazy'>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, DataE | null>;
+export declare function useLazyAsyncData<DataT, DataE = Error, Transform extends _Transform<DataT> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(key: string, handler: (ctx?: DtwoApp) => Promise<DataT>, options?: Omit<AsyncDataOptions<DataT, Transform, PickKeys>, 'lazy'>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, DataE | null>;
+export declare function refreshDtwoData(keys?: string | string[]): Promise<void>;
+export declare function clearDtwoData(keys?: string | string[] | ((key: string) => boolean)): void;
+export {};

package/dist/app/composables/asyncData.mjs

@@ -0,0 +1,169 @@
+import { onBeforeMount, onServerPrefetch, onUnmounted, ref, getCurrentInstance, watch, unref } from "kdu";
+import { useDtwoApp } from "../dtwo.mjs";
+import { createError } from "./error.mjs";
+const getDefault = () => null;
+export function useAsyncData(...args) {
+  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
+  if (typeof args[0] !== "string") {
+    args.unshift(autoKey);
+  }
+  let [key, handler, options = {}] = args;
+  if (typeof key !== "string") {
+    throw new TypeError("[dtwo] [asyncData] key must be a string.");
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError("[dtwo] [asyncData] handler must be a function.");
+  }
+  options.server = options.server ?? true;
+  options.default = options.default ?? getDefault;
+  options.lazy = options.lazy ?? false;
+  options.immediate = options.immediate ?? true;
+  const dtwo = useDtwoApp();
+  const getCachedData = () => dtwo.isHydrating ? dtwo.payload.data[key] : dtwo.static.data[key];
+  const hasCachedData = () => getCachedData() !== void 0;
+  if (!dtwo._asyncData[key]) {
+    dtwo._asyncData[key] = {
+      data: ref(getCachedData() ?? options.default?.() ?? null),
+      pending: ref(!hasCachedData()),
+      error: ref(dtwo.payload._errors[key] ? createError(dtwo.payload._errors[key]) : null)
+    };
+  }
+  const asyncData = { ...dtwo._asyncData[key] };
+  asyncData.refresh = asyncData.execute = (opts = {}) => {
+    if (dtwo._asyncDataPromises[key]) {
+      if (opts.dedupe === false) {
+        return dtwo._asyncDataPromises[key];
+      }
+      dtwo._asyncDataPromises[key].cancelled = true;
+    }
+    if (opts._initial && hasCachedData()) {
+      return getCachedData();
+    }
+    asyncData.pending.value = true;
+    const promise = new Promise(
+      (resolve, reject) => {
+        try {
+          resolve(handler(dtwo));
+        } catch (err) {
+          reject(err);
+        }
+      }
+    ).then((result) => {
+      if (promise.cancelled) {
+        return dtwo._asyncDataPromises[key];
+      }
+      if (options.transform) {
+        result = options.transform(result);
+      }
+      if (options.pick) {
+        result = pick(result, options.pick);
+      }
+      asyncData.data.value = result;
+      asyncData.error.value = null;
+    }).catch((error) => {
+      if (promise.cancelled) {
+        return dtwo._asyncDataPromises[key];
+      }
+      asyncData.error.value = error;
+      asyncData.data.value = unref(options.default?.() ?? null);
+    }).finally(() => {
+      if (promise.cancelled) {
+        return;
+      }
+      asyncData.pending.value = false;
+      dtwo.payload.data[key] = asyncData.data.value;
+      if (asyncData.error.value) {
+        dtwo.payload._errors[key] = createError(asyncData.error.value);
+      }
+      delete dtwo._asyncDataPromises[key];
+    });
+    dtwo._asyncDataPromises[key] = promise;
+    return dtwo._asyncDataPromises[key];
+  };
+  const initialFetch = () => asyncData.refresh({ _initial: true });
+  const fetchOnServer = options.server !== false && dtwo.payload.serverRendered;
+  if (process.server && fetchOnServer && options.immediate) {
+    const promise = initialFetch();
+    onServerPrefetch(() => promise);
+  }
+  if (process.client) {
+    const instance = getCurrentInstance();
+    if (instance && !instance._dtwoOnBeforeMountCbs) {
+      instance._dtwoOnBeforeMountCbs = [];
+      const cbs = instance._dtwoOnBeforeMountCbs;
+      if (instance) {
+        onBeforeMount(() => {
+          cbs.forEach((cb) => {
+            cb();
+          });
+          cbs.splice(0, cbs.length);
+        });
+        onUnmounted(() => cbs.splice(0, cbs.length));
+      }
+    }
+    if (fetchOnServer && dtwo.isHydrating && hasCachedData()) {
+      asyncData.pending.value = false;
+    } else if (instance && (dtwo.payload.serverRendered && dtwo.isHydrating || options.lazy) && options.immediate) {
+      instance._dtwoOnBeforeMountCbs.push(initialFetch);
+    } else if (options.immediate) {
+      initialFetch();
+    }
+    if (options.watch) {
+      watch(options.watch, () => asyncData.refresh());
+    }
+    const off = dtwo.hook("app:data:refresh", (keys) => {
+      if (!keys || keys.includes(key)) {
+        return asyncData.refresh();
+      }
+    });
+    if (instance) {
+      onUnmounted(off);
+    }
+  }
+  const asyncDataPromise = Promise.resolve(dtwo._asyncDataPromises[key]).then(() => asyncData);
+  Object.assign(asyncDataPromise, asyncData);
+  return asyncDataPromise;
+}
+export function useLazyAsyncData(...args) {
+  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
+  if (typeof args[0] !== "string") {
+    args.unshift(autoKey);
+  }
+  const [key, handler, options] = args;
+  return useAsyncData(key, handler, { ...options, lazy: true }, null);
+}
+export async function refreshDtwoData(keys) {
+  if (process.server) {
+    return Promise.resolve();
+  }
+  const _keys = keys ? Array.isArray(keys) ? keys : [keys] : void 0;
+  await useDtwoApp().hooks.callHookParallel("app:data:refresh", _keys);
+}
+export function clearDtwoData(keys) {
+  const dtwoApp = useDtwoApp();
+  const _allKeys = Object.keys(dtwoApp.payload.data);
+  const _keys = !keys ? _allKeys : typeof keys === "function" ? _allKeys.filter(keys) : Array.isArray(keys) ? keys : [keys];
+  for (const key of _keys) {
+    if (key in dtwoApp.payload.data) {
+      dtwoApp.payload.data[key] = void 0;
+    }
+    if (key in dtwoApp.payload._errors) {
+      dtwoApp.payload._errors[key] = void 0;
+    }
+    if (dtwoApp._asyncData[key]) {
+      dtwoApp._asyncData[key].data.value = void 0;
+      dtwoApp._asyncData[key].error.value = void 0;
+      dtwoApp._asyncData[key].pending.value = false;
+    }
+    if (key in dtwoApp._asyncDataPromises) {
+      dtwoApp._asyncDataPromises[key] = void 0;
+    }
+  }
+}
+function pick(obj, keys) {
+  const newObj = {};
+  for (const key of keys) {
+    newObj[key] = obj[key];
+  }
+  return newObj;
+}

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

@@ -0,0 +1,3 @@
+import { defineComponent } from 'kdu';
+export declare const DtwoComponentIndicator = "__dtwo_component";
+export declare const defineDtwoComponent: typeof defineComponent;

package/dist/app/composables/component.mjs

@@ -0,0 +1,46 @@
+import { getCurrentInstance, reactive, toRefs } from "kdu";
+import { useDtwoApp } from "../dtwo.mjs";
+import { useAsyncData } from "./asyncData.mjs";
+import { useRoute } from "./router.mjs";
+import { useHead } from "#head";
+export const DtwoComponentIndicator = "__dtwo_component";
+async function runLegacyAsyncData(res, fn) {
+  const dtwo = useDtwoApp();
+  const route = useRoute();
+  const vm = getCurrentInstance();
+  const { fetchKey } = vm.proxy.$options;
+  const key = typeof fetchKey === "function" ? fetchKey(() => "") : fetchKey || route.fullPath;
+  const { data } = await useAsyncData(`options:asyncdata:${key}`, () => fn(dtwo));
+  if (data.value && typeof data.value === "object") {
+    Object.assign(await res, toRefs(reactive(data.value)));
+  } else if (process.dev) {
+    console.warn("[dtwo] asyncData should return an object", data);
+  }
+}
+export const defineDtwoComponent = function defineDtwoComponent2(options) {
+  const { setup } = options;
+  if (!setup && !options.asyncData && !options.head) {
+    return {
+      [DtwoComponentIndicator]: true,
+      ...options
+    };
+  }
+  return {
+    [DtwoComponentIndicator]: true,
+    ...options,
+    setup(props, ctx) {
+      const res = setup?.(props, ctx) || {};
+      const promises = [];
+      if (options.asyncData) {
+        promises.push(runLegacyAsyncData(res, options.asyncData));
+      }
+      if (options.head) {
+        const dtwoApp = useDtwoApp();
+        useHead(typeof options.head === "function" ? () => options.head(dtwoApp) : options.head);
+      }
+      return Promise.resolve(res).then(() => Promise.all(promises)).then(() => res).finally(() => {
+        promises.length = 0;
+      });
+    }
+  };
+};

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

@@ -0,0 +1,12 @@
+import { Ref } from 'kdu';
+import { CookieParseOptions, CookieSerializeOptions } from 'cookie-es';
+type _CookieOptions = Omit<CookieSerializeOptions & CookieParseOptions, 'decode' | 'encode'>;
+export interface CookieOptions<T = any> extends _CookieOptions {
+    decode?(value: string): T;
+    encode?(value: T): string;
+    default?: () => T | Ref<T>;
+}
+export interface CookieRef<T> extends Ref<T | null> {
+}
+export declare function useCookie<T = string>(name: string, _opts?: CookieOptions<T>): CookieRef<T>;
+export {};

package/dist/app/composables/cookie.mjs

@@ -0,0 +1,58 @@
+import { ref, watch } from "kdu";
+import { parse, serialize } from "cookie-es";
+import { appendHeader } from "h3";
+import destr from "destr";
+import { isEqual } from "ohash";
+import { useDtwoApp } from "../dtwo.mjs";
+import { useRequestEvent } from "./ssr.mjs";
+const CookieDefaults = {
+  path: "/",
+  decode: (val) => destr(decodeURIComponent(val)),
+  encode: (val) => encodeURIComponent(typeof val === "string" ? val : JSON.stringify(val))
+};
+export function useCookie(name, _opts) {
+  const opts = { ...CookieDefaults, ..._opts };
+  const cookies = readRawCookies(opts) || {};
+  const cookie = ref(cookies[name] ?? opts.default?.());
+  if (process.client) {
+    watch(cookie, () => {
+      writeClientCookie(name, cookie.value, opts);
+    });
+  } else if (process.server) {
+    const dtwoApp = useDtwoApp();
+    const writeFinalCookieValue = () => {
+      if (!isEqual(cookie.value, cookies[name])) {
+        writeServerCookie(useRequestEvent(dtwoApp), name, cookie.value, opts);
+      }
+    };
+    const unhook = dtwoApp.hooks.hookOnce("app:rendered", writeFinalCookieValue);
+    dtwoApp.hooks.hookOnce("app:redirected", () => {
+      unhook();
+      return writeFinalCookieValue();
+    });
+  }
+  return cookie;
+}
+function readRawCookies(opts = {}) {
+  if (process.server) {
+    return parse(useRequestEvent()?.req.headers.cookie || "", opts);
+  } else if (process.client) {
+    return parse(document.cookie, opts);
+  }
+}
+function serializeCookie(name, value, opts = {}) {
+  if (value === null || value === void 0) {
+    return serialize(name, value, { ...opts, maxAge: -1 });
+  }
+  return serialize(name, value, opts);
+}
+function writeClientCookie(name, value, opts = {}) {
+  if (process.client) {
+    document.cookie = serializeCookie(name, value, opts);
+  }
+}
+function writeServerCookie(event, name, value, opts = {}) {
+  if (event) {
+    appendHeader(event, "Set-Cookie", serializeCookie(name, value, opts));
+  }
+}

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

@@ -0,0 +1,17 @@
+import { H3Error } from 'h3';
+export declare const useError: () => import("kdu").Ref<Error | {
+    url: string;
+    statusCode: string;
+    statusMessage: string;
+    message: string;
+    description: string;
+    data?: any;
+} | null | undefined>;
+export interface DtwoError extends H3Error {
+}
+export declare const showError: (_err: string | Error | Partial<DtwoError>) => DtwoError;
+export declare const clearError: (options?: {
+    redirect?: string;
+}) => Promise<void>;
+export declare const isDtwoError: (err?: string | object) => err is DtwoError;
+export declare const createError: (err: string | Partial<DtwoError>) => DtwoError;

package/dist/app/composables/error.mjs

@@ -0,0 +1,31 @@
+import { createError as _createError } from "h3";
+import { toRef } from "kdu";
+import { useDtwoApp } from "../dtwo.mjs";
+export const useError = () => toRef(useDtwoApp().payload, "error");
+export const showError = (_err) => {
+  const err = createError(_err);
+  try {
+    const dtwoApp = useDtwoApp();
+    dtwoApp.callHook("app:error", err);
+    const error = useError();
+    error.value = error.value || err;
+  } catch {
+    throw err;
+  }
+  return err;
+};
+export const clearError = async (options = {}) => {
+  const dtwoApp = useDtwoApp();
+  const error = useError();
+  dtwoApp.callHook("app:error:cleared", options);
+  if (options.redirect) {
+    await dtwoApp.$router.replace(options.redirect);
+  }
+  error.value = null;
+};
+export const isDtwoError = (err) => !!(err && typeof err === "object" && "__dtwo_error" in err);
+export const createError = (err) => {
+  const _err = _createError(err);
+  _err.__dtwo_error = true;
+  return _err;
+};

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

@@ -0,0 +1,15 @@
+import type { FetchError, FetchOptions } from 'ofetch';
+import type { TypedInternalResponse, HoleFetchRequest } from 'holepack';
+import { Ref } from 'kdu';
+import type { AsyncDataOptions, _Transform, KeyOfRes, AsyncData, PickFrom } from './asyncData';
+export type FetchResult<ReqT extends HoleFetchRequest> = TypedInternalResponse<ReqT, unknown>;
+type ComputedOptions<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends Function ? T[K] : T[K] extends Record<string, any> ? ComputedOptions<T[K]> | Ref<T[K]> | T[K] : Ref<T[K]> | T[K];
+};
+type ComputedFetchOptions = ComputedOptions<FetchOptions>;
+export interface UseFetchOptions<DataT, Transform extends _Transform<DataT, any> = _Transform<DataT, DataT>, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>> extends AsyncDataOptions<DataT, Transform, PickKeys>, ComputedFetchOptions {
+    key?: string;
+}
+export declare function useFetch<ResT = void, ErrorT = FetchError, ReqT extends HoleFetchRequest = HoleFetchRequest, _ResT = ResT extends void ? FetchResult<ReqT> : ResT, Transform extends (res: _ResT) => any = (res: _ResT) => _ResT, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, Transform, PickKeys>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, ErrorT | null>;
+export declare function useLazyFetch<ResT = void, ErrorT = FetchError, ReqT extends HoleFetchRequest = HoleFetchRequest, _ResT = ResT extends void ? FetchResult<ReqT> : ResT, Transform extends (res: _ResT) => any = (res: _ResT) => _ResT, PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: Omit<UseFetchOptions<_ResT, Transform, PickKeys>, 'lazy'>): AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, ErrorT | null>;
+export {};