dtwo 2.17.0 → 3.0.0-rc.14

package/dist/pages/runtime/app.kdu

@@ -0,0 +1,5 @@
+<template>
+  <DtwoLayout>
+    <DtwoPage />
+  </DtwoLayout>
+</template>

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

@@ -0,0 +1,42 @@
+import { KeepAliveProps, TransitionProps, UnwrapRef } from 'kdu';
+import type { RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteRecordRedirectOption } from 'kdu-router';
+import type { DtwoError } from '#app';
+export interface PageMeta {
+    [key: string]: any;
+    /**
+     * Validate whether a given route can validly be rendered with this page.
+     *
+     * Return true if it is valid, or false if not. If another match can't be found,
+     * this will mean a 404. You can also directly return an object with
+     * statusCode/statusMessage to respond immediately with an error (other matches
+     * will not be checked).
+     */
+    validate?: (route: RouteLocationNormalized) => boolean | Promise<boolean> | Partial<DtwoError> | Promise<Partial<DtwoError>>;
+    /**
+     * Where to redirect if the route is directly matched. The redirection happens
+     * before any navigation guard and triggers a new navigation with the new
+     * target location.
+     */
+    redirect?: RouteRecordRedirectOption;
+    /**
+     * Aliases for the record. Allows defining extra paths that will behave like a
+     * copy of the record. Allows having paths shorthands like `/users/:id` and
+     * `/u/:id`. All `alias` and `path` values must share the same params.
+     */
+    alias?: string | string[];
+    pageTransition?: boolean | TransitionProps;
+    layoutTransition?: boolean | TransitionProps;
+    key?: false | string | ((route: RouteLocationNormalizedLoaded) => string);
+    keepalive?: boolean | KeepAliveProps;
+    /** You may define a name for this page's route. */
+    name?: string;
+    /** You may define a path matcher, if you have a more complex pattern than can be expressed with the file name. */
+    path?: string;
+    /** Set to `false` to avoid scrolling to top on page navigations */
+    scrollToTop?: boolean;
+}
+declare module 'kdu-router' {
+    interface RouteMeta extends UnwrapRef<PageMeta> {
+    }
+}
+export declare const definePageMeta: (meta: PageMeta) => void;

package/dist/pages/runtime/composables.mjs

@@ -0,0 +1,8 @@
+const warnRuntimeUsage = (method) => console.warn(
+  `${method}() is a compiler-hint helper that is only usable inside the script block of a single file component which is also a page. Its arguments should be compiled away and passing it at runtime has no effect.`
+);
+export const definePageMeta = (meta) => {
+  if (process.dev) {
+    warnRuntimeUsage("definePageMeta");
+  }
+};

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

@@ -0,0 +1 @@
+export * from './composables';

package/dist/pages/runtime/index.mjs

@@ -0,0 +1 @@
+export * from "./composables.mjs";

package/dist/pages/runtime/page-placeholder.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("kdu").DefineComponent<{}, () => import("kdu").KNode<import("kdu").RendererNode, import("kdu").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, 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/pages/runtime/page-placeholder.mjs

@@ -0,0 +1,10 @@
+import { defineComponent } from "kdu";
+export default defineComponent({
+  name: "DtwoPage",
+  setup(_, props) {
+    if (process.dev) {
+      console.warn("Create a Kdu component in the `pages/` directory to enable `<DtwoPage>`");
+    }
+    return () => props.slots.default?.();
+  }
+});

package/dist/pages/runtime/page.d.ts

@@ -0,0 +1,15 @@
+import type { DefineComponent } from 'kdu';
+declare const _default: DefineComponent<{
+    [key: string]: any;
+    name?: string | undefined;
+    route?: any;
+    pageKey?: string | ((route: RouteLocationNormalizedLoaded) => string) | undefined;
+}, {}, {}, import("kdu").ComputedOptions, import("kdu").MethodOptions, import("kdu").ComponentOptionsMixin, import("kdu").ComponentOptionsMixin, {}, string, import("kdu").KNodeProps & import("kdu").AllowedComponentProps & import("kdu").ComponentCustomProps, Readonly<import("kdu").ExtractPropTypes<{
+    [key: string]: any;
+    name?: string | undefined;
+    route?: any;
+    pageKey?: string | ((route: RouteLocationNormalizedLoaded) => string) | undefined;
+}>>, {
+    [x: string]: any;
+}>;
+export default _default;

