create-snapify-app 0.0.0-stage → 1.1.1

package/template/scripts/seed-demo-products.ts

@@ -0,0 +1,120 @@
+/**
+ * Active la boutique et installe un catalogue démo (catégories + produits).
+ */
+import 'dotenv/config';
+import { runMigrations } from '../server/db/client';
+import { loadSnapshot } from '../server/cms/store';
+import { initModules, setModuleEnabled } from '../server/modules/manager';
+import { createCollection } from '../server/modules/records';
+import type { Category, Product } from '../modules/shop/src/types';
+
+const SHOP = 'novalabs.shop';
+const ECOM = ['novalabs.shop', 'novalabs.cart', 'novalabs.checkout', 'novalabs.customers'] as const;
+
+const PHOTOS = [
+  '/images/photos/sidi-bou-said-port.webp',
+  '/images/photos/ruelle-bleue-medina.jpg',
+  '/images/photos/terrasse-blanche-mer-voilier.jpg',
+  '/images/photos/hammamet-medina-plage.jpg',
+  '/images/photos/maison-campagne-collines.webp',
+  '/images/photos/caravane-chameaux-desert.webp',
+  '/images/photos/maisons-troglodytes-desert.jpg',
+  '/images/photos/panorama-ville.jpg',
+];
+
+await runMigrations();
+await loadSnapshot();
+await initModules();
+
+for (const id of ECOM) {
+  try {
+    await setModuleEnabled(id, true);
+    console.log(`[seed] module activé : ${id}`);
+  } catch (e) {
+    console.warn(`[seed] activation ${id} :`, (e as Error).message);
+  }
+}
+
+const categories = createCollection<Category>(SHOP, 'categories');
+const products = createCollection<Product>(SHOP, 'products');
+
+if ((await products.count()) > 0) {
+  console.log(`[seed] déjà ${await products.count()} produit(s) — rien à faire`);
+  process.exit(0);
+}
+
+const catDefs: Omit<Category, never>[] = [
+  { name: 'Maison & déco', slug: 'maison-deco', description: 'Objets déco et art de la table inspirés de la Méditerranée.', image: PHOTOS[0], position: 1 },
+  { name: 'Mode', slug: 'mode', description: 'Pièces légères pour le quotidien et les weekends.', image: PHOTOS[1], position: 2 },
+  { name: 'Bien-être', slug: 'bien-etre', description: 'Soins, huiles et rituels pour se ressourcer.', image: PHOTOS[2], position: 3 },
+  { name: 'Gourmet', slug: 'gourmet', description: 'Épicerie fine et saveurs du terroir tunisien.', image: PHOTOS[3], position: 4 },
+];
+
+const catIds: string[] = [];
+for (const c of catDefs) {
+  const row = await categories.insert(c, { id: `cat-${c.slug}` });
+  catIds.push(row.id);
+  console.log(`[seed] catégorie ${row.name}`);
+}
+
+type Demo = {
+  name: string;
+  slug: string;
+  sku: string;
+  price: number;
+  compareAtPrice?: number | null;
+  stock: number;
+  featured?: boolean;
+  badge?: string;
+  cats: number[];
+  photo: number;
+  short: string;
+};
+
+const demos: Demo[] = [
+  { name: 'Vase Sidi Bou', slug: 'vase-sidi-bou', sku: 'DEC-001', price: 89, compareAtPrice: 120, stock: 24, featured: true, badge: 'Promo', cats: [0], photo: 0, short: 'Céramique artisanale, émail bleu méditerranée.' },
+  { name: 'Plateau olivier', slug: 'plateau-olivier', sku: 'DEC-002', price: 65, stock: 18, featured: true, cats: [0], photo: 4, short: 'Plateau en bois d’olivier, finition huile naturelle.' },
+  { name: 'Coussin Medina', slug: 'coussin-medina', sku: 'DEC-003', price: 45, compareAtPrice: 59, stock: 40, badge: '-24 %', cats: [0, 1], photo: 1, short: 'Housse en coton brodé, motifs de la médina.' },
+  { name: 'Chemise lin Hammamet', slug: 'chemise-lin-hammamet', sku: 'MOD-001', price: 129, stock: 15, featured: true, cats: [1], photo: 3, short: 'Chemise en lin lavé, coupe décontractée.' },
+  { name: 'Sandales Cap Bon', slug: 'sandales-cap-bon', sku: 'MOD-002', price: 79, stock: 22, cats: [1], photo: 2, short: 'Sandales en cuir souple, semelle confort.' },
+  { name: 'Écharpe mer & ciel', slug: 'echarpe-mer-ciel', sku: 'MOD-003', price: 55, stock: 30, cats: [1], photo: 2, short: 'Foulard léger, dégradé bleu et blanc.' },
+  { name: 'Huile d’argan bio', slug: 'huile-argan-bio', sku: 'WEL-001', price: 42, compareAtPrice: 52, stock: 50, featured: true, badge: 'Best-seller', cats: [2], photo: 5, short: 'Huile pressée à froid, 50 ml.' },
+  { name: 'Savon noir traditionnel', slug: 'savon-noir', sku: 'WEL-002', price: 18, stock: 80, cats: [2], photo: 6, short: 'Savon noir à l’huile d’olive, rituel hammam.' },
+  { name: 'Bougie jasmin de Nabeul', slug: 'bougie-jasmin', sku: 'WEL-003', price: 28, stock: 35, cats: [2, 0], photo: 7, short: 'Cire végétale, parfum jasmin tunisien.' },
+  { name: 'Huile d’olive fruitée', slug: 'huile-olive-fruitee', sku: 'GOU-001', price: 32, stock: 60, featured: true, cats: [3], photo: 4, short: 'Extra vierge, première pression, 50 cl.' },
+  { name: 'Miel de thym', slug: 'miel-de-thym', sku: 'GOU-002', price: 38, stock: 25, cats: [3], photo: 5, short: 'Miel artisanal du Cap Bon, 250 g.' },
+  { name: 'Épices ras el hanout', slug: 'ras-el-hanout', sku: 'GOU-003', price: 14, stock: 100, badge: 'Nouveau', cats: [3], photo: 6, short: 'Mélange d’épices pour tajines et grillades.' },
+];
+
+let i = 0;
+for (const d of demos) {
+  i += 1;
+  const compareAtPrice = d.compareAtPrice && d.compareAtPrice > d.price ? d.compareAtPrice : null;
+  const data: Product = {
+    name: d.name,
+    slug: d.slug,
+    sku: d.sku,
+    price: d.price,
+    compareAtPrice,
+    onSale: compareAtPrice !== null,
+    stock: d.stock,
+    trackStock: true,
+    inStock: d.stock > 0,
+    images: [PHOTOS[d.photo % PHOTOS.length]],
+    description: `<p>${d.short}</p><p>Produit démo Snapify — catalogue Tunisie. Livraison illustrative.</p>`,
+    shortDescription: d.short,
+    categoryIds: d.cats.map((ci) => catIds[ci]),
+    status: 'active',
+    featured: !!d.featured,
+    badge: d.badge || '',
+    sales: Math.floor(Math.random() * 40),
+    position: i,
+    seoTitle: `${d.name} — Boutique démo`,
+    seoDescription: d.short,
+  };
+  await products.insert(data, { id: `prod-${d.slug}` });
+  console.log(`[seed] produit ${d.name} (${d.price} TND)`);
+}
+
+console.log(`[seed] OK — ${catIds.length} catégories, ${demos.length} produits`);
+process.exit(0);

