react-doctor-cli-dev 1.0.9 → 1.0.12

package/dashboard/src/router.js

@@ -0,0 +1,77 @@
+// ─────────────────────────────────────────────────────────────
+// js/router.js — hash-based SPA router
+// Maps #hash → page element + init function
+// ─────────────────────────────────────────────────────────────
+
+import { initOverview, initVitals, initIssues, initSuggestions, initHistory } from './pages.js';
+import { closeLightbox } from './utils.js';
+
+const ROUTES = {
+  "overview":    { id: "page-overview",    init: initOverview    },
+  "vitals":      { id: "page-vitals",      init: initVitals      },
+  "issues":      { id: "page-issues",      init: initIssues      },
+  "suggestions": { id: "page-suggestions", init: initSuggestions },
+  "history":     { id: "page-history",     init: initHistory     },
+};
+
+let currentRoute = null;
+
+async function navigate(hash) {
+  const route = ROUTES[hash] || ROUTES["overview"];
+  if (currentRoute === hash) return;
+  currentRoute = hash;
+
+  // Hide all pages
+  document.querySelectorAll(".page-content").forEach(el => el.classList.remove("active"));
+  // Show target
+  const page = document.getElementById(route.id);
+  if (page) page.classList.add("active");
+
+  // Update nav
+  document.querySelectorAll(".nav-item").forEach(el => {
+    el.classList.toggle("active", el.dataset.route === hash);
+  });
+
+  // Update topbar
+  const titles = {
+    overview:    ["Overview",    "Performance summary"],
+    vitals:      ["Web Vitals",  "Core Web Vitals per route & device"],
+    issues:      ["Code Issues", "Static analysis results"],
+    suggestions: ["Suggestions", "Rule engine recommendations"],
+    history:     ["History",     "Previous analysis runs"],
+  };
+  const [title, sub] = titles[hash] || titles.overview;
+  document.getElementById("topbar-title").textContent = title;
+  document.getElementById("topbar-sub").textContent   = sub;
+
+  // Run page init (await it!)
+  try {
+    await route.init();
+  } catch (err) {
+    console.error('Error initializing page:', err);
+  }
+}
+
+export function initRouter() {
+  // Nav clicks
+  document.querySelectorAll(".nav-item[data-route]").forEach(btn => {
+    btn.addEventListener("click", () => {
+      window.location.hash = btn.dataset.route;
+    });
+  });
+
+  // Hash change
+  window.addEventListener("hashchange", () => {
+    navigate(location.hash.replace("#", "") || "overview");
+  });
+
+  // Lightbox close
+  document.getElementById("lightbox").addEventListener("click", e => {
+    if (e.target === e.currentTarget) closeLightbox();
+  });
+  document.getElementById("lb-close").addEventListener("click", closeLightbox);
+  document.addEventListener("keydown", e => { if (e.key === "Escape") closeLightbox(); });
+
+  // Initial route
+  navigate(location.hash.replace("#", "") || "overview");
+}

package/dashboard/src/utils.js