package/dist/pages/runtime/page.mjs

@@ -0,0 +1,107 @@
+import { computed, defineComponent, h, provide, reactive, onMounted, nextTick, Suspense, Transition } from "kdu";
+import { RouterView } from "kdu-router";
+import { defu } from "defu";
+import { generateRouteKey, wrapInKeepAlive } from "./utils.mjs";
+import { useDtwoApp } from "#app";
+import { _wrapIf } from "#app/components/utils";
+import { appPageTransition as defaultPageTransition, appKeepalive as defaultKeepaliveConfig } from "#build/dtwo.config.mjs";
+export default defineComponent({
+  name: "DtwoPage",
+  inheritAttrs: false,
+  props: {
+    name: {
+      type: String
+    },
+    transition: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    keepalive: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    route: {
+      type: Object
+    },
+    pageKey: {
+      type: [Function, String],
+      default: null
+    }
+  },
+  setup(props, { attrs }) {
+    const dtwoApp = useDtwoApp();
+    return () => {
+      return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
+        default: (routeProps) => {
+          if (!routeProps.Component) {
+            return;
+          }
+          const key = generateRouteKey(props.pageKey, routeProps);
+          const done = dtwoApp.deferHydration();
+          const hasTransition = !!(props.transition ?? routeProps.route.meta.pageTransition ?? defaultPageTransition);
+          const transitionProps = hasTransition && _mergeTransitionProps([
+            props.transition,
+            routeProps.route.meta.pageTransition,
+            defaultPageTransition,
+            { onAfterLeave: () => {
+              dtwoApp.callHook("page:transition:finish", routeProps.Component);
+            } }
+          ].filter(Boolean));
+          return _wrapIf(
+            Transition,
+            hasTransition && transitionProps,
+            wrapInKeepAlive(
+              props.keepalive ?? routeProps.route.meta.keepalive ?? defaultKeepaliveConfig,
+              h(Suspense, {
+                onPending: () => dtwoApp.callHook("page:start", routeProps.Component),
+                onResolve: () => {
+                  nextTick(() => dtwoApp.callHook("page:finish", routeProps.Component).finally(done));
+                }
+              }, { default: () => h(Component, { key, routeProps, pageKey: key, hasTransition }) })
+            )
+          ).default();
+        }
+      });
+    };
+  }
+});
+function _toArray(val) {
+  return Array.isArray(val) ? val : val ? [val] : [];
+}
+function _mergeTransitionProps(routeProps) {
+  const _props = routeProps.map((prop) => ({
+    ...prop,
+    onAfterLeave: _toArray(prop.onAfterLeave)
+  }));
+  return defu(..._props);
+}
+const Component = defineComponent({
+  props: ["routeProps", "pageKey", "hasTransition"],
+  setup(props) {
+    const previousKey = props.pageKey;
+    const previousRoute = props.routeProps.route;
+    const route = {};
+    for (const key in props.routeProps.route) {
+      route[key] = computed(() => previousKey === props.pageKey ? props.routeProps.route[key] : previousRoute[key]);
+    }
+    provide("_route", reactive(route));
+    let knode;
+    if (process.dev && process.client && props.hasTransition) {
+      onMounted(() => {
+        nextTick(() => {
+          if (["#comment", "#text"].includes(knode?.el?.nodeName)) {
+            const filename = (knode?.type).__file;
+            console.warn(`[dtwo] \`${filename}\` does not have a single root node and will cause errors when navigating between routes.`);
+          }
+        });
+      });
+    }
+    return () => {
+      if (process.dev && process.client) {
+        knode = h(props.routeProps.Component);
+        return knode;
+      }
+      return h(props.routeProps.Component);
+    };
+  }
+});

package/dist/pages/runtime/router.d.ts

@@ -0,0 +1,8 @@
+import DtwoPage from './page';
+declare module '@kdujs/runtime-core' {
+    interface GlobalComponents {
+        DtwoPage: typeof DtwoPage;
+    }
+}
+declare const _default: any;
+export default _default;

package/dist/pages/runtime/router.mjs