package/template/scripts/seed-theme-content-packs.ts

@@ -0,0 +1,42 @@
+/**
+ * Installe / rafraîchit les packs contenu par thème et aligne le site sur le thème actif.
+ */
+import 'dotenv/config';
+import { eq } from 'drizzle-orm';
+import { db, runMigrations } from '../server/db/client';
+import { siteSettings } from '../server/db/schema';
+import { loadSnapshot } from '../server/cms/store';
+import {
+  applyThemePack,
+  buildDoggaPack,
+  buildMahdiaPack,
+  ensureDefaultThemePacks,
+  readThemePack,
+  writeThemePack,
+} from '../server/cms/themeContent';
+import { initModules, listThemes } from '../server/modules/manager';
+
+await runMigrations();
+await loadSnapshot();
+await initModules();
+
+// Packs officiels : toujours réécrits pour garantir un état propre après pollution cross-thème
+await writeThemePack(buildMahdiaPack());
+await writeThemePack(buildDoggaPack());
+await db.delete(siteSettings).where(eq(siteSettings.key, 'theme.content.novalabs.sidibou'));
+await ensureDefaultThemePacks();
+
+const themes = await listThemes();
+const active = themes.find((t) => t.enabled)?.id || 'novalabs.sidibou';
+const pack = await readThemePack(active);
+if (!pack) throw new Error(`Pack manquant pour ${active}`);
+await applyThemePack(pack);
+console.log(`[seed-packs] contenu appliqué : ${active} (${pack.home.blocks.length} blocs)`);
+
+for (const id of ['novalabs.sidibou', 'novalabs.dogga', 'novalabs.mahdia']) {
+  const p = await readThemePack(id);
+  const hero = p?.home.blocks.find((b) => b.type === 'hero');
+  const title = hero ? String((hero.data as { title?: string }).title || '').slice(0, 50) : '-';
+  console.log(`  ${id}: ${p?.home.blocks.length ?? 0} blocs · « ${title} »`);
+}
+process.exit(0);

