akanjs 2.0.0-rc.7 → 2.0.0

package/ui/Constant/Mermaid.tsx

@@ -0,0 +1,149 @@
+"use client";
+
+import { clsx } from "akanjs/client";
+import { useEffect, useId, useRef, useState } from "react";
+
+interface MermaidProps {
+  chart: string;
+  title?: string;
+  className?: string;
+  highlightNodes?: string[];
+  onSelectNode?: (nodeId: string) => void;
+}
+
+const lightThemeFallback = {
+  base100: "#ffffff",
+  base200: "#f5f5f5",
+  base300: "#d4d4d4",
+  baseContent: "#1f2937",
+  primary: "#3b82f6",
+};
+
+const darkThemeFallback = {
+  base100: "#1f2937",
+  base200: "#111827",
+  base300: "#374151",
+  baseContent: "#f9fafb",
+  primary: "#60a5fa",
+};
+
+export const Mermaid = ({ chart, title, className, highlightNodes = [], onSelectNode }: MermaidProps) => {
+  const reactId = useId();
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    const render = async () => {
+      try {
+        const { default: mermaid } = await import("mermaid");
+        const colors = getThemeColors();
+        mermaid.initialize({
+          startOnLoad: false,
+          securityLevel: "strict",
+          theme: "base",
+          themeVariables: {
+            background: colors.base100,
+            mainBkg: colors.base100,
+            primaryColor: colors.base100,
+            primaryTextColor: colors.baseContent,
+            primaryBorderColor: colors.baseContent,
+            lineColor: colors.baseContent,
+            secondaryColor: colors.base200,
+            tertiaryColor: colors.base300,
+          },
+        });
+        const id = `mermaid-${reactId.replace(/[^a-zA-Z0-9_-]/g, "")}`;
+        const result = await mermaid.render(id, chart.trim());
+        if (cancelled) return;
+        const parsed = new DOMParser().parseFromString(result.svg, "text/html");
+        const svg = parsed.querySelector("svg");
+        if (!svg) throw new Error("Mermaid did not return an SVG.");
+        applyHighlights(svg, highlightNodes, colors.primary);
+        applyNodeSelection(svg, onSelectNode);
+        const container = containerRef.current;
+        if (container) container.replaceChildren(document.importNode(svg, true));
+        setError(null);
+      } catch (err) {
+        if (cancelled) return;
+        containerRef.current?.replaceChildren();
+        setError(err instanceof Error ? err.message : String(err));
+      }
+    };
+    void render();
+    const observer = new MutationObserver(() => void render());
+    observer.observe(document.documentElement, { attributes: true, attributeFilter: ["class", "data-theme", "style"] });
+    return () => {
+      cancelled = true;
+      observer.disconnect();
+    };
+  }, [chart, highlightNodes, onSelectNode, reactId]);
+
+  return (
+    <div className={clsx("my-4 overflow-hidden rounded-xl border border-base-300 bg-base-200/40", className)}>
+      {title ? (
+        <div className="border-base-300 border-b px-4 py-2 font-bold text-base-content/70 text-sm">{title}</div>
+      ) : null}
+      <div className="overflow-x-auto p-4">
+        {error ? (
+          <pre className="whitespace-pre-wrap text-error text-sm">{error}</pre>
+        ) : (
+          <div ref={containerRef} className="min-w-fit text-base-content" />
+        )}
+      </div>
+    </div>
+  );
+};
+
+function getThemeColors() {
+  const root = document.documentElement;
+  const style = getComputedStyle(root);
+  const fallback = isDarkTheme(root) ? darkThemeFallback : lightThemeFallback;
+
+  return {
+    base100: getMermaidColor(style, "--color-base-100", fallback.base100),
+    base200: getMermaidColor(style, "--color-base-200", fallback.base200),
+    base300: getMermaidColor(style, "--color-base-300", fallback.base300),
+    baseContent: getMermaidColor(style, "--color-base-content", fallback.baseContent),
+    primary: getMermaidColor(style, "--color-primary", fallback.primary),
+  };
+}
+
+function getMermaidColor(style: CSSStyleDeclaration, token: string, fallback: string): string {
+  const color = style.getPropertyValue(token).trim();
+  if (!color) return fallback;
+  return isMermaidColor(color) ? color : fallback;
+}
+
+function isMermaidColor(color: string): boolean {
+  return /^(#[\da-f]{3,8}|rgba?\(|hsla?\(|[a-z]+$)/i.test(color);
+}
+
+function isDarkTheme(root: HTMLElement): boolean {
+  return root.dataset.theme === "dark" || root.classList.contains("dark");
+}
+
+function applyHighlights(svg: Element, nodeIds: string[], color: string): void {
+  if (nodeIds.length === 0) return;
+  const ids = new Set(nodeIds);
+  for (const node of svg.querySelectorAll<SVGGElement>(".node")) {
+    const id = getMermaidNodeId(node);
+    if (!ids.has(id)) continue;
+    node.querySelectorAll<SVGElement>("rect, circle, ellipse, polygon, path").forEach((shape) => {
+      shape.setAttribute("stroke", color);
+      shape.setAttribute("stroke-width", "3px");
+    });
+  }
+}
+
+function applyNodeSelection(svg: Element, onSelectNode?: (nodeId: string) => void): void {
+  if (!onSelectNode) return;
+  for (const node of svg.querySelectorAll<SVGGElement>(".node")) {
+    node.style.cursor = "pointer";
+    node.addEventListener("click", () => onSelectNode(getMermaidNodeId(node)));
+  }
+}
+
+function getMermaidNodeId(node: SVGGElement): string {
+  return node.id.replace(/^flowchart-/, "").replace(/-\d+$/, "");
+}

package/ui/Constant/index.ts

@@ -0,0 +1,6 @@
+import Doc from "./Doc";
+import { Mermaid } from "./Mermaid";
+
+export * from "./schemaDoc";
+
+export const Constant = { Doc, Mermaid };

package/ui/Constant/schemaDoc.ts

@@ -0,0 +1,324 @@
+import {
+  type Cls,
+  type EnumInstance,
+  FIELD_META,
+  getNonArrayModel,
+  PrimitiveRegistry,
+  type PrimitiveScalar,
+} from "akanjs/base";
+import { capitalize } from "akanjs/common";
+import { type ConstantCls, type ConstantField, type ConstantModel, ConstantRegistry } from "akanjs/constant";
+
+export const databaseModelVariants = ["input", "object", "full", "light", "insight"] as const;
+export type DatabaseModelVariant = (typeof databaseModelVariants)[number];
+
+export interface ConstantSchemaOptions {
+  models?: string[];
+  scalars?: string[];
+  enums?: string[];
+}
+
+export interface ConstantSchemaDoc {
+  databases: DatabaseSchema[];
+  scalars: ScalarSchema[];
+  enums: EnumSchema[];
+  relations: RelationSchema[];
+}
+
+export interface DatabaseSchema {
+  kind: "database";
+  refName: string;
+  modelName: string;
+  variants: Record<DatabaseModelVariant, ModelVariantSchema>;
+}
+
+export interface ScalarSchema {
+  kind: "scalar";
+  refName: string;
+  modelName: string;
+  modelRef: ConstantCls;
+  fields: FieldSchema[];
+}
+
+export interface ModelVariantSchema {
+  refName: string;
+  variant: DatabaseModelVariant | "scalar";
+  modelName: string;
+  modelRef: ConstantCls;
+  fields: FieldSchema[];
+}
+
+export interface EnumSchema {
+  key: string;
+  refName: string;
+  typeName: string;
+  values: (string | number)[];
+  enumRef: EnumInstance;
+  usedBy: EnumUsage[];
+}
+
+export interface EnumUsage {
+  refName: string;
+  variant: DatabaseModelVariant | "scalar";
+  fieldKey: string;
+}
+
+export interface RelationSchema {
+  sourceRefName: string;
+  sourceVariant: DatabaseModelVariant | "scalar";
+  targetRefName: string;
+  targetKind: "database" | "scalar";
+  fieldKey: string;
+  relationType: string;
+  external: boolean;
+}
+
+export interface FieldSchema {
+  key: string;
+  typeLabel: string;
+  typeRefName?: string;
+  typeKind: "primitive" | "database" | "scalar" | "map" | "unknown";
+  required: boolean;
+  nullable: boolean;
+  arrDepth: number;
+  fieldType: "property" | "hidden" | "resolve";
+  select: boolean;
+  immutable: boolean;
+  ref?: string;
+  refPath?: string;
+  refType?: "child" | "parent" | "relation";
+  relationLabel?: string;
+  enumRefName?: string;
+  enumValues?: (string | number)[];
+  defaultLabel?: string;
+  exampleLabel?: string;
+  constraints: string[];
+  text?: "search" | "filter";
+  meta: Record<string, unknown>;
+  raw: ConstantField;
+}
+
+export const getConstantSchemaDoc = (options: ConstantSchemaOptions = {}): ConstantSchemaDoc => {
+  const databases = getSelectedEntries(ConstantRegistry.database, options.models).map(([refName, model]) =>
+    buildDatabaseSchema(refName, model),
+  );
+  const scalars = getSelectedEntries(ConstantRegistry.scalar, options.scalars).map(([refName, scalar]) => {
+    const modelRef = scalar.model;
+    return {
+      kind: "scalar" as const,
+      refName,
+      modelName: getModelName(modelRef, refName),
+      modelRef,
+      fields: getFields(modelRef, "scalar"),
+    };
+  });
+  const selectedEnums = getSelectedEntries(ConstantRegistry.enum, options.enums);
+  const enumUsages = collectEnumUsages(databases, scalars);
+  const enums = selectedEnums.map(([key, enumRef]) => ({
+    key,
+    refName: enumRef.refName,
+    typeName: PrimitiveRegistry.getName(enumRef.type as typeof PrimitiveScalar),
+    values: [...enumRef.values] as (string | number)[],
+    enumRef,
+    usedBy: enumUsages.get(enumRef) ?? [],
+  }));
+  const relations = collectRelations(databases, scalars);
+  return { databases, scalars, enums, relations };
+};
+
+export const getDefaultVariant = (database: DatabaseSchema): ModelVariantSchema => database.variants.full;
+
+export const getVariantTitle = (variant: DatabaseModelVariant | "scalar") => {
+  if (variant === "scalar") return "Scalar";
+  return capitalize(variant);
+};
+
+const buildDatabaseSchema = (refName: string, model: ConstantModel): DatabaseSchema => {
+  const variants = Object.fromEntries(
+    databaseModelVariants.map((variant) => {
+      const modelRef = model[variant];
+      return [
+        variant,
+        {
+          refName,
+          variant,
+          modelName: ConstantRegistry.getModelName(modelRef),
+          modelRef,
+          fields: getFields(modelRef, variant),
+        },
+      ];
+    }),
+  ) as Record<DatabaseModelVariant, ModelVariantSchema>;
+  return { kind: "database", refName, modelName: ConstantRegistry.getModelName(model.full), variants };
+};
+
+const getFields = (modelRef: ConstantCls, variant: DatabaseModelVariant | "scalar"): FieldSchema[] =>
+  Object.entries(modelRef[FIELD_META]).map(([key, field]) => buildFieldSchema(key, field, variant));
+
+const buildFieldSchema = (
+  key: string,
+  field: ConstantField,
+  _variant: DatabaseModelVariant | "scalar",
+): FieldSchema => {
+  const props = field.getProps();
+  const typeInfo = getTypeInfo(props.modelRef, props.arrDepth, props.isMap, props.of as Cls | Cls[] | undefined);
+  const enumValues = props.enum ? ([...props.enum.values] as (string | number)[]) : undefined;
+  const relationLabel = props.refType ?? (typeInfo.typeKind === "database" ? "reference" : undefined);
+  return {
+    key,
+    typeLabel: typeInfo.typeLabel,
+    typeRefName: typeInfo.typeRefName,
+    typeKind: typeInfo.typeKind,
+    required: !props.nullable,
+    nullable: props.nullable,
+    arrDepth: props.arrDepth,
+    fieldType: props.fieldType,
+    select: props.select,
+    immutable: props.immutable,
+    ref: props.ref,
+    refPath: props.refPath,
+    refType: props.refType,
+    relationLabel,
+    enumRefName: props.enum?.refName,
+    enumValues,
+    defaultLabel: stringifyMetaValue(props.default),
+    exampleLabel: stringifyMetaValue(props.example),
+    constraints: getConstraints(props),
+    text: props.text,
+    meta: props.meta as Record<string, unknown>,
+    raw: field,
+  };
+};
+
+const getTypeInfo = (
+  modelRef: Cls,
+  arrDepth: number,
+  isMap: boolean,
+  of?: Cls | Cls[],
+): Pick<FieldSchema, "typeKind" | "typeLabel" | "typeRefName"> => {
+  if (isMap) {
+    const mapValue = of ? getNestedTypeInfo(of) : { label: "Unknown", refName: undefined };
+    return { typeKind: "map", typeLabel: `Map<String, ${mapValue.label}>`, typeRefName: mapValue.refName };
+  }
+  const refName = ConstantRegistry.getRefName(modelRef, { allowEmpty: true });
+  if (PrimitiveRegistry.has(modelRef)) {
+    return {
+      typeKind: "primitive",
+      typeLabel: formatArrayType(PrimitiveRegistry.getName(modelRef as typeof PrimitiveScalar), arrDepth),
+    };
+  }
+  if (refName && ConstantRegistry.database.has(refName)) {
+    return {
+      typeKind: "database",
+      typeLabel: formatArrayType(ConstantRegistry.getModelName(modelRef), arrDepth),
+      typeRefName: refName,
+    };
+  }
+  if (refName && ConstantRegistry.scalar.has(refName)) {
+    return {
+      typeKind: "scalar",
+      typeLabel: formatArrayType(getModelName(modelRef, refName), arrDepth),
+      typeRefName: refName,
+    };
+  }
+  return { typeKind: "unknown", typeLabel: formatArrayType("Unknown", arrDepth), typeRefName: refName };
+};
+
+const getModelName = (modelRef: Cls, refName: string) => {
+  if ((modelRef as ConstantCls).modelType) return ConstantRegistry.getModelName(modelRef);
+  return capitalize(refName);
+};
+
+const getNestedTypeInfo = (model: Cls | Cls[]) => {
+  const [modelRef, arrDepth] = getNonArrayModel(model as Cls);
+  const info = getTypeInfo(modelRef as Cls, arrDepth, modelRef === Map);
+  return { label: info.typeLabel, refName: info.typeRefName };
+};
+
+const formatArrayType = (name: string, arrDepth: number) => `${"[".repeat(arrDepth)}${name}${"]".repeat(arrDepth)}`;
+
+const stringifyMetaValue = (value: unknown): string | undefined => {
+  if (value === undefined) return undefined;
+  if (typeof value === "function") return "[function]";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+const getConstraints = (props: ReturnType<ConstantField["getProps"]>) =>
+  [
+    props.min !== undefined ? `min ${props.min}` : null,
+    props.max !== undefined ? `max ${props.max}` : null,
+    props.minlength !== undefined ? `minlength ${props.minlength}` : null,
+    props.maxlength !== undefined ? `maxlength ${props.maxlength}` : null,
+    props.text ? `text:${props.text}` : null,
+    props.validate ? "custom validate" : null,
+    props.accumulate ? "accumulate" : null,
+  ].filter((constraint): constraint is string => !!constraint);
+
+const getSelectedEntries = <Value>(map: Map<string, Value>, selected?: string[]): [string, Value][] => {
+  if (!selected?.length) return [...map.entries()].sort(([a], [b]) => a.localeCompare(b));
+  return selected.flatMap((key) => {
+    const value = map.get(key);
+    return value ? ([[key, value]] as [string, Value][]) : [];
+  });
+};
+
+const collectEnumUsages = (databases: DatabaseSchema[], scalars: ScalarSchema[]) => {
+  const usages = new Map<EnumInstance, EnumUsage[]>();
+  const addUsage = (field: FieldSchema, usage: EnumUsage) => {
+    const enumRef = field.raw.enum;
+    if (!enumRef) return;
+    usages.set(enumRef, [...(usages.get(enumRef) ?? []), usage]);
+  };
+  databases.forEach((database) => {
+    Object.values(database.variants).forEach((variant) => {
+      variant.fields.forEach((field) => {
+        addUsage(field, { refName: database.refName, variant: variant.variant, fieldKey: field.key });
+      });
+    });
+  });
+  scalars.forEach((scalar) => {
+    scalar.fields.forEach((field) => {
+      addUsage(field, { refName: scalar.refName, variant: "scalar", fieldKey: field.key });
+    });
+  });
+  return usages;
+};
+
+const collectRelations = (databases: DatabaseSchema[], scalars: ScalarSchema[]): RelationSchema[] => {
+  const selectedDatabases = new Set(databases.map((database) => database.refName));
+  const selectedScalars = new Set(scalars.map((scalar) => scalar.refName));
+  const relations: RelationSchema[] = [];
+  const addRelations = (refName: string, variant: DatabaseModelVariant | "scalar", fields: FieldSchema[]) => {
+    fields.forEach((field) => {
+      if (
+        !field.typeRefName ||
+        (field.typeKind !== "database" && field.typeKind !== "scalar" && field.typeKind !== "map")
+      )
+        return;
+      const targetKind = ConstantRegistry.database.has(field.typeRefName) ? "database" : "scalar";
+      const selected =
+        targetKind === "database" ? selectedDatabases.has(field.typeRefName) : selectedScalars.has(field.typeRefName);
+      relations.push({
+        sourceRefName: refName,
+        sourceVariant: variant,
+        targetRefName: field.typeRefName,
+        targetKind,
+        fieldKey: field.key,
+        relationType: field.relationLabel ?? field.typeKind,
+        external: !selected,
+      });
+    });
+  };
+  databases.forEach((database) => {
+    addRelations(database.refName, "full", database.variants.full.fields);
+  });
+  scalars.forEach((scalar) => {
+    addRelations(scalar.refName, "scalar", scalar.fields);
+  });
+  return relations;
+};

package/ui/Field.tsx

@@ -678,7 +678,6 @@ const Tags = ({
           />
         ) : !disabled ? (
           <div
-            
             className="flex items-center gap-2 rounded-full bg-success px-2 py-1 text-success-content text-xs duration-200 hover:cursor-pointer hover:opacity-80"
             onClick={() => {
               setInputVisible(true);

package/ui/Portal.tsx

@@ -1,3 +1,5 @@
+"use client";
+
 import { createPortal } from "react-dom";
 
 interface PortalProps {

package/ui/System/CSR.tsx

@@ -15,7 +15,7 @@ import {
 import { st } from "akanjs/store";
 import { animated } from "akanjs/ui";
 import { useFetch, usePushNoti } from "akanjs/webkit";
-import { memo, type ReactNode, useEffect, useRef } from "react";
+import { createElement, memo, type ReactNode, useEffect, useRef } from "react";
 import { createPortal } from "react-dom";
 
 import { FontFace } from "../FontFace";
@@ -305,9 +305,7 @@ const CSRPageContainer = ({ pathRoute, prefix, layoutStyle }: CSRPageContainerPr
         <animated.div
           id={`pageContainer-${pathRoute.path}`}
           style={{ ...(page?.containerStyle ?? {}), zIndex }}
-          className={clsx("absolute top-0 left-0 isolate", {
-            "w-full": layoutStyle === "web",
-            "w-screen": layoutStyle === "mobile",
+          className={clsx("absolute top-0 left-0 isolate w-screen", {
             absolute: pageType !== "current",
             hidden: pageType === "cached",
             "pointer-events-none": pageType === "prev",
@@ -398,11 +396,14 @@ const RenderLayer = memo(({ renders, index, params, searchParams }: RenderLayerP
     <RenderLayer renders={renders} index={index + 1} params={params} searchParams={searchParams} />
   );
   const routeRender = renders[index];
+  const isAsyncRender = routeRender?.render.constructor.name === "AsyncFunction";
   const resultRef = useRef<ReactNode | Promise<ReactNode> | null>(null);
-  if (resultRef.current === null) {
+  if (isAsyncRender && resultRef.current === null) {
     resultRef.current = routeRender?.render({ children, params, searchParams } as never) ?? null;
   }
   const { fulfilled, value: Component } = useFetch(resultRef.current);
+  if (!routeRender) return null;
+  if (!isAsyncRender) return createElement(routeRender.render as never, { children, params, searchParams } as never);
   if (!fulfilled || !Component) return <>{composeLoadingFallback(renders.slice(index), params)}</>;
   return <>{Component}</>;
 });

package/ui/System/SSR.tsx

@@ -119,7 +119,7 @@ const SSRWrapper = ({
           <div id="pageContainer">
             <div
               id="pageContent"
-              className={clsx("relative isolate bg-base-100", {
+              className={clsx("relative isolate", {
                 "w-full": layoutStyle === "web",
                 "left-1/2 h-screen w-[600px] -translate-x-1/2": layoutStyle === "mobile",
               })}

package/ui/System/SelectLanguage.tsx

@@ -22,7 +22,7 @@ export const SelectLanguage = ({ className, languages = parseAkanI18nEnv().local
         id="select-language"
         tabIndex={0}
         role="button"
-        className="btn btn-ghost btn-sm mx-2 my-auto min-h-0 rounded-btn px-3 font-medium text-xs md:mx-4"
+        className="btn btn-ghost btn-sm mx-2 my-auto min-h-0 border-none px-3 font-medium text-xs md:mx-4"
       >
         {languageNames[lang as keyof typeof languageNames]}
       </div>

package/ui/index.ts

@@ -3,6 +3,7 @@ export { BottomSheet, type BottomSheetRef } from "./BottomSheet";
 export { Button } from "./Button";
 export { ClientSide } from "./ClientSide";
 export { Clipboard } from "./Clipboard";
+export { Constant } from "./Constant";
 export { Copy } from "./Copy";
 export { CsrImage } from "./CsrImage";
 export { Data } from "./Data";

package/ui/styles.css

@@ -1,6 +1,5 @@
 @source "./**/*";
 @plugin "tailwind-scrollbar";
-@plugin "tailwindcss-radix";
 
 html,
 body {

package/webkit/bootCsr.tsx

@@ -23,7 +23,7 @@ import {
   parseRouteModuleKey,
   routeSegmentToTreePath,
 } from "akanjs/common";
-import { memo, type ReactNode, useRef } from "react"; 
+import { createElement, memo, type ReactNode, useRef } from "react"; 
 import * as ReactDOM from "react-dom/client";
 import { useCsrValues } from "./useCsrValues";
 import { useFetch } from "./useFetch";
@@ -48,11 +48,14 @@ const RootRenderLayer = memo(({ renders, index, params, searchParams }: RootRend
     <RootRenderLayer renders={renders} index={index + 1} params={params} searchParams={searchParams} />
   );
   const routeRender = renders[index];
+  const isAsyncRender = routeRender?.render.constructor.name === "AsyncFunction";
   const resultRef = useRef<ReactNode | Promise<ReactNode> | null>(null);
-  if (resultRef.current === null) {
+  if (isAsyncRender && resultRef.current === null) {
     resultRef.current = routeRender?.render({ children, params, searchParams } as never) ?? null;
   }
   const { fulfilled, value: Layout } = useFetch(resultRef.current);
+  if (!routeRender) return null;
+  if (!isAsyncRender) return createElement(routeRender.render as never, { children, params, searchParams } as never);
   if (!fulfilled || !Layout) return <>{composeLoadingFallback(renders.slice(index), params)}</>;
   return Layout;
 });
@@ -101,7 +104,7 @@ export const bootCsr = async (context: Record<string, () => Promise<RouteModule>
       if (pageContent.default) pages[key] = pageContent;
     }),
   );
-  const getPageState = (csrConfig?: PageConfig) => {
+  const getPageState = (PageConfig?: PageConfig) => {
     const {
       transition,
       safeArea,
@@ -111,7 +114,7 @@ export const bootCsr = async (context: Record<string, () => Promise<RouteModule>
       cache,
       topSafeAreaColor,
       bottomSafeAreaColor,
-    }: PageConfig = csrConfig ?? {};
+    }: PageConfig = PageConfig ?? {};
     const pageState: PageState = {
       transition: transition ?? "none",
       topSafeArea:
@@ -159,7 +162,7 @@ export const bootCsr = async (context: Record<string, () => Promise<RouteModule>
             pageIncludesOwnLayout: parsed.leaf === "_index",
             isSpecialRoute: parsed.isSpecialRoute,
             pageState: getPageState((page as RouteModuleWithConfig).pageConfig),
-            csrConfig: (page as RouteModuleWithConfig).pageConfig,
+            PageConfig: (page as RouteModuleWithConfig).pageConfig,
           }),
     } as Route);
   }

package/base/test-globals.d.ts

@@ -1,4 +0,0 @@
-declare const afterAll: typeof import("bun:test").afterAll;
-declare const describe: typeof import("bun:test").describe;
-declare const expect: typeof import("bun:test").expect;
-declare const test: typeof import("bun:test").test;

package/cli/templates/app/common/commonLogic.ts

@@ -1,12 +0,0 @@
-import type { AppInfo, LibInfo } from "akanjs/devkit";
-
-interface Dict {
-  appName: string;
-}
-export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict) {
-  return `
-
-export const someCommonLogic = () => {
-};
-  `;
-}

package/cli/templates/app/common/index.ts

@@ -1,10 +0,0 @@
-import type { AppInfo, LibInfo } from "akanjs/devkit";
-
-interface Dict {
-  [key: string]: string;
-}
-export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict = {}) {
-  return `
-export * from "./commonLogic";
-  `;
-}