@@ -0,0 +1,152 @@
+import { computed, reactive, shallowRef } from "kdu";
+import {
+  createRouter,
+  createWebHistory,
+  createMemoryHistory,
+  createWebHashHistory
+} from "kdu-router";
+import { createError } from "h3";
+import { withoutBase, isEqual } from "ufo";
+import { callWithDtwo, defineDtwoPlugin, useRuntimeConfig, showError, clearError, navigateTo, useError, useState } from "#app";
+import _routes from "#build/routes";
+import routerOptions from "#build/router.options";
+import { globalMiddleware, namedMiddleware } from "#build/middleware";
+function createCurrentLocation(base, location) {
+  const { pathname, search, hash } = location;
+  const hashPos = base.indexOf("#");
+  if (hashPos > -1) {
+    const slicePos = hash.includes(base.slice(hashPos)) ? base.slice(hashPos).length : 1;
+    let pathFromHash = hash.slice(slicePos);
+    if (pathFromHash[0] !== "/") {
+      pathFromHash = "/" + pathFromHash;
+    }
+    return withoutBase(pathFromHash, "");
+  }
+  const path = withoutBase(pathname, base);
+  return path + search + hash;
+}
+export default defineDtwoPlugin(async (dtwoApp) => {
+  let routerBase = useRuntimeConfig().app.baseURL;
+  if (routerOptions.hashMode && !routerBase.includes("#")) {
+    routerBase += "#";
+  }
+  const history = routerOptions.history?.(routerBase) ?? (process.client ? routerOptions.hashMode ? createWebHashHistory(routerBase) : createWebHistory(routerBase) : createMemoryHistory(routerBase));
+  const routes = routerOptions.routes?.(_routes) ?? _routes;
+  const initialURL = process.server ? dtwoApp.ssrContext.url : createCurrentLocation(routerBase, window.location);
+  const router = createRouter({
+    ...routerOptions,
+    history,
+    routes
+  });
+  dtwoApp.kduApp.use(router);
+  const previousRoute = shallowRef(router.currentRoute.value);
+  router.afterEach((_to, from) => {
+    previousRoute.value = from;
+  });
+  Object.defineProperty(dtwoApp.kduApp.config.globalProperties, "previousRoute", {
+    get: () => previousRoute.value
+  });
+  const _route = shallowRef(router.resolve(initialURL));
+  const syncCurrentRoute = () => {
+    _route.value = router.currentRoute.value;
+  };
+  dtwoApp.hook("page:finish", syncCurrentRoute);
+  router.afterEach((to, from) => {
+    if (to.matched[0]?.components?.default === from.matched[0]?.components?.default) {
+      syncCurrentRoute();
+    }
+  });
+  const route = {};
+  for (const key in _route.value) {
+    route[key] = computed(() => _route.value[key]);
+  }
+  dtwoApp._route = reactive(route);
+  dtwoApp._middleware = dtwoApp._middleware || {
+    global: [],
+    named: {}
+  };
+  const error = useError();
+  try {
+    if (process.server) {
+      await router.push(initialURL);
+    }
+    await router.isReady();
+  } catch (error2) {
+    callWithDtwo(dtwoApp, showError, [error2]);
+  }
+  const initialLayout = useState("_layout");
+  router.beforeEach(async (to, from) => {
+    to.meta = reactive(to.meta);
+    if (dtwoApp.isHydrating) {
+      to.meta.layout = initialLayout.value ?? to.meta.layout;
+    }
+    dtwoApp._processingMiddleware = true;
+    const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...dtwoApp._middleware.global]);
+    for (const component of to.matched) {
+      const componentMiddleware = component.meta.middleware;
+      if (!componentMiddleware) {
+        continue;
+      }
+      if (Array.isArray(componentMiddleware)) {
+        for (const entry of componentMiddleware) {
+          middlewareEntries.add(entry);
+        }
+      } else {
+        middlewareEntries.add(componentMiddleware);
+      }
+    }
+    for (const entry of middlewareEntries) {
+      const middleware = typeof entry === "string" ? dtwoApp._middleware.named[entry] || await namedMiddleware[entry]?.().then((r) => r.default || r) : entry;
+      if (!middleware) {
+        if (process.dev) {
+          throw new Error(`Unknown route middleware: '${entry}'. Valid middleware: ${Object.keys(namedMiddleware).map((mw) => `'${mw}'`).join(", ")}.`);
+        }
+        throw new Error(`Unknown route middleware: '${entry}'.`);
+      }
+      const result = await callWithDtwo(dtwoApp, middleware, [to, from]);
+      if (process.server || !dtwoApp.payload.serverRendered && dtwoApp.isHydrating) {
+        if (result === false || result instanceof Error) {
+          const error2 = result || createError({
+            statusCode: 404,
+            statusMessage: `Page Not Found: ${initialURL}`
+          });
+          await callWithDtwo(dtwoApp, showError, [error2]);
+          return false;
+        }
+      }
+      if (result || result === false) {
+        return result;
+      }
+    }
+  });
+  router.afterEach(async (to) => {
+    delete dtwoApp._processingMiddleware;
+    if (process.client && !dtwoApp.isHydrating && error.value) {
+      await callWithDtwo(dtwoApp, clearError);
+    }
+    if (to.matched.length === 0) {
+      callWithDtwo(dtwoApp, showError, [createError({
+        statusCode: 404,
+        fatal: false,
+        statusMessage: `Page not found: ${to.fullPath}`
+      })]);
+    } else if (process.server) {
+      const currentURL = to.fullPath || "/";
+      if (!isEqual(currentURL, initialURL)) {
+        await callWithDtwo(dtwoApp, navigateTo, [currentURL]);
+      }
+    }
+  });
+  dtwoApp.hooks.hookOnce("app:created", async () => {
+    try {
+      await router.replace({
+        ...router.resolve(initialURL),
+        name: void 0,
+        force: true
+      });
+    } catch (error2) {
+      callWithDtwo(dtwoApp, showError, [error2]);
+    }
+  });
+  return { provide: { router } };
+});