package/template/scripts/snapify-module.ts

@@ -0,0 +1,207 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/**
+ * Outil des modules Snapify.
+ *
+ *   npm run module -- build <dossier-du-module-ou-thème> [--out marketplace/packages] [--unsigned]
+ *   npm run module -- verify <fichier.snapmod|.snaptheme>
+ *   npm run module -- license --module <id> --licensee "<titulaire>" --domains exemple.fr,*.exemple.fr [--plan standard] [--expires 2027-12-31]
+ *   npm run module -- catalog [marketplace]
+ *   npm run module -- keygen [--out ~/.snapify/keys] [--kid novalabs-2026]
+ *
+ * Signature : clé privée Ed25519 désignée par SNAPIFY_SIGNING_KEY (chemin PEM) ou --key,
+ * identifiant de clé SNAPIFY_SIGNING_KID ou --kid. La clé privée ne doit jamais être versionnée.
+ */
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { buildModule } from '../sdk/build';
+import {
+  checkLicensePayload,
+  compareVersions,
+  decodePackage,
+  encodeLicenseKey,
+  encodePackage,
+  PACKAGE_EXTENSIONS,
+  PACKAGE_FORMAT,
+  packageExtension,
+  sha256,
+  sign,
+  verify,
+  type ModulePackage,
+} from '../sdk/package';
+import { packageKind, type LicensePayload, type SignedLicense } from '../sdk/index';
+import { TRUSTED_KEYS } from '../server/modules/trust';
+
+const [, , command, ...rest] = process.argv;
+
+function args() {
+  const positional: string[] = [];
+  const flags: Record<string, string | true> = {};
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a.startsWith('--')) {
+      const next = rest[i + 1];
+      if (next === undefined || next.startsWith('--')) flags[a.slice(2)] = true;
+      else flags[a.slice(2)] = rest[++i];
+    } else positional.push(a);
+  }
+  return { positional, flags };
+}
+
+const expandHome = (p: string) => (p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : p);
+
+async function signingKey(flags: Record<string, string | true>) {
+  const keyPath = typeof flags.key === 'string' ? flags.key : process.env.SNAPIFY_SIGNING_KEY;
+  const kid = typeof flags.kid === 'string' ? flags.kid : process.env.SNAPIFY_SIGNING_KID || 'novalabs-2026';
+  if (!keyPath) return null;
+  return { pem: await fs.readFile(expandHome(keyPath), 'utf8'), kid };
+}
+
+function fail(message: string): never {
+  console.error(`✖ ${message}`);
+  process.exit(1);
+}
+
+function freeLicense(moduleId: string, key: { pem: string; kid: string }): SignedLicense {
+  const payload: LicensePayload = {
+    v: 1,
+    licenseId: `free-${moduleId}`,
+    moduleId,
+    licensee: 'Licence gratuite',
+    plan: 'free',
+    domains: ['*'],
+    issuedAt: new Date().toISOString(),
+    expiresAt: null,
+  };
+  return { payload, signature: sign(payload, key.pem, key.kid) };
+}
+
+async function cmdBuild() {
+  const { positional, flags } = args();
+  const dir = positional[0] || fail('Dossier du module ou du thème manquant');
+  const outDir = path.resolve(typeof flags.out === 'string' ? flags.out : 'marketplace/packages');
+  const key = flags.unsigned ? null : await signingKey(flags);
+  if (!key && !flags.unsigned) fail('Clé de signature absente : définissez SNAPIFY_SIGNING_KEY ou utilisez --unsigned (mode développeur)');
+
+  console.log(`• Compilation de ${dir}…`);
+  const { manifest, files } = await buildModule(dir);
+  const pkg: ModulePackage = {
+    format: PACKAGE_FORMAT,
+    manifest,
+    files: Object.fromEntries([...files].map(([n, d]) => [n, d.toString('base64')])),
+  };
+  if (key) {
+    pkg.signature = sign(manifest, key.pem, key.kid);
+    if (manifest.pricing === 'free') pkg.license = freeLicense(manifest.id, key);
+  }
+  await fs.mkdir(outDir, { recursive: true });
+  const file = path.join(outDir, `${manifest.id}-${manifest.version}${packageExtension(packageKind(manifest))}`);
+  await fs.writeFile(file, encodePackage(pkg));
+  for (const [name, meta] of Object.entries(manifest.files)) console.log(`  ${name.padEnd(12)} ${(meta.size / 1024).toFixed(1).padStart(8)} Ko`);
+  console.log(`✔ ${path.relative(process.cwd(), file)} ${key ? `(signé : ${key.kid})` : '(NON signé — mode développeur uniquement)'}`);
+}
+
+async function cmdVerify() {
+  const { positional } = args();
+  const file = positional[0] || fail('Fichier .snapmod ou .snaptheme manquant');
+  const { pkg } = decodePackage(await fs.readFile(file));
+  const m = pkg.manifest;
+  console.log(`${packageKind(m) === 'theme' ? 'Thème' : 'Module'} ${m.name} ${m.version} (${m.id}) — ${m.author.name}`);
+  console.log(`  Permissions : ${m.permissions.join(', ') || 'aucune'}`);
+  console.log(`  Fichiers    : ${Object.keys(m.files).join(', ')}`);
+  console.log(`  Signature   : ${verify(m, pkg.signature, TRUSTED_KEYS) ? `valide (${pkg.signature!.kid})` : pkg.signature ? 'INVALIDE' : 'absente'}`);
+  if (pkg.license) console.log(`  Licence     : ${verify(pkg.license.payload, pkg.license.signature, TRUSTED_KEYS) ? 'valide' : 'INVALIDE'} (${pkg.license.payload.plan})`);
+}
+
+async function cmdLicense() {
+  const { flags } = args();
+  const key = (await signingKey(flags)) || fail('Clé de signature absente (SNAPIFY_SIGNING_KEY ou --key)');
+  const payload: LicensePayload = {
+    v: 1,
+    licenseId: crypto.randomUUID(),
+    moduleId: String(flags.module || fail('--module requis')),
+    licensee: String(flags.licensee || fail('--licensee requis')),
+    plan: (typeof flags.plan === 'string' ? flags.plan : 'standard') as LicensePayload['plan'],
+    domains: String(flags.domains || fail('--domains requis')).split(',').map((d) => d.trim().toLowerCase()).filter(Boolean),
+    issuedAt: new Date().toISOString(),
+    expiresAt: typeof flags.expires === 'string' ? new Date(`${flags.expires}T23:59:59Z`).toISOString() : null,
+  };
+  const issues = checkLicensePayload(payload);
+  if (issues.length) fail(issues.join(', '));
+  console.log(encodeLicenseKey({ payload, signature: sign(payload, key.pem, key.kid) }));
+}
+
+async function cmdCatalog() {
+  const { positional } = args();
+  const root = path.resolve(positional[0] || 'marketplace');
+  const pkgDir = path.join(root, 'packages');
+  const shotDir = path.join(root, 'screenshots');
+  const latest = new Map<string, Record<string, unknown>>();
+  const shots = new Map<string, { name: string; data: Buffer }>();
+  for (const name of (await fs.readdir(pkgDir)).filter((f) => PACKAGE_EXTENSIONS.some((ext) => f.endsWith(ext))).sort()) {
+    const buf = await fs.readFile(path.join(pkgDir, name));
+    const { pkg, files } = decodePackage(buf);
+    const m = pkg.manifest;
+    const prev = latest.get(m.id);
+    if (prev && compareVersions(String(prev.version), m.version) >= 0) continue;
+    const shot = m.screenshot ? files.get(m.screenshot) : undefined;
+    if (shot) shots.set(m.id, { name: `${m.id}-${m.version}${path.extname(m.screenshot!)}`, data: shot });
+    else shots.delete(m.id);
+    latest.set(m.id, {
+      id: m.id,
+      kind: packageKind(m),
+      name: m.name,
+      version: m.version,
+      description: m.description,
+      author: m.author,
+      pricing: m.pricing,
+      category: m.category,
+      icon: m.icon,
+      permissions: m.permissions,
+      engines: m.engines,
+      ...(shot ? { screenshot: `screenshots/${shots.get(m.id)!.name}` } : {}),
+      package: `packages/${name}`,
+      sha256: sha256(buf),
+      size: buf.length,
+      signed: !!pkg.signature,
+    });
+  }
+  for (const [id, entry] of latest) {
+    const files = await fs.readdir(path.join(root, 'gallery', id)).catch(() => [] as string[]);
+    const gallery = files.filter((f) => /\.(jpe?g|png|webp)$/i.test(f)).sort().slice(0, 8);
+    if (gallery.length) entry.gallery = gallery.map((f) => `gallery/${id}/${f}`);
+  }
+  await fs.rm(shotDir, { recursive: true, force: true });
+  if (shots.size) await fs.mkdir(shotDir, { recursive: true });
+  for (const { name, data } of shots.values()) await fs.writeFile(path.join(shotDir, name), data);
+  const catalog = { format: 'snapify-catalog/1', generatedAt: new Date().toISOString(), modules: [...latest.values()] };
+  await fs.writeFile(path.join(root, 'catalog.json'), `${JSON.stringify(catalog, null, 2)}\n`);
+  const themes = [...latest.values()].filter((e) => e.kind === 'theme').length;
+  console.log(`✔ catalog.json : ${latest.size - themes} module(s), ${themes} thème(s)`);
+}
+
+async function cmdKeygen() {
+  const { flags } = args();
+  const out = expandHome(typeof flags.out === 'string' ? flags.out : '~/.snapify/keys');
+  const kid = typeof flags.kid === 'string' ? flags.kid : 'novalabs-2026';
+  const { privateKey, publicKey } = crypto.generateKeyPairSync('ed25519');
+  await fs.mkdir(out, { recursive: true, mode: 0o700 });
+  const file = path.join(out, `${kid}.pem`);
+  await fs.writeFile(file, privateKey.export({ type: 'pkcs8', format: 'pem' }), { mode: 0o600, flag: 'wx' }).catch(() => fail(`${file} existe déjà`));
+  console.log(`✔ Clé privée : ${file} (à conserver hors du dépôt)`);
+  console.log(`  Clé publique à ajouter dans server/modules/trust.ts :\n  '${kid}': '${publicKey.export({ type: 'spki', format: 'der' }).toString('base64')}',`);
+}
+
+const commands: Record<string, () => Promise<void>> = { build: cmdBuild, verify: cmdVerify, license: cmdLicense, catalog: cmdCatalog, keygen: cmdKeygen };
+const run = commands[command || ''];
+if (!run) {
+  console.log('Commandes : build, verify, license, catalog, keygen');
+  process.exit(command ? 1 : 0);
+}
+run().catch((e) => fail(e instanceof Error ? e.message : String(e)));