@@ -0,0 +1,163 @@
+// ─────────────────────────────────────────────────────────────
+// js/utils.js — pure helper functions used across all pages
+// ─────────────────────────────────────────────────────────────
+
+export function scoreColor(score) {
+  if (score >= 90) return "var(--green)";
+  if (score >= 75) return "var(--blue)";
+  if (score >= 50) return "var(--orange)";
+  return "var(--red)";
+}
+
+export function gradeBadgeClass(grade) {
+  const g = grade ? grade[0] : 'N';
+  if (g === "A") return "grade-a";
+  if (g === "B") return "grade-b";
+  if (g === "C") return "grade-c";
+  if (g === "D") return "grade-d";
+  return "grade-d";
+}
+
+export function severityIcon(severity) {
+  return { critical: "🔴", warning: "🟠", info: "🔵" }[severity] || "⚪";
+}
+
+export function severityLabel(sev) {
+  return `<span class="badge ${sev}">${severityIcon(sev)} ${sev}</span>`;
+}
+
+// Vital thresholds: [good_max, warn_max]  (above warn_max = bad)
+const VITAL_THRESHOLDS = {
+  lcp:  [2500,  4000],
+  fcp:  [1800,  3000],
+  ttfb: [800,   1800],
+  inp:  [200,   500],
+  cls:  [0.1,   0.25],
+  render: [2000, 4000], // ← Added Render Time threshold
+};
+
+export function vitalClass(metric, value) {
+  const [good, warn] = VITAL_THRESHOLDS[metric] || [Infinity, Infinity];
+  if (value <= good) return "good";
+  if (value <= warn) return "warn";
+  return "bad";
+}
+
+export function vitalColor(metric, value) {
+  const cls = vitalClass(metric, value);
+  return cls === "good" ? "var(--green)" : cls === "warn" ? "var(--orange)" : "var(--red)";
+}
+
+// Percentage fill for the bar — capped to 100%
+export function vitalBarPct(metric, value) {
+  const limits = { 
+    lcp: 5000, 
+    fcp: 4000, 
+    ttfb: 2500, 
+    inp: 600, 
+    cls: 0.35, 
+    render: 6000  // ← Added Render Time limit
+  };
+  const max = limits[metric] || 100;
+  return Math.min((value / max) * 100, 100).toFixed(1);
+}
+
+export function formatMs(ms) {
+  if (ms === undefined || ms === null) return "–";
+  if (ms >= 1000) return (ms / 1000).toFixed(2) + "s";
+  return ms.toFixed(0) + "ms";
+}
+
+export function formatCls(v) {
+  return typeof v === "number" ? v.toFixed(3) : "–";
+}
+
+export function formatDate(iso) {
+  if (!iso) return "–";
+  const d = new Date(iso);
+  return d.toLocaleDateString("en-GB", { day: "2-digit", month: "short", year: "numeric" }) +
+    "  " + d.toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
+}
+
+export function relativeTime(iso) {
+  if (!iso) return "";
+  const diff = Date.now() - new Date(iso).getTime();
+  const m = Math.floor(diff / 60000);
+  if (m < 1)   return "just now";
+  if (m < 60)  return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24)  return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+
+// ── Build the SVG score ring with VISIBLE text ──────────────
+export function buildScoreRing(score, size = 140, strokeWidth = 10) {
+  const r = (size - strokeWidth) / 2;
+  const c = size / 2;
+  const circ = 2 * Math.PI * r;
+  const pct = Math.min(Math.max(score / 100, 0), 1);
+  const color = scoreColor(score);
+
+  // Map score to a color for the text
+  let textColor;
+  if (score >= 90) textColor = '#3FB950';      // green
+  else if (score >= 75) textColor = '#58A6FF'; // blue
+  else if (score >= 50) textColor = '#F0883E'; // orange
+  else textColor = '#FF7B72';                   // red
+
+  return `
+    <div class="score-ring" style="width:${size}px;height:${size}px;position:relative;flex-shrink:0;">
+      <svg width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" style="transform:rotate(-90deg);display:block;">
+        <circle 
+          cx="${c}" cy="${c}" r="${r}" 
+          fill="none" 
+          stroke="#1C2333" 
+          stroke-width="${strokeWidth}" />
+        <circle 
+          cx="${c}" cy="${c}" r="${r}" 
+          fill="none" 
+          stroke="${textColor}" 
+          stroke-width="${strokeWidth}" 
+          stroke-linecap="round"
+          stroke-dasharray="${circ}"
+          stroke-dashoffset="${circ * (1 - pct)}"
+          style="transition: stroke-dashoffset 1.4s cubic-bezier(.4,0,.2,1);" />
+      </svg>
+      <div style="position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);text-align:center;pointer-events:none;width:100%;z-index:10;">
+        <div style="font-size:2.4rem;font-weight:700;font-family:'JetBrains Mono',monospace;line-height:1;color:${textColor};text-shadow:0 0 20px rgba(0,0,0,0.5);">${Math.round(score)}</div>
+        <div style="font-size:0.7rem;font-weight:600;color:#8B949E;margin-top:2px;">/ 100</div>
+      </div>
+    </div>
+  `;
+}
+
+// Vital bar row HTML
+export function buildVitalRow(label, metric, value) {
+  const display = metric === "cls" ? formatCls(value) : formatMs(value);
+  const color   = vitalColor(metric, value);
+  const pct     = vitalBarPct(metric, value);
+  return `
+    <div class="vital-row">
+      <div class="vital-row-head">
+        <span class="vname">${label}</span>
+        <span class="vval" style="color:${color}">${display}</span>
+      </div>
+      <div class="vital-track">
+        <div class="vital-fill" style="width:${pct}%;background:${color}"></div>
+      </div>
+    </div>`;
+}
+
+// Lightbox
+export function openLightbox(src, caption) {
+  const lb = document.getElementById("lightbox");
+  const img = lb.querySelector("img");
+  if (img) img.src = src;
+  const cap = document.getElementById("lb-caption");
+  if (cap) cap.textContent = caption || "";
+  lb.classList.add("open");
+}
+
+export function closeLightbox() {
+  document.getElementById("lightbox").classList.remove("open");
+}

package/dashboard/vite.config.js