package/dist/pages/runtime/router.options.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@dtwo/schema").RouterOptions;
+export default _default;

package/dist/pages/runtime/router.options.mjs

@@ -0,0 +1,51 @@
+import { nextTick } from "kdu";
+import { useDtwoApp } from "#app";
+import { appPageTransition as defaultPageTransition } from "#build/dtwo.config.mjs";
+export default {
+  scrollBehavior(to, from, savedPosition) {
+    const dtwoApp = useDtwoApp();
+    let position = savedPosition || void 0;
+    if (!position && from && to && to.meta.scrollToTop !== false && _isDifferentRoute(from, to)) {
+      position = { left: 0, top: 0 };
+    }
+    if (to.path === from.path) {
+      if (from.hash && !to.hash) {
+        return { left: 0, top: 0 };
+      }
+      if (to.hash) {
+        return { el: to.hash, top: _getHashElementScrollMarginTop(to.hash) };
+      }
+    }
+    const hasTransition = (route) => !!(route.meta.pageTransition ?? defaultPageTransition);
+    const hookToWait = hasTransition(from) && hasTransition(to) ? "page:transition:finish" : "page:finish";
+    return new Promise((resolve) => {
+      dtwoApp.hooks.hookOnce(hookToWait, async () => {
+        await nextTick();
+        if (to.hash) {
+          position = { el: to.hash, top: _getHashElementScrollMarginTop(to.hash) };
+        }
+        resolve(position);
+      });
+    });
+  }
+};
+function _getHashElementScrollMarginTop(selector) {
+  try {
+    const elem = document.querySelector(selector);
+    if (elem) {
+      return parseFloat(getComputedStyle(elem).scrollMarginTop);
+    }
+  } catch {
+  }
+  return 0;
+}
+function _isDifferentRoute(a, b) {
+  const samePageComponent = a.matched[0] === b.matched[0];
+  if (!samePageComponent) {
+    return true;
+  }
+  if (samePageComponent && JSON.stringify(a.params) !== JSON.stringify(b.params)) {
+    return true;
+  }
+  return false;
+}

package/dist/pages/runtime/utils.d.ts