package/template/scripts/test-theme-switch.ts

@@ -0,0 +1,24 @@
+import 'dotenv/config';
+import { runMigrations } from '../server/db/client';
+import { loadSnapshot } from '../server/cms/store';
+import { initModules, activateTheme } from '../server/modules/manager';
+
+function heroTitle(blocks: { type: string; data?: { title?: string } }[]) {
+  const h = blocks.find((b) => b.type === 'hero');
+  return String(h?.data?.title || '').slice(0, 55);
+}
+
+await runMigrations();
+await loadSnapshot();
+await initModules();
+
+for (const id of ['novalabs.mahdia', 'novalabs.dogga', 'novalabs.sidibou', 'novalabs.mahdia']) {
+  await activateTheme(id);
+  const { loadSnapshot: reload } = await import('../server/cms/store');
+  const s = await reload();
+  const home = s.pages.find((p) => p.path === '/');
+  const menu = s.menus.find((m) => m.id === 'primary')?.items.map((i) => i.label).join('>') || '';
+  const hasShop = (home?.blocks || []).some((b) => b.type === 'module' && (b.data as { module?: string }).module === 'novalabs.shop');
+  console.log(`→ ${id} | hero=« ${heroTitle(home?.blocks || [])} » | shopWidgets=${hasShop} | menu=${menu}`);
+}
+process.exit(0);

