@goplusvn/core 0.1.13 → 0.1.15

package/src/crud/server-service.ts

@@ -0,0 +1,312 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Generic server-side CRUD engine (Prisma-backed) for @goerp/core.
+//
+// Core is schema-agnostic, so this is a FACTORY: the consuming app injects its
+// own Prisma client + entity→model resolver. The engine itself (query building,
+// filter/sort/search allowlist, relation connect/disconnect, Decimal serialize)
+// lives here so every app stops re-implementing it.
+//
+// Usage (app side):
+//   import { createServerCrudService, getModelName } from "@goerp/core/crud/server";
+//   import { prisma } from "@/lib/prisma";
+//   const MODEL_MAP = { customers: "customer", "fee-schedules": "feeSchedule" };
+//   export const crudService = createServerCrudService({
+//     prisma,
+//     getModelName: (e) => getModelName(e, MODEL_MAP),
+//   });
+
+import type { CrudQueryParams, CrudResponse, EntityConfig } from "../types";
+import { serializeDecimalFields } from "../utils/serialize";
+
+type PrismaLike = Record<string, any>;
+
+export interface ServerCrudService {
+  list(entity: string, config: EntityConfig, params: CrudQueryParams): Promise<CrudResponse>;
+  getById(entity: string, id: string): Promise<any>;
+  create(entity: string, data: any, config?: EntityConfig): Promise<any>;
+  update(entity: string, id: string, data: any, config?: EntityConfig): Promise<any>;
+  delete(entity: string, id: string): Promise<any>;
+  deleteMany(entity: string, ids: string[]): Promise<any>;
+}
+
+export interface ServerCrudLogger {
+  warn(message: string, ...rest: unknown[]): void;
+  error(message: string, ...rest: unknown[]): void;
+}
+
+export interface ServerCrudDeps {
+  /** The app's PrismaClient instance. */
+  prisma: PrismaLike;
+  /** Resolve a plural entity key → Prisma model name. Defaults to {@link getModelName}. */
+  getModelName?: (entity: string) => string;
+  /** Optional: enrich rows with createdByName/updatedByName. Schema-tolerant — inject
+   *  {@link createAuditUserNameResolver} if your User model exposes a name field. */
+  resolveAuditNames?: (records: any[]) => Promise<any[]>;
+  logger?: ServerCrudLogger;
+}
+
+const MAX_PAGE_SIZE = 200;
+
+// Default plural→model resolver: strip trailing "s", camelCase kebab. Apps with
+// irregular names pass a map: getModelName(entity, { "fee-schedules": "feeSchedule" }).
+export function getModelName(entity: string, map?: Record<string, string>): string {
+  if (map && map[entity]) return map[entity];
+  return entity.replace(/s$/, "").replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+// Opt-in audit-name resolver. Overwrites createdByName/updatedByName from a User
+// model. `nameField` handles schema drift (vinhhoa: "name", wu: "fullName").
+export function createAuditUserNameResolver(opts: {
+  prisma: PrismaLike;
+  userModel?: string;
+  nameField?: string;
+}): (records: any[]) => Promise<any[]> {
+  const { prisma, userModel = "user", nameField = "name" } = opts;
+  return async (records: any[]) => {
+    if (!records.length) return records;
+    const ids = new Set<string>();
+    for (const r of records) {
+      if (r?.createdBy) ids.add(r.createdBy);
+      if (r?.updatedBy) ids.add(r.updatedBy);
+    }
+    if (!ids.size) return records;
+    try {
+      const users = await prisma[userModel].findMany({
+        where: { id: { in: Array.from(ids) } },
+        select: { id: true, [nameField]: true },
+      });
+      const nameOf = new Map<string, string>(users.map((u: any) => [u.id, u[nameField] || u.id]));
+      return records.map((r) => ({
+        ...r,
+        createdByName: r.createdBy ? nameOf.get(r.createdBy) ?? r.createdBy : null,
+        updatedByName: r.updatedBy ? nameOf.get(r.updatedBy) ?? r.updatedBy : null,
+      }));
+    } catch {
+      return records;
+    }
+  };
+}
+
+export function createServerCrudService(deps: ServerCrudDeps): ServerCrudService {
+  const prisma = deps.prisma;
+  const resolveModel = deps.getModelName ?? ((e: string) => getModelName(e));
+  const resolveAuditNames = deps.resolveAuditNames ?? (async (r: any[]) => r);
+  const log: ServerCrudLogger = deps.logger ?? {
+    warn: (m, ...r) => console.warn(m, ...r),
+    error: (m, ...r) => console.error(m, ...r),
+  };
+
+  const model = (entity: string) => {
+    const name = resolveModel(entity);
+    const m = prisma[name];
+    if (!m) throw new Error(`Prisma model not found for entity: ${entity} (${name})`);
+    return m;
+  };
+
+  const filterValidFields = (data: any, config: EntityConfig) => {
+    const valid = new Set(config.fields.filter((f) => !(f as any).isDisplayOnly).map((f) => f.name));
+    valid.add("id");
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (valid.has(k)) out[k] = v;
+      else log.warn(`Filtering out invalid field "${k}" for entity "${config.name}"`);
+    }
+    return out;
+  };
+
+  const castFieldValues = (data: any, config: EntityConfig) => {
+    const out = { ...data };
+    for (const field of config.fields) {
+      const value = out[field.name];
+      if (value === undefined || value === null) continue;
+      if (field.type === "boolean" || field.type === "switch") {
+        let isTrue: boolean;
+        if (typeof value === "string") {
+          const lv = value.toLowerCase();
+          isTrue = lv === "true" || lv === "active" || value === "1" || value === "on";
+        } else isTrue = Boolean(value);
+        if (field.type === "switch" && field.options && field.options.length >= 2) {
+          out[field.name] = isTrue ? (field.options[0] as any).value : (field.options[1] as any).value;
+        } else out[field.name] = isTrue;
+      } else if (field.type === "number" || (field.type as string) === "integer") {
+        if (typeof value === "string") {
+          if (value.trim() === "") out[field.name] = null;
+          else {
+            const num = Number(value);
+            if (!isNaN(num)) out[field.name] = num;
+          }
+        }
+      }
+    }
+    return out;
+  };
+
+  const transformRelationFields = (data: any, mode: "create" | "update") => {
+    const out = { ...data };
+    const skip = new Set(["id", "createdBy", "updatedBy", "citizenId", "targetId"]);
+    for (const key of Object.keys(out)) {
+      if (skip.has(key)) continue;
+      if (key.endsWith("Id") && key.length > 2) {
+        const rel = key.slice(0, -2);
+        const value = out[key];
+        if (value && typeof value === "string" && value.trim() !== "") {
+          out[rel] = { connect: { id: value } };
+          delete out[key];
+        } else if (value === null || value === undefined || value === "") {
+          if (mode === "update") out[rel] = { disconnect: true };
+          delete out[key];
+        }
+      }
+    }
+    return out;
+  };
+
+  return {
+    async list(entity, config, params) {
+      const prismaModel = model(entity);
+      const { page = 1, pageSize = 10, search, sort, filters } = params;
+      const safePage = Math.max(1, Number(page) || 1);
+      const safePageSize = Math.min(Math.max(1, Number(pageSize) || 10), MAX_PAGE_SIZE);
+      const skip = (safePage - 1) * safePageSize;
+      const take = safePageSize;
+
+      const allowedFields = new Set<string>([
+        ...config.fields.map((f) => f.name),
+        "id", "createdAt", "updatedAt", "createdBy", "updatedBy", config.idField || "id",
+      ]);
+      const allowedRelations = new Set<string>(config.include || []);
+      const isAllowed = (name: string) => {
+        if (!name) return false;
+        if (name.includes(".")) return allowedRelations.has(name.split(".")[0]);
+        return allowedFields.has(name);
+      };
+
+      const where: any = {};
+      if (search && search.trim()) {
+        const term = search.trim();
+        const searchFields = config.fields.filter((f) => f.filterable && f.type === "text").map((f) => f.name);
+        if (searchFields.length) where.OR = searchFields.map((f) => ({ [f]: { contains: term, mode: "insensitive" } }));
+      }
+      if (filters && filters.length) {
+        for (const filter of filters) {
+          const { name, value, operator } = filter as any;
+          if (value === undefined || value === null || (Array.isArray(value) && value.length === 0)) continue;
+          if (!isAllowed(name)) {
+            log.warn(`Ignoring filter on disallowed field "${name}" for entity "${entity}"`);
+            continue;
+          }
+          let target = where;
+          let key = name;
+          if (name.includes(".")) {
+            const parts = name.split(".");
+            key = parts.pop()!;
+            for (const p of parts) { if (!target[p]) target[p] = {}; target = target[p]; }
+          }
+          const op = operator as string;
+          if (op === "contains") target[key] = { contains: value, mode: "insensitive" };
+          else if (op === "in") target[key] = { in: value };
+          else if (op === "notIn") target[key] = { notIn: value };
+          else if (op === "eq") target[key] = value;
+          else if (op === "ne") target[key] = { not: value };
+          else if (op === "gt") target[key] = { gt: value };
+          else if (op === "gte") target[key] = { gte: value };
+          else if (op === "lt") target[key] = { lt: value };
+          else if (op === "lte") target[key] = { lte: value };
+          else if (op === "startsWith") target[key] = { startsWith: value, mode: "insensitive" };
+          else if (op === "endsWith") target[key] = { endsWith: value, mode: "insensitive" };
+          else if (op === "isNull") target[key] = null;
+          else if (op === "isNotNull") target[key] = { not: null };
+          else target[key] = value;
+        }
+      }
+
+      const orderBy: any = {};
+      const applySort = (field: string, direction: any) => {
+        if (field.includes(".")) {
+          const parts = field.split(".");
+          const leaf = parts.pop()!;
+          let t = orderBy;
+          for (const p of parts) { t[p] = t[p] || {}; t = t[p]; }
+          t[leaf] = direction;
+        } else orderBy[field] = direction;
+      };
+      if (sort && isAllowed(sort.field)) applySort(sort.field, sort.direction);
+      else if (config.defaultSort) applySort(config.defaultSort.field, config.defaultSort.direction);
+      else if (config.fields.some((f) => f.name === "createdAt")) orderBy.createdAt = "desc";
+      else orderBy[config.idField || "id"] = "desc";
+
+      const include: any = {};
+      if (config.include?.length) config.include.forEach((inc) => (include[inc] = true));
+      const includeOption = Object.keys(include).length ? { include } : {};
+
+      try {
+        const [total, data] = await Promise.all([
+          prismaModel.count({ where }),
+          prismaModel.findMany({ where, orderBy, skip, take, ...includeOption }),
+        ]);
+        const serialized = serializeDecimalFields(data);
+        const resolved = await resolveAuditNames(serialized as any[]);
+        return { data: resolved, total, page: safePage, pageSize: safePageSize } as CrudResponse;
+      } catch (error) {
+        log.error(`Error listing ${entity}:`, error);
+        throw error;
+      }
+    },
+
+    async getById(entity, id) {
+      const prismaModel = model(entity);
+      const result = await prismaModel.findUnique({ where: { id } });
+      if (!result) return null;
+      const serialized = serializeDecimalFields(result);
+      const [resolved] = await resolveAuditNames([serialized]);
+      return resolved;
+    },
+
+    async create(entity, data, config) {
+      const prismaModel = model(entity);
+      try {
+        let filtered = config ? filterValidFields(data, config) : data;
+        if (config) filtered = castFieldValues(filtered, config);
+        if (!filtered.id) filtered.id = crypto.randomUUID();
+        const prismaData = transformRelationFields(filtered, "create");
+        return serializeDecimalFields(await prismaModel.create({ data: prismaData }));
+      } catch (error) {
+        log.error(`Error creating ${entity}:`, error);
+        throw error;
+      }
+    },
+
+    async update(entity, id, data, config) {
+      const prismaModel = model(entity);
+      try {
+        let filtered = config ? filterValidFields(data, config) : data;
+        if (config) filtered = castFieldValues(filtered, config);
+        const prismaData = transformRelationFields(filtered, "update");
+        return serializeDecimalFields(await prismaModel.update({ where: { id }, data: prismaData }));
+      } catch (error) {
+        log.error(`Error updating ${entity}:`, error);
+        throw error;
+      }
+    },
+
+    async delete(entity, id) {
+      const prismaModel = model(entity);
+      try {
+        return await prismaModel.delete({ where: { id } });
+      } catch (error) {
+        log.error(`Error deleting ${entity}:`, error);
+        throw error;
+      }
+    },
+
+    async deleteMany(entity, ids) {
+      const prismaModel = model(entity);
+      try {
+        return await prismaModel.deleteMany({ where: { id: { in: ids } } });
+      } catch (error) {
+        log.error(`Error deleting many ${entity}:`, error);
+        throw error;
+      }
+    },
+  };
+}