@@ -0,0 +1,9 @@
+import type { RouterView, RouteLocationNormalizedLoaded } from 'kdu-router';
+type InstanceOf<T> = T extends new (...args: any[]) => infer R ? R : never;
+type RouterViewSlot = Exclude<InstanceOf<typeof RouterView>['$slots']['default'], undefined>;
+export type RouterViewSlotProps = Parameters<RouterViewSlot>[0];
+export declare const generateRouteKey: (override: string | ((route: RouteLocationNormalizedLoaded) => string), routeProps: RouterViewSlotProps) => string;
+export declare const wrapInKeepAlive: (props: any, children: any) => {
+    default: () => any;
+};
+export {};

package/dist/pages/runtime/utils.mjs

@@ -0,0 +1,12 @@
+import { KeepAlive, h } from "kdu";
+const interpolatePath = (route, match) => {
+  return match.path.replace(/(:\w+)\([^)]+\)/g, "$1").replace(/(:\w+)[?+*]/g, "$1").replace(/:\w+/g, (r) => route.params[r.slice(1)]?.toString() || "");
+};
+export const generateRouteKey = (override, routeProps) => {
+  const matchedRoute = routeProps.route.matched.find((m) => m.components?.default === routeProps.Component.type);
+  const source = override ?? matchedRoute?.meta.key ?? (matchedRoute && interpolatePath(routeProps.route, matchedRoute));
+  return typeof source === "function" ? source(routeProps.route) : source;
+};
+export const wrapInKeepAlive = (props, children) => {
+  return { default: () => process.client && props ? h(KeepAlive, props === true ? {} : props, children) : children };
+};

package/dist/pages/runtime/validate.d.ts

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

package/dist/pages/runtime/validate.mjs

@@ -0,0 +1,11 @@
+import { createError, defineDtwoRouteMiddleware } from "#app";
+export default defineDtwoRouteMiddleware(async (to) => {
+  if (!to.meta?.validate) {
+    return;
+  }
+  const result = await Promise.resolve(to.meta.validate(to));
+  if (typeof result === "boolean") {
+    return result;
+  }
+  return createError(result);
+});

package/package.json