package/template/sdk/admin.css

@@ -0,0 +1,18 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/* Couleurs de l'administration disponibles dans les pages d'administration des modules (bg-brand-600…). */
+@theme inline reference {
+  --color-brand-50: #e6faf8;
+  --color-brand-100: #c2f2ee;
+  --color-brand-200: #8fe6df;
+  --color-brand-500: #00c6ba;
+  --color-brand-600: #00a89d;
+  --color-brand-700: #00867d;
+  --color-navy-800: #111d33;
+  --color-navy-900: #0b1528;
+  --color-navy-950: #070e1c;
+}

package/template/sdk/admin.ts

@@ -0,0 +1,95 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/**
+ * Pages d'administration des modules (`entries.admin`, importé via `@snapify/sdk/admin`).
+ * Les composants du back-office (boutons, tableaux, fenêtres, médiathèque…) sont prêtés par
+ * l'administration à l'exécution : une page de module a la même apparence que le reste du back-office.
+ */
+import type { ComponentType } from 'react';
+import type { AdminKit } from '../src/admin/modules/kit';
+
+export interface AdminApi {
+  get: <T = unknown>(path: string) => Promise<T>;
+  post: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+  put: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+  delete: <T = unknown>(path: string) => Promise<T>;
+}
+
+export interface AdminPageProps<S = Record<string, unknown>> {
+  /** Identifiant de la page déclarée dans `adminPages`. */
+  page: string;
+  /** Suite de l'adresse après la page, ex. `/123` pour /administrator/m/<module>/<page>/123. */
+  subpath: string;
+  /** Navigue dans la page du module (`navigate('/123')`) ou vers une autre page (`navigate('/m/<id>/<page>')` avec `absolute`). */
+  navigate: (subpath: string, opts?: { absolute?: boolean }) => void;
+  /** Routes d'administration du module (/api/admin/modules/<id>/api/…). */
+  api: AdminApi;
+  module: { id: string; version: string };
+  /** Réglages complets du module. */
+  settings: S;
+  user: { id: string; name: string; email: string };
+  /** L'utilisateur peut-il modifier les réglages du module ? */
+  canConfigure: boolean;
+}
+
+export interface AdminModule<S = Record<string, unknown>> {
+  pages: Record<string, ComponentType<AdminPageProps<S>>>;
+}
+
+export function defineAdminModule<S = Record<string, unknown>>(mod: AdminModule<S>): AdminModule<S> {
+  return mod;
+}
+
+const kit = (globalThis as { __SNAPIFY_ADMIN__?: AdminKit }).__SNAPIFY_ADMIN__ ?? ({} as AdminKit);
+
+export const {
+  Alert,
+  Badge,
+  Button,
+  Card,
+  cx,
+  Drawer,
+  Dropdown,
+  DropdownItem,
+  EmptyState,
+  ErrorState,
+  Field,
+  ImageField,
+  Input,
+  MediaPicker,
+  Modal,
+  PageHeader,
+  PageSkeleton,
+  Pagination,
+  RichTextEditor,
+  Section,
+  Segmented,
+  Select,
+  Skeleton,
+  Spinner,
+  StatCard,
+  Switch,
+  Table,
+  Tabs,
+  TagInput,
+  Td,
+  Textarea,
+  Th,
+  toast,
+  useAsync,
+  useConfirm,
+  useDebounced,
+  usePagination,
+  usePaging,
+  errorMessage,
+  fmtDate,
+  fmtDateTime,
+  fmtNumber,
+  timeAgo,
+  slugify,
+  downloadCsv,
+} = kit;