@@ -0,0 +1,19 @@
+import { defineConfig } from 'vite';
+import path from 'path';
+
+export default defineConfig({
+  root: '.',
+  base: '/',
+  build: {
+    outDir: '../backend/public',   // Express serves this as static
+    emptyOutDir: true,
+  },
+  server: {
+    port: 5173,
+    proxy: {
+      // Forward /api/* and /screenshots/* to the backend during dev
+      '/api':         'http://localhost:3000',
+      '/screenshots': 'http://localhost:3000',
+    },
+  },
+});

package/package.json

@@ -1,25 +1,19 @@
 {
   "name": "react-doctor-cli-dev",
-  "version": "1.0.9",
-  "description": "React performance analyzer with static analysis, runtime profiling, rule engine, and dashboard",
+  "version": "1.0.12",
+  "description": "React performance analyzer with static analysis, runtime profiling, rule engine, and dashboard upload",
   "main": "index.js",
   "type": "commonjs",
   "bin": {
     "react-doctor": "./cli/bin/react-doctor.js"
   },
-  "scripts": {
-    "postinstall": "node scripts/postinstall.js",
-    "build": "node scripts/build.js",
-    "dev": "node scripts/dev.js"
-  },
+  "scripts": {},
   "keywords": [
     "react",
     "performance",
     "profiler",
     "cli",
-    "analyzer",
-    "dashboard",
-    "web-vitals"
+    "analyzer"
   ],
   "author": "Ozma",
   "license": "ISC",
@@ -54,17 +48,5 @@
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.9.1",
     "nodemon": "^3.1.14"
-  },
-  "files": [
-    "cli/**/*",
-    "backend/**/*",
-    "frontend/dist/**/*",
-    "core/**/*",
-    "scripts/**/*",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
   }
 }

package/shared/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './schemas';

package/shared/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Exporting all types in one common used file
+__exportStar(require("./types"), exports);
+__exportStar(require("./schemas"), exports);

package/shared/dist/schemas.d.ts