@@ -1,54 +1,91 @@
 {
   "name": "dtwo",
-  "version": "2.17.0",
-  "description": "A minimalistic framework for server-rendered Kdu.js applications (inspired by Next.js)",
-  "keywords": [
-    "dtwo",
-    "dtwo.js",
-    "dtwojs",
-    "ssr",
-    "kdu",
-    "kdu isomorphic",
-    "kdu server side",
-    "kdu ssr",
-    "kdu universal",
-    "kdu versatile",
-    "kdu.js",
-    "kdujs"
-  ],
+  "version": "3.0.0-rc.14",
   "repository": "d2js/framework",
   "license": "MIT",
-  "main": "dist/dtwo.js",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./types.d.ts",
   "bin": {
-    "dtwo": "./bin/dtwo.js"
+    "dcli": "./bin/dtwo.mjs",
+    "dtwo": "./bin/dtwo.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./config": {
+      "import": "./config.mjs",
+      "require": "./config.cjs",
+      "types": "./config.d.ts"
+    },
+    "./app": "./dist/app/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#app": "./dist/app/index.mjs",
+    "#head": "./dist/head/runtime/index.mjs",
+    "#pages": "./dist/pages/runtime/index.mjs"
   },
   "files": [
+    "app.d.ts",
     "bin",
+    "types.d.ts",
     "dist",
-    "webpack.config.js"
+    "config.*"
   ],
-  "scripts": {
-    "postinstall": "opencollective || exit 0"
-  },
   "dependencies": {
-    "@dtwo/babel-preset-app": "2.17.0",
-    "@dtwo/builder": "2.17.0",
-    "@dtwo/cli": "2.17.0",
-    "@dtwo/components": "^2.2.1",
-    "@dtwo/config": "2.17.0",
-    "@dtwo/core": "2.17.0",
-    "@dtwo/generator": "2.17.0",
-    "@dtwo/kdu-app": "2.17.0",
-    "@dtwo/kdu-renderer": "2.17.0",
-    "@dtwo/loading-screen": "^2.0.4",
-    "@dtwo/opencollective": "^0.3.3",
-    "@dtwo/server": "2.17.0",
-    "@dtwo/telemetry": "^1.4.1",
-    "@dtwo/utils": "2.17.0",
-    "@dtwo/webpack": "2.17.0"
+    "@d2js/devalue": "^2.0.2",
+    "@dtwo/cli": "3.0.0-rc.14",
+    "@dtwo/kit": "3.0.0-rc.14",
+    "@dtwo/schema": "3.0.0-rc.14",
+    "@dtwo/telemetry": "^2.1.7",
+    "@dtwo/ui-templates": "^0.4.0",
+    "@dtwo/unplugin": "^1.0.0",
+    "@dtwo/wite-builder": "3.0.0-rc.14",
+    "@kdhead/ssr": "^0.6.9",
+    "@kdujs/reactivity": "^3.2.45",
+    "@kdujs/shared": "^3.2.45",
+    "@kduse/head": "^1.0.13",
+    "chokidar": "^3.5.3",
+    "cookie-es": "^0.5.0",
+    "defu": "^6.1.1",
+    "destr": "^1.2.1",
+    "escape-string-regexp": "^5.0.0",
+    "estree-walker": "^3.0.1",
+    "fs-extra": "^10.1.0",
+    "globby": "^13.1.2",
+    "h3": "^1.0.1",
+    "hash-sum": "^2.0.0",
+    "holepack": "^1.0.0",
+    "hookable": "^5.4.2",
+    "kdhead": "^0.6.9",
+    "kdimport": "^1.0.0",
+    "kdu": "^3.2.45",
+    "kdu-bundle-renderer": "^1.0.0",
+    "kdu-devtools-stub": "^0.1.0",
+    "kdu-router": "^4.1.6",
+    "knitwork": "^1.0.0",
+    "magic-string": "^0.26.7",
+    "mlly": "^1.0.0",
+    "ohash": "^1.0.0",
+    "ofetch": "^1.0.0",
+    "pathe": "^1.0.0",
+    "perfect-debounce": "^0.1.3",
+    "scule": "^1.0.0",
+    "strip-literal": "^1.0.0",
+    "ufo": "^1.0.0",
+    "ultrahtml": "^1.0.0",
+    "unctx": "^2.1.0",
+    "unenv": "^1.0.0",
+    "untyped": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.13",
+    "@types/hash-sum": "^1.0.0",
+    "kdu-meta": "next",
+    "unbuild": "latest"
+  },
+  "engines": {
+    "node": "^14.16.0 || ^16.10.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
   },
-  "collective": {
-    "url": "https://opencollective.com/kdu-platforms",
-    "logoUrl": "https://opencollective.com/kdu-platforms/logo.txt?reverse=true&variant=variant2"
-  }
-}
+  "scripts": {}
+}

package/types.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="holepack" />
+export * from './dist/index'
+
+declare global {
+  const defineDtwoConfig: typeof import('dtwo/config')['defineDtwoConfig']
+}
+
+declare module 'holepack' {
+  interface HoleRouteConfig {
+    ssr?: boolean
+  }
+  interface HoleRouteRules {
+    ssr?: boolean
+  }
+}

package/bin/dtwo.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-global.__DTWO_PATHS__ = (global.__DTWO_PATHS__ || []).concat(__dirname)
-
-const suffix = require('../package.json').name.includes('-edge') ? '-edge' : ''
-require('@dtwo/cli' + suffix).run()
-  .catch((error) => {
-    require('consola').fatal(error)
-    process.exit(2)
-  })

package/dist/dtwo.js

@@ -1,37 +0,0 @@
-/*!
- * dtwo v2.17.0 (c) 2023-2023
- * Released under the MIT License
- * Repository: https://github.com/d2js/framework
- * Website: https://dtwojs-v2.web.app
-*/
-'use strict';
-
-const core = require('@dtwo/core');
-const builder = require('@dtwo/builder');
-const generator = require('@dtwo/generator');
-const cli = require('@dtwo/cli');
-
-
-
-Object.defineProperty(exports, 'getWebpackConfig', {
-	enumerable: true,
-	get: function () { return cli.getWebpackConfig; }
-});
-Object.keys(core).forEach(function (k) {
-	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return core[k]; }
-	});
-});
-Object.keys(builder).forEach(function (k) {
-	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return builder[k]; }
-	});
-});
-Object.keys(generator).forEach(function (k) {
-	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return generator[k]; }
-	});
-});