package/src/crud/server.ts

@@ -6,3 +6,21 @@ export {
   getCrudPermissions,
   mergePermissions,
 } from './lib/permissions'
+
+// Generic Prisma-backed CRUD engine + Next.js route-handler factories.
+// Apps inject their PrismaClient + entity→model map; the engine lives in core.
+export {
+  createServerCrudService,
+  getModelName,
+  createAuditUserNameResolver,
+} from './server-service'
+export type {
+  ServerCrudService,
+  ServerCrudDeps,
+  ServerCrudLogger,
+} from './server-service'
+export {
+  createCrudCollectionHandlers,
+  createCrudItemHandlers,
+} from './crud-route-handlers'
+export type { CrudHandlerDeps } from './crud-route-handlers'

package/src/rbac/role-service.ts

@@ -18,6 +18,23 @@ export type RoleFilters = {
   status?: string;
 };
 
+// Schema-tolerance seam: apps whose User/Role tables diverge from the default
+// (name/email/image/isActive + Role.createdAt/updatedAt) pass field overrides so
+// getRolesData works without forking. E.g. wu-vpbank:
+//   { userNameField: "fullName", userActiveField: "active", userImageField: null, roleTimestamps: false }
+export type RoleServiceSchema = {
+  /** User display-name column. Default "name". */
+  userNameField?: string;
+  /** User email column. Default "email". */
+  userEmailField?: string;
+  /** User avatar column, or null if the table has none. Default "image". */
+  userImageField?: string | null;
+  /** User active-flag column. Default "isActive". */
+  userActiveField?: string;
+  /** Whether Role has createdAt/updatedAt. Default true; false → order by name, blank timestamps. */
+  roleTimestamps?: boolean;
+};
+
 export type RoleData = {
   id: string;
   name: string;
@@ -68,6 +85,7 @@ export interface RolePrismaClient {
 export async function getRolesData(
   db: RolePrismaClient,
   params: RoleFilters = {},
+  schema: RoleServiceSchema = {},
 ): Promise<{
   total: number;
   page: number;
@@ -76,6 +94,13 @@ export async function getRolesData(
 }> {
   const { page = 1, pageSize = 10, search, status } = params;
 
+  // Schema knobs (default to the canonical name/email/image/isActive + timestamps).
+  const nameField = schema.userNameField ?? "name";
+  const emailField = schema.userEmailField ?? "email";
+  const imageField = schema.userImageField === undefined ? "image" : schema.userImageField;
+  const activeField = schema.userActiveField ?? "isActive";
+  const hasTimestamps = schema.roleTimestamps ?? true;
+
   const whereConditions: any[] = [];
 
   if (search) {
@@ -94,42 +119,24 @@ export async function getRolesData(
 
   const where: any = whereConditions.length > 0 ? { AND: whereConditions } : {};
 
+  // Build the user select from the (possibly overridden) field names.
+  const userSelect: Record<string, boolean> = { id: true, [nameField]: true, [emailField]: true };
+  if (imageField) userSelect[imageField] = true;
+  if (activeField) userSelect[activeField] = true;
+
   const [total, items] = await Promise.all([
     db.role.count({ where }),
     db.role.findMany({
       where,
-      orderBy: { createdAt: "desc" },
+      orderBy: hasTimestamps ? { createdAt: "desc" } : { name: "asc" },
       skip: (page - 1) * pageSize,
       take: pageSize,
       include: {
-        userRoles: {
-          include: {
-            user: {
-              select: {
-                id: true,
-                name: true,
-                email: true,
-                image: true,
-                isActive: true,
-              },
-            },
-          },
-        },
+        userRoles: { include: { user: { select: userSelect } } },
         rolePermissions: {
           include: {
-            resource: {
-              select: {
-                code: true,
-                name: true,
-                icon: true,
-              },
-            },
-            action: {
-              select: {
-                code: true,
-                name: true,
-              },
-            },
+            resource: { select: { code: true, name: true, icon: true } },
+            action: { select: { code: true, name: true } },
           },
         },
       },
@@ -150,13 +157,13 @@ export async function getRolesData(
     usersCount: role.userRoles.length,
     users: role.userRoles.map((ur: any) => ({
       id: ur.user.id,
-      name: ur.user.name,
-      email: ur.user.email,
-      image: ur.user.image,
-      isActive: ur.user.isActive,
+      name: ur.user[nameField] ?? null,
+      email: ur.user[emailField] ?? null,
+      image: imageField ? ur.user[imageField] ?? null : null,
+      isActive: activeField ? Boolean(ur.user[activeField]) : true,
     })),
-    createdAt: role.createdAt.toISOString(),
-    updatedAt: role.updatedAt.toISOString(),
+    createdAt: hasTimestamps && role.createdAt ? role.createdAt.toISOString() : "",
+    updatedAt: hasTimestamps && role.updatedAt ? role.updatedAt.toISOString() : "",
     createdBy: role.createdBy || undefined,
     updatedBy: role.updatedBy || undefined,
   }));

package/src/ui/index.tsx

@@ -15,3 +15,4 @@ export * from "./auth";
 // export * from "./crud"
 export * from "./management";
 export * from "./pages/not-found";
+export * from "./shared";

package/src/ui/layout/page-tabs.tsx

@@ -85,44 +85,10 @@ export function PageTabs({
     currentTabIndex >= 0 && currentTabIndex < sortedTabs.length - 1;
   const hasOtherTabs = sortedTabs.length > 1;
 
-  // Generate unique gradient background for each tab based on path
-  const getTabBackgroundColor = (path: string, isActive: boolean) => {
-    if (isActive) return "bg-background";
-
-    // Generate consistent hash from path
-    const normalizedPath = path.replace(/^\/[a-z]{2}(\/|$)/, "/");
-    const hash = normalizedPath.split("").reduce((acc, char) => {
-      return (acc << 5) - acc + char.charCodeAt(0);
-    }, 0);
-
-    // Refined gradient palette - darker and more visible (using dark theme colors for both modes)
-    const gradients = [
-      "bg-gradient-to-r from-slate-700 to-slate-600",
-      "bg-gradient-to-r from-zinc-700 to-zinc-600",
-      "bg-gradient-to-r from-stone-700 to-stone-600",
-      "bg-gradient-to-r from-neutral-700 to-neutral-600",
-      "bg-gradient-to-r from-blue-700 to-blue-600",
-      "bg-gradient-to-r from-indigo-700 to-indigo-600",
-      "bg-gradient-to-r from-purple-700 to-purple-600",
-      "bg-gradient-to-r from-violet-700 to-violet-600",
-      "bg-gradient-to-r from-fuchsia-700 to-fuchsia-600",
-      "bg-gradient-to-r from-pink-700 to-pink-600",
-      "bg-gradient-to-r from-rose-700 to-rose-600",
-      "bg-gradient-to-r from-red-700 to-red-600",
-      "bg-gradient-to-r from-orange-700 to-orange-600",
-      "bg-gradient-to-r from-amber-700 to-amber-600",
-      "bg-gradient-to-r from-yellow-700 to-yellow-600",
-      "bg-gradient-to-r from-lime-700 to-lime-600",
-      "bg-gradient-to-r from-green-700 to-green-600",
-      "bg-gradient-to-r from-emerald-700 to-emerald-600",
-      "bg-gradient-to-r from-teal-700 to-teal-600",
-      "bg-gradient-to-r from-cyan-700 to-cyan-600",
-      "bg-gradient-to-r from-sky-700 to-sky-600",
-    ];
-
-    // Select gradient based on hash to ensure consistency
-    const gradientIndex = Math.abs(hash) % gradients.length;
-    return gradients[gradientIndex];
+  // Neutral, single-style tab background (was a per-path rainbow gradient).
+  // Active tabs sit on the page surface; inactive tabs are a muted chip.
+  const getTabBackgroundColor = (_path: string, isActive: boolean) => {
+    return isActive ? "bg-background" : "bg-muted/60";
   };
 
   return (
@@ -163,21 +129,21 @@ export function PageTabs({
                     className={cn(
                       "group relative flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium transition-all duration-200",
                       "border border-transparent",
-                      "hover:brightness-105 cursor-pointer",
+                      "cursor-pointer",
                       "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1",
                       getTabBackgroundColor(tab.path, isActive),
                       variant === "default" &&
                         (isActive
                           ? "bg-background text-foreground border-b-2 border-primary shadow-sm shadow-primary/10 border-t border-x border-b-0 rounded-t-md -mb-px z-10"
-                          : "text-white hover:text-white border-b border-white/10 rounded-t-md"),
+                          : "text-muted-foreground hover:bg-muted hover:text-foreground border-b border-border rounded-t-md"),
                       variant === "header" &&
                         (isActive
                           ? "bg-background text-foreground border-b-2 border-primary shadow-sm shadow-primary/10 border-t border-x rounded-t-md z-10"
-                          : "text-white hover:text-white border-b border-white/10 rounded-t-md"),
+                          : "text-muted-foreground hover:bg-muted hover:text-foreground border-b border-border rounded-t-md"),
                       !isLast &&
                         !isActive &&
                         variant === "default" &&
-                        "border-r border-white/10",
+                        "border-r border-border",
                     )}
                   >
                     {/* Tab number indicator (for keyboard shortcuts) */}

package/src/ui/primitives/index.tsx

@@ -132,3 +132,4 @@ export * from "./toggle";
 export * from "./toggle-group";
 export * from "./combobox";
 export * from "./label";
+export * from "./dynamic-icon";

package/src/ui/shared/confirm-dialog.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+// ConfirmDialog — promoted from vinhhoa/wu (every app copied it). Imports from
+// sub-barrels (not ../index) to avoid a circular ui/shared ↔ ui/index import.
+import * as React from "react";
+import { Button } from "../primitives";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "../feedback";
+import { AlertTriangle, Loader2 } from "lucide-react";
+
+export interface ConfirmDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  title: string;
+  description: string;
+  onConfirm: () => void;
+  loading?: boolean;
+  confirmText?: string;
+  cancelText?: string;
+  variant?: "default" | "destructive";
+}
+
+export function ConfirmDialog({
+  open,
+  onOpenChange,
+  title,
+  description,
+  onConfirm,
+  loading = false,
+  confirmText = "Xác nhận",
+  cancelText = "Hủy",
+  variant = "destructive",
+}: ConfirmDialogProps) {
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            {variant === "destructive" && <AlertTriangle className="h-5 w-5 text-destructive" />}
+            {title}
+          </DialogTitle>
+          <DialogDescription>{description}</DialogDescription>
+        </DialogHeader>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)} disabled={loading}>
+            {cancelText}
+          </Button>
+          <Button
+            variant={variant === "destructive" ? "destructive" : "default"}
+            onClick={onConfirm}
+            disabled={loading}
+          >
+            {loading && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+            {confirmText}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/ui/shared/index.ts

@@ -0,0 +1,9 @@
+// @goerp/core/ui shared app-level components (promoted from vinhhoa/wu so apps
+// stop copying them). Re-exported through the ui barrel.
+export * from "./page-header";
+export * from "./status-indicator";
+export * from "./table-sum-footer";
+export * from "./table-styles";
+export * from "./confirm-dialog";
+export * from "./stat-bar";
+export * from "./list-toolbar";