@tachui/core 0.7.0-alpha1 → 0.8.0-alpha

package/dist/plugins/index.js

@@ -1,34 +1,395 @@
-import { SimplifiedPluginManager as i } from "./simplified-plugin-manager.js";
-import { SimplifiedComponentRegistry as l } from "./simplified-component-registry.js";
-import { SimplifiedTachUIInstance as n, globalTachUIInstance as t, installPlugin as g, registerComponent as m, registerService as p } from "./simplified-tachui-instance.js";
-import { PluginError as u } from "./simplified-types.js";
-import { PluginDevUtils as f, compareSemver as c, normalizePluginName as s, validatePluginName as L, validateSemver as x } from "./simplified-utils.js";
-import { OptimizedLazyPluginLoader as z, OptimizedLazyPluginLoader as S, createLazyPlugin as v } from "./simplified-lazy-loader.js";
-import { ErrorRecoveryUtils as I, OptimizedPluginErrorHandler as U, SimplifiedPluginErrorHandler as H, globalPluginErrorHandler as O } from "./simplified-error-handler.js";
-import { adaptPlugin as h, createLegacyPluginAdapter as C, isLegacyPlugin as N } from "./legacy-adapter.js";
+var P = Object.defineProperty, w = (s, e, t) => e in s ? P(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, h = (s, e, t) => w(s, typeof e != "symbol" ? e + "" : e, t);
+let c = class extends Error {
+  constructor(e, t) {
+    super(e), this.code = t, this.name = "PluginError";
+  }
+};
+class y {
+  constructor(e) {
+    h(this, "plugins", /* @__PURE__ */ new Map()), h(this, "instance"), this.instance = e;
+  }
+  async install(e) {
+    this.validatePluginBasics(e), await e.install(this.instance), this.plugins.set(e.name, e), console.log(`✅ Plugin "${e.name}" v${e.version} installed successfully`);
+  }
+  async uninstall(e) {
+    const t = this.plugins.get(e);
+    if (!t)
+      throw new c(`Plugin "${e}" is not installed`);
+    this.plugins.delete(e);
+    try {
+      t.uninstall && await t.uninstall(), console.log(`🗑️ Plugin "${e}" uninstalled successfully`);
+    } catch (n) {
+      throw console.log(`🗑️ Plugin "${e}" uninstalled successfully (cleanup failed)`), n;
+    }
+  }
+  isInstalled(e) {
+    return this.plugins.has(e);
+  }
+  getInstalledPlugins() {
+    return Array.from(this.plugins.keys());
+  }
+  getPlugin(e) {
+    return this.plugins.get(e);
+  }
+  getAllPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  validatePluginBasics(e) {
+    if (!e.name || typeof e.name != "string")
+      throw new c("Plugin must have a valid name string", "INVALID_NAME");
+    if (!e.version || typeof e.version != "string")
+      throw new c("Plugin must have a valid version string", "INVALID_VERSION");
+    if (!e.install || typeof e.install != "function")
+      throw new c("Plugin must have an install function", "INVALID_INSTALL");
+    this.plugins.has(e.name) && console.warn(`Plugin "${e.name}" is already installed, overwriting`);
+  }
+}
+var $ = Object.defineProperty, _ = (s, e, t) => e in s ? $(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, E = (s, e, t) => _(s, e + "", t);
+class I {
+  constructor() {
+    E(this, "components", /* @__PURE__ */ new Map());
+  }
+  register(e) {
+    if (!e.name || typeof e.name != "string")
+      throw new Error("Component registration must have a valid name");
+    if (!e.component || typeof e.component != "function")
+      throw new Error("Component registration must have a valid component function");
+    this.components.has(e.name) && console.warn(`Component ${e.name} already registered, overwriting`), this.components.set(e.name, e), console.log(`📦 Component "${e.name}" registered${e.category ? ` (${e.category})` : ""}`);
+  }
+  get(e) {
+    return this.components.get(e);
+  }
+  getComponent(e) {
+    return this.components.get(e)?.component;
+  }
+  has(e) {
+    return this.components.has(e);
+  }
+  list() {
+    return Array.from(this.components.values());
+  }
+  listByCategory(e) {
+    return this.list().filter((t) => t.category === e);
+  }
+  listByPlugin(e) {
+    return this.list().filter((t) => t.plugin === e);
+  }
+  unregister(e) {
+    const t = this.components.has(e);
+    return this.components.delete(e), t && console.log(`🗑️ Component "${e}" unregistered`), t;
+  }
+  unregisterByPlugin(e) {
+    const t = [];
+    for (const [n, r] of this.components.entries())
+      r.plugin === e && (this.components.delete(n), t.push(n));
+    return t.length > 0 && console.log(`🗑️ Unregistered ${t.length} components from plugin "${e}": ${t.join(", ")}`), t;
+  }
+  clear() {
+    const e = this.components.size;
+    this.components.clear(), console.log(`🗑️ Cleared ${e} registered components`);
+  }
+  getStats() {
+    const e = {
+      totalComponents: this.components.size,
+      categories: /* @__PURE__ */ new Map(),
+      plugins: /* @__PURE__ */ new Map(),
+      tags: /* @__PURE__ */ new Map()
+    };
+    for (const t of this.components.values()) {
+      const n = t.category || "uncategorized";
+      e.categories.set(n, (e.categories.get(n) || 0) + 1);
+      const r = t.plugin || "core";
+      if (e.plugins.set(r, (e.plugins.get(r) || 0) + 1), t.tags)
+        for (const i of t.tags)
+          e.tags.set(i, (e.tags.get(i) || 0) + 1);
+    }
+    return {
+      totalComponents: e.totalComponents,
+      categories: Object.fromEntries(e.categories),
+      plugins: Object.fromEntries(e.plugins),
+      tags: Object.fromEntries(e.tags)
+    };
+  }
+}
+var M = Object.defineProperty, z = (s, e, t) => e in s ? M(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, u = (s, e, t) => z(s, typeof e != "symbol" ? e + "" : e, t);
+class b {
+  constructor() {
+    u(this, "plugins"), u(this, "components"), u(this, "services"), u(this, "currentInstallingPlugin", null), this.components = new I(), this.services = /* @__PURE__ */ new Map(), this.plugins = new y(this);
+  }
+  registerComponent(e, t, n) {
+    this.components.register({
+      name: e,
+      component: t,
+      category: n?.category,
+      tags: n?.tags,
+      plugin: this.currentInstallingPlugin || void 0
+    });
+  }
+  registerService(e, t) {
+    this.services.has(e) && !this.services.get(e) && console.warn(`Service "${e}" already registered, overwriting`), this.services.set(e, t), console.log(`⚙️ Service "${e}" registered`);
+  }
+  getService(e) {
+    return this.services.get(e);
+  }
+  hasService(e) {
+    return this.services.has(e);
+  }
+  unregisterService(e) {
+    const t = this.services.has(e);
+    return this.services.delete(e), t && console.log(`🗑️ Service "${e}" unregistered`), t;
+  }
+  async installPlugin(e) {
+    this.currentInstallingPlugin = e.name;
+    try {
+      await this.plugins.install(e);
+    } finally {
+      this.currentInstallingPlugin = null;
+    }
+  }
+  async uninstallPlugin(e) {
+    this.components.unregisterByPlugin(e), await this.plugins.uninstall(e);
+  }
+  isPluginInstalled(e) {
+    return this.plugins.isInstalled(e);
+  }
+  getInstalledPlugins() {
+    return this.plugins.getInstalledPlugins();
+  }
+  getStats() {
+    return {
+      plugins: {
+        installed: this.plugins.getInstalledPlugins().length,
+        list: this.plugins.getInstalledPlugins()
+      },
+      components: this.components.getStats(),
+      services: {
+        registered: this.services.size,
+        list: Array.from(this.services.keys())
+      }
+    };
+  }
+  async reset() {
+    const e = this.getInstalledPlugins();
+    for (const t of e)
+      try {
+        await this.uninstallPlugin(t);
+      } catch (n) {
+        console.error(`Failed to uninstall plugin "${t}":`, n);
+      }
+    this.components.clear(), this.services.clear(), console.log("🔄 TachUI instance reset completed");
+  }
+}
+const g = new b();
+function D(s) {
+  return g.installPlugin(s);
+}
+function T(s, e, t) {
+  return g.registerComponent(s, e, t);
+}
+function x(s, e) {
+  return g.registerService(s, e);
+}
+class a extends Error {
+  constructor(e, t) {
+    super(e), this.code = t, this.name = "PluginError";
+  }
+}
+function m(s) {
+  return !s || typeof s != "string" ? !1 : /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(s);
+}
+function R(s, e) {
+  if (!m(s) || !m(e))
+    throw new Error("Invalid semantic version format");
+  const t = (i) => {
+    const [o, d] = i.split("-"), [f, p, v] = o.split(".").map(Number);
+    return { major: f, minor: p, patch: v, prerelease: d };
+  }, n = t(s), r = t(e);
+  return n.major !== r.major ? n.major < r.major ? -1 : 1 : n.minor !== r.minor ? n.minor < r.minor ? -1 : 1 : n.patch !== r.patch ? n.patch < r.patch ? -1 : 1 : n.prerelease && r.prerelease ? n.prerelease < r.prerelease ? -1 : n.prerelease > r.prerelease ? 1 : 0 : n.prerelease && !r.prerelease ? -1 : !n.prerelease && r.prerelease ? 1 : 0;
+}
+function V(s) {
+  return !s || typeof s != "string" ? !1 : /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(s);
+}
+function j(s) {
+  return s.replace(/^@[^/]+\//, "");
+}
+const B = {
+  /**
+   * Logs plugin debug information in development mode
+   */
+  log(s, e, t) {
+    process.env.NODE_ENV === "development" && (console.group(`🔌 [${s}]`), console.log(e), t && console.log("Data:", t), console.groupEnd());
+  },
+  /**
+   * Creates a development-only warning
+   */
+  warn(s, e) {
+    process.env.NODE_ENV === "development" && console.warn(`⚠️  [${s}] ${e}`);
+  }
+};
+var L = Object.defineProperty, A = (s, e, t) => e in s ? L(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, l = (s, e, t) => A(s, typeof e != "symbol" ? e + "" : e, t);
+class F {
+  constructor() {
+    l(this, "loadPromises", /* @__PURE__ */ new Map()), l(this, "loadedPlugins", /* @__PURE__ */ new Map()), l(this, "loadMetrics", /* @__PURE__ */ new Map()), l(this, "maxRetries", 3), l(this, "baseRetryDelay", 100);
+  }
+  // ms
+  async loadPlugin(e) {
+    if (this.loadedPlugins.has(e))
+      return this.recordCacheHit(e), this.loadedPlugins.get(e);
+    if (this.loadPromises.has(e))
+      return this.loadPromises.get(e);
+    const t = this.doLoadPluginWithRetry(e);
+    this.loadPromises.set(e, t);
+    try {
+      const n = await t;
+      return this.loadedPlugins.set(e, n), n;
+    } catch (n) {
+      throw this.loadPromises.delete(e), n;
+    }
+  }
+  async doLoadPluginWithRetry(e, t = 1) {
+    const n = {
+      startTime: performance.now(),
+      attempts: t,
+      success: !1,
+      cacheHit: !1
+    };
+    this.loadMetrics.set(e, n);
+    try {
+      const r = await this.doLoadPlugin(e);
+      return n.endTime = performance.now(), n.duration = n.endTime - n.startTime, n.success = !0, process.env.NODE_ENV === "development" && console.log(`🚀 Plugin "${e}" loaded in ${n.duration.toFixed(2)}ms (attempt ${t})`), r;
+    } catch (r) {
+      if (n.endTime = performance.now(), n.duration = n.endTime - n.startTime, t < this.maxRetries) {
+        const i = this.baseRetryDelay * Math.pow(2, t - 1);
+        return process.env.NODE_ENV === "development" && console.warn(`⚠️ Plugin "${e}" load failed (attempt ${t}), retrying in ${i}ms...`), await this.delay(i), this.doLoadPluginWithRetry(e, t + 1);
+      }
+      throw process.env.NODE_ENV === "development" && console.error(`❌ Plugin "${e}" failed to load after ${t} attempts`), new a(`Failed to load plugin "${e}" after ${t} attempts: ${r}`);
+    }
+  }
+  async doLoadPlugin(e) {
+    try {
+      const t = await import(
+        /* webpackChunkName: "plugin-[request]" */
+        e
+      ), n = t.default || t;
+      if (!n || typeof n != "object")
+        throw new a(`Plugin "${e}" must export a plugin object`);
+      if (!n.name || !n.version || typeof n.install != "function")
+        throw new a(`Plugin "${e}" must have name, version, and install method`);
+      return n;
+    } catch (t) {
+      throw new a(`Dynamic import failed for "${e}": ${t}`);
+    }
+  }
+  recordCacheHit(e) {
+    if (this.loadMetrics.has(e)) {
+      const t = this.loadMetrics.get(e);
+      t.cacheHit = !0;
+    }
+    process.env.NODE_ENV === "development" && console.log(`💾 Plugin "${e}" served from cache`);
+  }
+  delay(e) {
+    return new Promise((t) => setTimeout(t, e));
+  }
+  // Performance monitoring methods
+  isLoading(e) {
+    return this.loadPromises.has(e) && !this.loadedPlugins.has(e);
+  }
+  isLoaded(e) {
+    return this.loadedPlugins.has(e);
+  }
+  getLoadMetrics(e) {
+    return this.loadMetrics.get(e);
+  }
+  getAllMetrics() {
+    return Array.from(this.loadMetrics.entries()).map(([e, t]) => ({
+      plugin: e,
+      metrics: t
+    }));
+  }
+  getPerformanceStats() {
+    const e = this.getAllMetrics(), t = e.filter((o) => o.metrics.success), n = e.filter((o) => !o.metrics.success), r = t.reduce((o, d) => o + (d.metrics.duration || 0), 0), i = t.length > 0 ? r / t.length : 0;
+    return {
+      totalPlugins: e.length,
+      successful: t.length,
+      failed: n.length,
+      cached: this.loadedPlugins.size,
+      averageLoadTime: i,
+      totalLoadTime: r,
+      cacheHitRate: t.length > 0 ? t.filter((o) => o.metrics.cacheHit).length / t.length : 0
+    };
+  }
+  clearCache(e) {
+    e ? (this.loadPromises.delete(e), this.loadedPlugins.delete(e), this.loadMetrics.delete(e)) : (this.loadPromises.clear(), this.loadedPlugins.clear(), this.loadMetrics.clear());
+  }
+  // Memory management
+  unloadPlugin(e) {
+    this.loadPromises.delete(e), this.loadedPlugins.delete(e), process.env.NODE_ENV === "development" && console.log(`🗑️ Plugin "${e}" unloaded from memory`);
+  }
+  getMemoryUsage() {
+    return {
+      loadedPlugins: this.loadedPlugins.size,
+      pendingLoads: this.loadPromises.size,
+      metricsEntries: this.loadMetrics.size,
+      estimatedMemoryKB: this.loadedPlugins.size * 5 + this.loadMetrics.size * 1
+      // rough estimate
+    };
+  }
+}
+function U(s) {
+  return async () => {
+    try {
+      const e = await s(), t = "default" in e ? e.default : e;
+      if (!t || typeof t != "object")
+        throw new a("Plugin module must export a plugin object");
+      if (!t.name || !t.version || typeof t.install != "function")
+        throw new a("Plugin must have name, version, and install method");
+      return t;
+    } catch (e) {
+      throw new a(`Failed to load plugin: ${e}`);
+    }
+  };
+}
+function S(s) {
+  if (!s.metadata)
+    throw new a("Legacy plugin must have metadata property");
+  if (!s.metadata.name || !s.metadata.version)
+    throw new a("Legacy plugin metadata must include name and version");
+  return {
+    name: s.metadata.name,
+    version: s.metadata.version,
+    description: s.metadata.description,
+    async install(e) {
+      process.env.NODE_ENV === "development" && console.warn(`⚠️  Using legacy adapter for plugin "${s.metadata.name}". Consider updating to simplified API.`), await s.initialize(e);
+    },
+    async uninstall() {
+      s.cleanup && await s.cleanup();
+    }
+  };
+}
+function C(s) {
+  return s && typeof s == "object" && s.metadata && typeof s.metadata.name == "string" && typeof s.metadata.version == "string" && typeof s.initialize == "function";
+}
+function H(s) {
+  return C(s) ? S(s) : s;
+}
 export {
-  I as ErrorRecoveryUtils,
-  z as OptimizedLazyPluginLoader,
-  U as OptimizedPluginErrorHandler,
-  f as PluginDevUtils,
-  u as PluginError,
-  l as SimplifiedComponentRegistry,
-  S as SimplifiedLazyPluginLoader,
-  H as SimplifiedPluginErrorHandler,
-  i as SimplifiedPluginManager,
-  n as SimplifiedTachUIInstance,
-  h as adaptPlugin,
-  c as compareSemver,
-  v as createLazyPlugin,
-  C as createLegacyPluginAdapter,
-  O as globalPluginErrorHandler,
-  t as globalTachUIInstance,
-  g as installPlugin,
-  N as isLegacyPlugin,
-  s as normalizePluginName,
-  m as registerComponent,
-  p as registerService,
-  L as validatePluginName,
-  x as validateSemver
+  F as OptimizedLazyPluginLoader,
+  B as PluginDevUtils,
+  a as PluginError,
+  I as SimplifiedComponentRegistry,
+  F as SimplifiedLazyPluginLoader,
+  y as SimplifiedPluginManager,
+  b as SimplifiedTachUIInstance,
+  H as adaptPlugin,
+  R as compareSemver,
+  U as createLazyPlugin,
+  S as createLegacyPluginAdapter,
+  g as globalTachUIInstance,
+  D as installPlugin,
+  C as isLegacyPlugin,
+  j as normalizePluginName,
+  T as registerComponent,
+  x as registerService,
+  V as validatePluginName,
+  m as validateSemver
 };
-//# sourceMappingURL=index.js.map

package/dist/plugins/simplified-index.d.ts

@@ -6,12 +6,11 @@
  */
 export { SimplifiedPluginManager } from './simplified-plugin-manager';
 export { SimplifiedComponentRegistry } from './simplified-component-registry';
-export { SimplifiedTachUIInstance, globalTachUIInstance, installPlugin, registerComponent, registerService } from './simplified-tachui-instance';
-export type { TachUIPlugin, TachUIInstance, ComponentRegistrationOptions, ServiceRegistration } from './simplified-types';
+export { SimplifiedTachUIInstance, globalTachUIInstance, installPlugin, registerComponent, registerService, } from './simplified-tachui-instance';
+export type { TachUIPlugin, TachUIInstance, ComponentRegistrationOptions, ServiceRegistration, } from './simplified-types';
 export { PluginError } from './simplified-types';
 export type { ComponentRegistration } from './simplified-component-registry';
-export { validateSemver, compareSemver, validatePluginName, normalizePluginName, PluginDevUtils } from './simplified-utils';
-export { OptimizedLazyPluginLoader, createLazyPlugin, OptimizedLazyPluginLoader as SimplifiedLazyPluginLoader } from './simplified-lazy-loader';
-export { OptimizedPluginErrorHandler, SimplifiedPluginErrorHandler, globalPluginErrorHandler, ErrorRecoveryUtils } from './simplified-error-handler';
-export { createLegacyPluginAdapter, isLegacyPlugin, adaptPlugin } from './legacy-adapter';
+export { validateSemver, compareSemver, validatePluginName, normalizePluginName, PluginDevUtils, } from './simplified-utils';
+export { OptimizedLazyPluginLoader, createLazyPlugin, OptimizedLazyPluginLoader as SimplifiedLazyPluginLoader, } from './simplified-lazy-loader';
+export { createLegacyPluginAdapter, isLegacyPlugin, adaptPlugin, } from './legacy-adapter';
 //# sourceMappingURL=simplified-index.d.ts.map

package/dist/plugins/simplified-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplified-index.d.ts","sourceRoot":"","sources":["../../src/plugins/simplified-index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAA;AAC7E,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,eAAe,EAChB,MAAM,8BAA8B,CAAA;AAGrC,YAAY,EACV,YAAY,EACZ,cAAc,EACd,4BAA4B,EAC5B,mBAAmB,EACpB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGhD,YAAY,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAG5E,OAAO,EACL,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACf,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAEhB,yBAAyB,IAAI,0BAA0B,EACxD,MAAM,0BAA0B,CAAA;AAGjC,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EACL,yBAAyB,EACzB,cAAc,EACd,WAAW,EACZ,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"simplified-index.d.ts","sourceRoot":"","sources":["../../src/plugins/simplified-index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAA;AAC7E,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,eAAe,GAChB,MAAM,8BAA8B,CAAA;AAGrC,YAAY,EACV,YAAY,EACZ,cAAc,EACd,4BAA4B,EAC5B,mBAAmB,GACpB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGhD,YAAY,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAG5E,OAAO,EACL,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,GACf,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAEhB,yBAAyB,IAAI,0BAA0B,GACxD,MAAM,0BAA0B,CAAA;AAMjC,OAAO,EACL,yBAAyB,EACzB,cAAc,EACd,WAAW,GACZ,MAAM,kBAAkB,CAAA"}