@@ -0,0 +1,91 @@
+import * as v from 'valibot';
+
+export declare const WebVitalsSchema: v.ObjectSchema<{
+    readonly lcp: v.NumberSchema<undefined>;
+    readonly fcp: v.NumberSchema<undefined>;
+    readonly cls: v.NumberSchema<undefined>;
+    readonly inp: v.NumberSchema<undefined>;
+    readonly ttfb: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const ComponentIssueSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly component: v.StringSchema<undefined>;
+    readonly file: v.StringSchema<undefined>;
+    readonly line: v.NumberSchema<undefined>;
+    readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+    readonly message: v.StringSchema<undefined>;
+    readonly suggestion: v.StringSchema<undefined>;
+}, undefined>;
+export declare const StaticReportSchema: v.ObjectSchema<{
+    readonly timestamp: v.StringSchema<undefined>;
+    readonly issues: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly component: v.StringSchema<undefined>;
+        readonly file: v.StringSchema<undefined>;
+        readonly line: v.NumberSchema<undefined>;
+        readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+        readonly message: v.StringSchema<undefined>;
+        readonly suggestion: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly bundleSize: v.NumberSchema<undefined>;
+    readonly componentCount: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const RuntimeReportSchema: v.ObjectSchema<{
+    readonly timestamp: v.StringSchema<undefined>;
+    readonly metrics: v.ObjectSchema<{
+        readonly lcp: v.NumberSchema<undefined>;
+        readonly fcp: v.NumberSchema<undefined>;
+        readonly cls: v.NumberSchema<undefined>;
+        readonly inp: v.NumberSchema<undefined>;
+        readonly ttfb: v.NumberSchema<undefined>;
+    }, undefined>;
+    readonly rerenders: v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>;
+    readonly commitDurations: v.ArraySchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export declare const SuggestionSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly title: v.StringSchema<undefined>;
+    readonly description: v.StringSchema<undefined>;
+    readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+    readonly affectedComponent: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly fix: v.StringSchema<undefined>;
+}, undefined>;
+export declare const FinalReportSchema: v.ObjectSchema<{
+    readonly projectName: v.StringSchema<undefined>;
+    readonly analyzedAt: v.StringSchema<undefined>;
+    readonly static: v.ObjectSchema<{
+        readonly timestamp: v.StringSchema<undefined>;
+        readonly issues: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly component: v.StringSchema<undefined>;
+            readonly file: v.StringSchema<undefined>;
+            readonly line: v.NumberSchema<undefined>;
+            readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+            readonly message: v.StringSchema<undefined>;
+            readonly suggestion: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly bundleSize: v.NumberSchema<undefined>;
+        readonly componentCount: v.NumberSchema<undefined>;
+    }, undefined>;
+    readonly runtime: v.ObjectSchema<{
+        readonly timestamp: v.StringSchema<undefined>;
+        readonly metrics: v.ObjectSchema<{
+            readonly lcp: v.NumberSchema<undefined>;
+            readonly fcp: v.NumberSchema<undefined>;
+            readonly cls: v.NumberSchema<undefined>;
+            readonly inp: v.NumberSchema<undefined>;
+            readonly ttfb: v.NumberSchema<undefined>;
+        }, undefined>;
+        readonly rerenders: v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>;
+        readonly commitDurations: v.ArraySchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly suggestions: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly description: v.StringSchema<undefined>;
+        readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+        readonly affectedComponent: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly fix: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly performanceScore: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 100, undefined>]>;
+}, undefined>;

package/shared/dist/schemas.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalReportSchema = exports.SuggestionSchema = exports.RuntimeReportSchema = exports.StaticReportSchema = exports.ComponentIssueSchema = exports.WebVitalsSchema = void 0;
+const v = __importStar(require("valibot"));
+// Valibot schemas for validation
+exports.WebVitalsSchema = v.object({
+    lcp: v.number(),
+    fcp: v.number(),
+    cls: v.number(),
+    inp: v.number(),
+    ttfb: v.number(),
+});
+exports.ComponentIssueSchema = v.object({
+    id: v.string(),
+    component: v.string(),
+    file: v.string(),
+    line: v.number(),
+    severity: v.picklist(['critical', 'warning', 'info']),
+    message: v.string(),
+    suggestion: v.string(),
+});
+exports.StaticReportSchema = v.object({
+    timestamp: v.string(),
+    issues: v.array(exports.ComponentIssueSchema),
+    bundleSize: v.number(),
+    componentCount: v.number(),
+});
+exports.RuntimeReportSchema = v.object({
+    timestamp: v.string(),
+    metrics: exports.WebVitalsSchema,
+    rerenders: v.record(v.string(), v.number()),
+    commitDurations: v.array(v.number()),
+});
+exports.SuggestionSchema = v.object({
+    id: v.string(),
+    title: v.string(),
+    description: v.string(),
+    severity: v.picklist(['critical', 'warning', 'info']),
+    affectedComponent: v.optional(v.string()),
+    fix: v.string(),
+});
+exports.FinalReportSchema = v.object({
+    projectName: v.string(),
+    analyzedAt: v.string(),
+    static: exports.StaticReportSchema,
+    runtime: exports.RuntimeReportSchema,
+    suggestions: v.array(exports.SuggestionSchema),
+    performanceScore: v.pipe(v.number(), v.minValue(0), v.maxValue(100)),
+});

package/shared/dist/types.d.ts

@@ -0,0 +1,44 @@
+export interface WebVitals {
+    lcp: number;
+    fcp: number;
+    cls: number;
+    inp: number;
+    ttfb: number;
+}
+export interface ComponentIssue {
+    id: string;
+    component: string;
+    file: string;
+    line: number;
+    severity: "critical" | "warning" | "info";
+    message: string;
+    suggestion: string;
+}
+export interface StaticReport {
+    timestamp: string;
+    issues: ComponentIssue[];
+    bundleSize: number;
+    componentCount: number;
+}
+export interface RuntimeReport {
+    timestamp: string;
+    metrics: WebVitals;
+    rerenders: Record<string, number>;
+    commitDurations: number[];
+}
+export interface Suggestion {
+    id: string;
+    title: string;
+    description: string;
+    severity: "critical" | "warning" | "info";
+    affectedComponent?: string;
+    fix: string;
+}
+export interface FinalReport {
+    projectName: string;
+    analyzedAt: string;
+    static: StaticReport;
+    runtime: RuntimeReport;
+    suggestions: Suggestion[];
+    performanceScore: number;
+}

package/shared/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/shared/package-lock.json

@@ -0,0 +1,47 @@
+{
+  "name": "shared",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "shared",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "valibot": "^1.2.0"
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/valibot": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.2.0.tgz",
+      "integrity": "sha512-mm1rxUsmOxzrwnX5arGS+U4T25RdvpPjPN4yR0u9pUBov9+zGVtO84tif1eY4r6zWxVxu3KzIyknJy3rxfRZZg==",
+      "license": "MIT",
+      "peerDependencies": {
+        "typescript": ">=5"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package/shared/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "shared",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "valibot": "^1.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/shared/src/index.ts

@@ -0,0 +1,4 @@
+
+// Exporting all types 
+export * from './types';
+export * from './schemas';