@tachui/core 0.7.0-alpha1

package/dist/reactive/migration.js

@@ -0,0 +1,164 @@
+import { createComputed as d } from "./computed.js";
+import { createEnhancedEffect as l } from "./enhanced-effect.js";
+import { createEnhancedSignal as u } from "./enhanced-signal.js";
+import { shallowEquals as f, deepEquals as m } from "./equality.js";
+import { createSignal as g } from "./signal.js";
+import { ReactiveScheduler as c } from "./unified-scheduler.js";
+let i = !0, a = {
+  signalsConverted: 0,
+  computedsConverted: 0,
+  effectsConverted: 0,
+  errorsFixed: 0
+};
+function w(t) {
+  return i && console.warn(
+    "createLegacySignal is deprecated. Use createSignal() or createEnhancedSignal() instead. See: https://docs.tachui.dev/migration/reactive-system"
+  ), a.signalsConverted++, g(t);
+}
+function p(t, e) {
+  const o = t[0]();
+  let r;
+  switch (e?.equals) {
+    case "deep":
+      r = m;
+      break;
+    case "shallow":
+      r = f;
+      break;
+    case "custom":
+      r = e.customEquals;
+      break;
+    default:
+      r = void 0;
+  }
+  return a.signalsConverted++, u(o, {
+    equals: r,
+    priority: e?.priority,
+    debugName: e?.debugName
+  });
+}
+function R(t) {
+  const e = t(), o = [];
+  let r = "enhanced";
+  return typeof e == "object" && e !== null && (Array.isArray(e) ? (o.push("Consider using deepEquals for array values to detect mutations"), o.push("Use createDeepSignal() for automatic deep comparison"), r = "deep") : (o.push("Consider using shallowEquals for object values with simple properties"), o.push("Use createShallowSignal() for automatic shallow comparison"), r = "shallow")), o.length === 0 && o.push("Signal looks good for reference equality"), { recommendations: o, suggestedMigration: r };
+}
+function U(t) {
+  const e = {
+    signals: [],
+    computeds: [],
+    effects: [],
+    cleanup: () => {
+    }
+  };
+  t.signals && (e.signals = t.signals.map(
+    ({ original: r, options: n }) => p(r, n)
+  )), t.computeds && (e.computeds = t.computeds.map(({ original: r, options: n }) => (a.computedsConverted++, d(r, n))));
+  const o = [];
+  return t.effects && t.effects.forEach(({ original: r, options: n }) => {
+    a.effectsConverted++;
+    const s = l(r, n);
+    o.push(s);
+  }), e.cleanup = () => {
+    o.forEach((r) => r());
+  }, e;
+}
+function $(t) {
+  const e = [];
+  let o = t;
+  return [
+    {
+      from: /createSignal\(/g,
+      to: "createEnhancedSignal(",
+      description: "Upgraded createSignal to createEnhancedSignal"
+    },
+    {
+      from: /createComputed\(([^,]+)\)/g,
+      to: "createComputed($1, { debugName: 'computed' })",
+      description: "Added debug name to createComputed"
+    },
+    {
+      from: /createEffect\(([^,]+)\)/g,
+      to: "createEnhancedEffect($1, { debugName: 'effect' })",
+      description: "Upgraded createEffect to createEnhancedEffect with debug name"
+    }
+  ].forEach((n) => {
+    o.match(n.from) && (o = o.replace(n.from, n.to), e.push(n.description));
+  }), { newCode: o, transformations: e };
+}
+function h() {
+  const t = c.getInstance(), e = t.getPerformanceMetrics(), o = [];
+  let r = 100;
+  return e.errorCount > 0 && (o.push(`Fix ${e.errorCount} reactive errors for better stability`), r -= e.errorCount * 5), e.averageUpdateTime > 16 && (o.push("Update times exceed 16ms - consider optimizing computations"), r -= 20), e.totalNodes > 1e3 && (o.push("High number of reactive nodes - consider batching updates"), r -= 10), {
+    scheduler: t.getDebugInfo(),
+    signals: {
+      total: a.signalsConverted,
+      recommendations: ["Use appropriate equality functions for your data types"]
+    },
+    computeds: {
+      total: a.computedsConverted,
+      recommendations: ["Add error recovery for critical computations"]
+    },
+    effects: {
+      total: a.effectsConverted,
+      recommendations: ["Use appropriate priorities for different effect types"]
+    },
+    overallScore: Math.max(0, r),
+    recommendations: o
+  };
+}
+function q(t = { verbose: !1 }) {
+  const e = c.getInstance(), o = (n) => {
+    console.error("🔥 Reactive System Error:", n), a.errorsFixed++;
+  }, r = e.onError(o);
+  return t.verbose && (console.log("🔍 Reactive debugging enabled"), console.log("📊 Migration stats:", a)), () => {
+    r(), t.verbose && console.log("🔍 Reactive debugging disabled");
+  };
+}
+function x() {
+  return { ...a };
+}
+function M() {
+  a = {
+    signalsConverted: 0,
+    computedsConverted: 0,
+    effectsConverted: 0,
+    errorsFixed: 0
+  };
+}
+function F(t) {
+  i = t;
+}
+function I() {
+  const t = h();
+  return `
+# TachUI Reactive System Migration Report
+
+## Statistics
+- Signals converted: ${a.signalsConverted}
+- Computeds converted: ${a.computedsConverted}
+- Effects converted: ${a.effectsConverted}
+- Errors fixed: ${a.errorsFixed}
+
+## Performance Score: ${t.overallScore}/100
+
+## Recommendations
+${t.recommendations.map((e) => `- ${e}`).join(`
+`)}
+
+## Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+}
+export {
+  h as analyzeReactivePerformance,
+  R as analyzeSignalUsage,
+  w as createLegacySignal,
+  I as createMigrationReport,
+  q as enableReactiveDebugging,
+  x as getMigrationStats,
+  U as migrateBatch,
+  $ as migrateReactiveCode,
+  p as migrateToEnhancedSignal,
+  M as resetMigrationStats,
+  F as setMigrationWarnings
+};
+//# sourceMappingURL=migration.js.map

package/dist/reactive/migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.js","sources":["../../src/reactive/migration.ts"],"sourcesContent":["/**\n * Migration Utilities for Reactive System v2.0\n *\n * Provides backward compatibility and migration tools for transitioning\n * from the old reactive system to the new unified scheduler system.\n */\n\nimport { createComputed } from './computed'\nimport { createEnhancedEffect } from './enhanced-effect'\nimport { createEnhancedSignal } from './enhanced-signal'\nimport { deepEquals, shallowEquals } from './equality'\nimport { createSignal } from './signal'\nimport { ReactiveScheduler, type UpdatePriority } from './unified-scheduler'\n\n/**\n * Migration status tracking\n */\nlet migrationWarningsEnabled = true\nlet migrationStats = {\n  signalsConverted: 0,\n  computedsConverted: 0,\n  effectsConverted: 0,\n  errorsFixed: 0,\n}\n\n/**\n * Legacy compatibility wrapper for signals\n */\nexport function createLegacySignal<T>(value: T): any {\n  if (migrationWarningsEnabled) {\n    console.warn(\n      'createLegacySignal is deprecated. Use createSignal() or createEnhancedSignal() instead. ' +\n        'See: https://docs.tachui.dev/migration/reactive-system'\n    )\n  }\n  migrationStats.signalsConverted++\n  return createSignal(value)\n}\n\n/**\n * Migrate existing signals to enhanced signals with options\n */\nexport function migrateToEnhancedSignal<T>(\n  originalSignal: [() => T, (value: T) => T],\n  options?: {\n    equals?: 'reference' | 'deep' | 'shallow' | 'custom'\n    customEquals?: (a: T, b: T) => boolean\n    priority?: UpdatePriority\n    debugName?: string\n  }\n): [() => T, (value: T) => T] {\n  const currentValue = originalSignal[0]()\n\n  let equalsFn\n  switch (options?.equals) {\n    case 'deep':\n      equalsFn = deepEquals\n      break\n    case 'shallow':\n      equalsFn = shallowEquals\n      break\n    case 'custom':\n      equalsFn = options.customEquals\n      break\n    default:\n      equalsFn = undefined // Use default\n  }\n\n  migrationStats.signalsConverted++\n\n  return createEnhancedSignal(currentValue, {\n    equals: equalsFn,\n    priority: options?.priority,\n    debugName: options?.debugName,\n  })\n}\n\n/**\n * Automatically detect and suggest signal migration improvements\n */\nexport function analyzeSignalUsage<T>(signal: () => T): {\n  recommendations: string[]\n  suggestedMigration: 'enhanced' | 'deep' | 'shallow'\n} {\n  const value = signal()\n  const recommendations: string[] = []\n  let suggestedMigration: 'enhanced' | 'deep' | 'shallow' = 'enhanced'\n\n  if (typeof value === 'object' && value !== null) {\n    if (Array.isArray(value)) {\n      recommendations.push('Consider using deepEquals for array values to detect mutations')\n      recommendations.push('Use createDeepSignal() for automatic deep comparison')\n      suggestedMigration = 'deep'\n    } else {\n      recommendations.push('Consider using shallowEquals for object values with simple properties')\n      recommendations.push('Use createShallowSignal() for automatic shallow comparison')\n      suggestedMigration = 'shallow'\n    }\n  }\n\n  if (recommendations.length === 0) {\n    recommendations.push('Signal looks good for reference equality')\n  }\n\n  return { recommendations, suggestedMigration }\n}\n\n/**\n * Batch migration utility for multiple reactive primitives\n */\nexport function migrateBatch(config: {\n  signals?: Array<{\n    original: [() => any, (value: any) => any]\n    options?: any\n  }>\n  computeds?: Array<{\n    original: () => any\n    options?: any\n  }>\n  effects?: Array<{\n    original: () => undefined | (() => void)\n    options?: any\n  }>\n}): {\n  signals: Array<[() => any, (value: any) => any]>\n  computeds: Array<() => any>\n  effects: Array<() => void>\n  cleanup: () => void\n} {\n  const results = {\n    signals: [] as Array<[() => any, (value: any) => any]>,\n    computeds: [] as Array<() => any>,\n    effects: [] as Array<() => void>,\n    cleanup: () => {},\n  }\n\n  // Migrate signals\n  if (config.signals) {\n    results.signals = config.signals.map(({ original, options }) =>\n      migrateToEnhancedSignal(original, options)\n    )\n  }\n\n  // Migrate computeds\n  if (config.computeds) {\n    results.computeds = config.computeds.map(({ original, options }) => {\n      migrationStats.computedsConverted++\n      return createComputed(original, options)\n    })\n  }\n\n  // Migrate effects with cleanup functions\n  const effectCleanups: Array<() => void> = []\n  if (config.effects) {\n    config.effects.forEach(({ original, options }) => {\n      migrationStats.effectsConverted++\n      const cleanup = createEnhancedEffect(original, options)\n      effectCleanups.push(cleanup)\n    })\n  }\n\n  results.cleanup = () => {\n    effectCleanups.forEach((cleanup) => cleanup())\n  }\n\n  return results\n}\n\n/**\n * Code transformation utility for automatic migration\n */\nexport function migrateReactiveCode(oldCode: string): {\n  newCode: string\n  transformations: string[]\n} {\n  const transformations: string[] = []\n  let newCode = oldCode\n\n  // Basic regex-based transformations\n  const patterns = [\n    {\n      from: /createSignal\\(/g,\n      to: 'createEnhancedSignal(',\n      description: 'Upgraded createSignal to createEnhancedSignal',\n    },\n    {\n      from: /createComputed\\(([^,]+)\\)/g,\n      to: \"createComputed($1, { debugName: 'computed' })\",\n      description: 'Added debug name to createComputed',\n    },\n    {\n      from: /createEffect\\(([^,]+)\\)/g,\n      to: \"createEnhancedEffect($1, { debugName: 'effect' })\",\n      description: 'Upgraded createEffect to createEnhancedEffect with debug name',\n    },\n  ]\n\n  patterns.forEach((pattern) => {\n    const matches = newCode.match(pattern.from)\n    if (matches) {\n      newCode = newCode.replace(pattern.from, pattern.to)\n      transformations.push(pattern.description)\n    }\n  })\n\n  return { newCode, transformations }\n}\n\n/**\n * Performance analyzer for reactive systems\n */\nexport function analyzeReactivePerformance(): {\n  scheduler: any\n  signals: { total: number; recommendations: string[] }\n  computeds: { total: number; recommendations: string[] }\n  effects: { total: number; recommendations: string[] }\n  overallScore: number\n  recommendations: string[]\n} {\n  const scheduler = ReactiveScheduler.getInstance()\n  const metrics = scheduler.getPerformanceMetrics()\n\n  const recommendations: string[] = []\n  let score = 100\n\n  // Analyze metrics\n  if (metrics.errorCount > 0) {\n    recommendations.push(`Fix ${metrics.errorCount} reactive errors for better stability`)\n    score -= metrics.errorCount * 5\n  }\n\n  if (metrics.averageUpdateTime > 16) {\n    recommendations.push('Update times exceed 16ms - consider optimizing computations')\n    score -= 20\n  }\n\n  if (metrics.totalNodes > 1000) {\n    recommendations.push('High number of reactive nodes - consider batching updates')\n    score -= 10\n  }\n\n  return {\n    scheduler: scheduler.getDebugInfo(),\n    signals: {\n      total: migrationStats.signalsConverted,\n      recommendations: ['Use appropriate equality functions for your data types'],\n    },\n    computeds: {\n      total: migrationStats.computedsConverted,\n      recommendations: ['Add error recovery for critical computations'],\n    },\n    effects: {\n      total: migrationStats.effectsConverted,\n      recommendations: ['Use appropriate priorities for different effect types'],\n    },\n    overallScore: Math.max(0, score),\n    recommendations,\n  }\n}\n\n/**\n * Debug utilities for migration\n */\nexport function enableReactiveDebugging(options = { verbose: false }): () => void {\n  const scheduler = ReactiveScheduler.getInstance()\n\n  const errorHandler = (error: any) => {\n    console.error('🔥 Reactive System Error:', error)\n    migrationStats.errorsFixed++\n  }\n\n  const cleanup = scheduler.onError(errorHandler)\n\n  if (options.verbose) {\n    console.log('🔍 Reactive debugging enabled')\n    console.log('📊 Migration stats:', migrationStats)\n  }\n\n  return () => {\n    cleanup()\n    if (options.verbose) {\n      console.log('🔍 Reactive debugging disabled')\n    }\n  }\n}\n\n/**\n * Get migration statistics\n */\nexport function getMigrationStats() {\n  return { ...migrationStats }\n}\n\n/**\n * Reset migration statistics\n */\nexport function resetMigrationStats() {\n  migrationStats = {\n    signalsConverted: 0,\n    computedsConverted: 0,\n    effectsConverted: 0,\n    errorsFixed: 0,\n  }\n}\n\n/**\n * Enable/disable migration warnings\n */\nexport function setMigrationWarnings(enabled: boolean) {\n  migrationWarningsEnabled = enabled\n}\n\n/**\n * Create a migration report\n */\nexport function createMigrationReport(): string {\n  const performance = analyzeReactivePerformance()\n\n  return `\n# TachUI Reactive System Migration Report\n\n## Statistics\n- Signals converted: ${migrationStats.signalsConverted}\n- Computeds converted: ${migrationStats.computedsConverted}\n- Effects converted: ${migrationStats.effectsConverted}\n- Errors fixed: ${migrationStats.errorsFixed}\n\n## Performance Score: ${performance.overallScore}/100\n\n## Recommendations\n${performance.recommendations.map((r) => `- ${r}`).join('\\n')}\n\n## Generated: ${new Date().toISOString()}\n`\n}\n"],"names":["migrationWarningsEnabled","migrationStats","createLegacySignal","value","createSignal","migrateToEnhancedSignal","originalSignal","options","currentValue","equalsFn","deepEquals","shallowEquals","createEnhancedSignal","analyzeSignalUsage","signal","recommendations","suggestedMigration","migrateBatch","config","results","original","createComputed","effectCleanups","cleanup","createEnhancedEffect","migrateReactiveCode","oldCode","transformations","newCode","pattern","analyzeReactivePerformance","scheduler","ReactiveScheduler","metrics","score","enableReactiveDebugging","errorHandler","error","getMigrationStats","resetMigrationStats","setMigrationWarnings","enabled","createMigrationReport","performance","r"],"mappings":";;;;;;AAiBA,IAAIA,IAA2B,IAC3BC,IAAiB;AAAA,EACnB,kBAAkB;AAAA,EAClB,oBAAoB;AAAA,EACpB,kBAAkB;AAAA,EAClB,aAAa;AACf;AAKO,SAASC,EAAsBC,GAAe;AACnD,SAAIH,KACF,QAAQ;AAAA,IACN;AAAA,EAAA,GAIJC,EAAe,oBACRG,EAAaD,CAAK;AAC3B;AAKO,SAASE,EACdC,GACAC,GAM4B;AAC5B,QAAMC,IAAeF,EAAe,CAAC,EAAA;AAErC,MAAIG;AACJ,UAAQF,GAAS,QAAA;AAAA,IACf,KAAK;AACH,MAAAE,IAAWC;AACX;AAAA,IACF,KAAK;AACH,MAAAD,IAAWE;AACX;AAAA,IACF,KAAK;AACH,MAAAF,IAAWF,EAAQ;AACnB;AAAA,IACF;AACE,MAAAE,IAAW;AAAA,EAAA;AAGf,SAAAR,EAAe,oBAERW,EAAqBJ,GAAc;AAAA,IACxC,QAAQC;AAAA,IACR,UAAUF,GAAS;AAAA,IACnB,WAAWA,GAAS;AAAA,EAAA,CACrB;AACH;AAKO,SAASM,EAAsBC,GAGpC;AACA,QAAMX,IAAQW,EAAA,GACRC,IAA4B,CAAA;AAClC,MAAIC,IAAsD;AAE1D,SAAI,OAAOb,KAAU,YAAYA,MAAU,SACrC,MAAM,QAAQA,CAAK,KACrBY,EAAgB,KAAK,gEAAgE,GACrFA,EAAgB,KAAK,sDAAsD,GAC3EC,IAAqB,WAErBD,EAAgB,KAAK,uEAAuE,GAC5FA,EAAgB,KAAK,4DAA4D,GACjFC,IAAqB,aAIrBD,EAAgB,WAAW,KAC7BA,EAAgB,KAAK,0CAA0C,GAG1D,EAAE,iBAAAA,GAAiB,oBAAAC,EAAA;AAC5B;AAKO,SAASC,EAAaC,GAkB3B;AACA,QAAMC,IAAU;AAAA,IACd,SAAS,CAAA;AAAA,IACT,WAAW,CAAA;AAAA,IACX,SAAS,CAAA;AAAA,IACT,SAAS,MAAM;AAAA,IAAC;AAAA,EAAA;AAIlB,EAAID,EAAO,YACTC,EAAQ,UAAUD,EAAO,QAAQ;AAAA,IAAI,CAAC,EAAE,UAAAE,GAAU,SAAAb,QAChDF,EAAwBe,GAAUb,CAAO;AAAA,EAAA,IAKzCW,EAAO,cACTC,EAAQ,YAAYD,EAAO,UAAU,IAAI,CAAC,EAAE,UAAAE,GAAU,SAAAb,SACpDN,EAAe,sBACRoB,EAAeD,GAAUb,CAAO,EACxC;AAIH,QAAMe,IAAoC,CAAA;AAC1C,SAAIJ,EAAO,WACTA,EAAO,QAAQ,QAAQ,CAAC,EAAE,UAAAE,GAAU,SAAAb,QAAc;AAChD,IAAAN,EAAe;AACf,UAAMsB,IAAUC,EAAqBJ,GAAUb,CAAO;AACtD,IAAAe,EAAe,KAAKC,CAAO;AAAA,EAC7B,CAAC,GAGHJ,EAAQ,UAAU,MAAM;AACtB,IAAAG,EAAe,QAAQ,CAACC,MAAYA,EAAA,CAAS;AAAA,EAC/C,GAEOJ;AACT;AAKO,SAASM,EAAoBC,GAGlC;AACA,QAAMC,IAA4B,CAAA;AAClC,MAAIC,IAAUF;AAqBd,SAlBiB;AAAA,IACf;AAAA,MACE,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,aAAa;AAAA,IAAA;AAAA,IAEf;AAAA,MACE,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,aAAa;AAAA,IAAA;AAAA,IAEf;AAAA,MACE,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,aAAa;AAAA,IAAA;AAAA,EACf,EAGO,QAAQ,CAACG,MAAY;AAE5B,IADgBD,EAAQ,MAAMC,EAAQ,IAAI,MAExCD,IAAUA,EAAQ,QAAQC,EAAQ,MAAMA,EAAQ,EAAE,GAClDF,EAAgB,KAAKE,EAAQ,WAAW;AAAA,EAE5C,CAAC,GAEM,EAAE,SAAAD,GAAS,iBAAAD,EAAA;AACpB;AAKO,SAASG,IAOd;AACA,QAAMC,IAAYC,EAAkB,YAAA,GAC9BC,IAAUF,EAAU,sBAAA,GAEpBhB,IAA4B,CAAA;AAClC,MAAImB,IAAQ;AAGZ,SAAID,EAAQ,aAAa,MACvBlB,EAAgB,KAAK,OAAOkB,EAAQ,UAAU,uCAAuC,GACrFC,KAASD,EAAQ,aAAa,IAG5BA,EAAQ,oBAAoB,OAC9BlB,EAAgB,KAAK,6DAA6D,GAClFmB,KAAS,KAGPD,EAAQ,aAAa,QACvBlB,EAAgB,KAAK,2DAA2D,GAChFmB,KAAS,KAGJ;AAAA,IACL,WAAWH,EAAU,aAAA;AAAA,IACrB,SAAS;AAAA,MACP,OAAO9B,EAAe;AAAA,MACtB,iBAAiB,CAAC,wDAAwD;AAAA,IAAA;AAAA,IAE5E,WAAW;AAAA,MACT,OAAOA,EAAe;AAAA,MACtB,iBAAiB,CAAC,8CAA8C;AAAA,IAAA;AAAA,IAElE,SAAS;AAAA,MACP,OAAOA,EAAe;AAAA,MACtB,iBAAiB,CAAC,uDAAuD;AAAA,IAAA;AAAA,IAE3E,cAAc,KAAK,IAAI,GAAGiC,CAAK;AAAA,IAC/B,iBAAAnB;AAAA,EAAA;AAEJ;AAKO,SAASoB,EAAwB5B,IAAU,EAAE,SAAS,MAAqB;AAChF,QAAMwB,IAAYC,EAAkB,YAAA,GAE9BI,IAAe,CAACC,MAAe;AACnC,YAAQ,MAAM,6BAA6BA,CAAK,GAChDpC,EAAe;AAAA,EACjB,GAEMsB,IAAUQ,EAAU,QAAQK,CAAY;AAE9C,SAAI7B,EAAQ,YACV,QAAQ,IAAI,+BAA+B,GAC3C,QAAQ,IAAI,uBAAuBN,CAAc,IAG5C,MAAM;AACX,IAAAsB,EAAA,GACIhB,EAAQ,WACV,QAAQ,IAAI,gCAAgC;AAAA,EAEhD;AACF;AAKO,SAAS+B,IAAoB;AAClC,SAAO,EAAE,GAAGrC,EAAA;AACd;AAKO,SAASsC,IAAsB;AACpC,EAAAtC,IAAiB;AAAA,IACf,kBAAkB;AAAA,IAClB,oBAAoB;AAAA,IACpB,kBAAkB;AAAA,IAClB,aAAa;AAAA,EAAA;AAEjB;AAKO,SAASuC,EAAqBC,GAAkB;AACrD,EAAAzC,IAA2ByC;AAC7B;AAKO,SAASC,IAAgC;AAC9C,QAAMC,IAAcb,EAAA;AAEpB,SAAO;AAAA;AAAA;AAAA;AAAA,uBAIc7B,EAAe,gBAAgB;AAAA,yBAC7BA,EAAe,kBAAkB;AAAA,uBACnCA,EAAe,gBAAgB;AAAA,kBACpCA,EAAe,WAAW;AAAA;AAAA,wBAEpB0C,EAAY,YAAY;AAAA;AAAA;AAAA,EAG9CA,EAAY,gBAAgB,IAAI,CAACC,MAAM,KAAKA,CAAC,EAAE,EAAE,KAAK;AAAA,CAAI,CAAC;AAAA;AAAA,iBAE7C,oBAAI,KAAA,GAAO,YAAA,CAAa;AAAA;AAExC;"}

package/dist/reactive/ownership.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./context.cjs");function o(){return t.getOwner()!==null}function r(e){return t.runWithOwner(null,e)}function i(e){return r(()=>t.createRoot(e))}function u(){let e=t.getOwner();if(!e)return null;for(;e.parent;)e=e.parent;return e}function c(){const e=[];let n=t.getOwner();for(;n;)e.push(n),n=n.parent;return e}exports.createRoot=t.createRoot;exports.runWithOwner=t.runWithOwner;exports.createDetachedRoot=i;exports.getOwnerChain=c;exports.getRootOwner=u;exports.isReactiveContext=o;exports.runOutsideReactiveContext=r;
+//# sourceMappingURL=ownership.cjs.map

package/dist/reactive/ownership.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.cjs","sources":["../../src/reactive/ownership.ts"],"sourcesContent":["/**\n * Ownership and reactive context management\n *\n * Provides utilities for managing reactive ownership contexts,\n * which control the lifecycle of reactive computations.\n */\n\nimport { createRoot, getOwner as getCurrentOwner, runWithOwner } from './context'\nimport type { Owner } from './types'\n\n/**\n * Get the current owner context\n */\nexport function getOwner(): Owner | null {\n  return getCurrentOwner()\n}\n\n/**\n * Run a function with a specific owner context\n */\nexport { runWithOwner }\n\n/**\n * Create a new reactive root context\n */\nexport { createRoot }\n\n/**\n * Check if we're currently in a reactive context\n */\nexport function isReactiveContext(): boolean {\n  return getCurrentOwner() !== null\n}\n\n/**\n * Run a function outside of any reactive context\n */\nexport function runOutsideReactiveContext<T>(fn: () => T): T {\n  return runWithOwner(null, fn)\n}\n\n/**\n * Create a detached reactive context that doesn't inherit from parent\n */\nexport function createDetachedRoot<T>(fn: (dispose: () => void) => T): T {\n  return runOutsideReactiveContext(() => createRoot(fn))\n}\n\n/**\n * Get the root owner of the current ownership chain\n */\nexport function getRootOwner(): Owner | null {\n  let owner = getCurrentOwner()\n  if (!owner) return null\n\n  while (owner.parent) {\n    owner = owner.parent\n  }\n\n  return owner\n}\n\n/**\n * Get all owners in the ownership chain\n */\nexport function getOwnerChain(): (Owner | null)[] {\n  const chain: (Owner | null)[] = []\n  let owner = getCurrentOwner()\n\n  while (owner) {\n    chain.push(owner)\n    owner = owner.parent\n  }\n\n  return chain\n}\n\n/**\n * Check if an owner is an ancestor of another owner\n */\nexport function isOwnerAncestor(ancestor: Owner, descendant: Owner): boolean {\n  let current = descendant.parent\n\n  while (current) {\n    if (current === ancestor) {\n      return true\n    }\n    current = current.parent\n  }\n\n  return false\n}\n\n/**\n * Find the common ancestor of two owners\n */\nexport function findCommonAncestor(owner1: Owner, owner2: Owner): Owner | null {\n  const chain1 = new Set<Owner>()\n  let current: Owner | null = owner1\n\n  // Build chain for owner1\n  while (current) {\n    chain1.add(current)\n    current = current.parent\n  }\n\n  // Walk chain for owner2 and find first common owner\n  current = owner2\n  while (current) {\n    if (chain1.has(current)) {\n      return current\n    }\n    current = current.parent\n  }\n\n  return null\n}\n\n/**\n * Get the depth of an owner in the ownership tree\n */\nexport function getOwnerDepth(owner: Owner): number {\n  let depth = 0\n  let current = owner.parent\n\n  while (current) {\n    depth++\n    current = current.parent\n  }\n\n  return depth\n}\n\n/**\n * Create a child owner context\n */\nexport function createChildOwner(): Owner | null {\n  const parent = getCurrentOwner()\n  if (!parent) return null\n\n  // This would be implemented in the OwnerImpl class\n  // For now, return null as we don't expose the constructor\n  return null\n}\n\n/**\n * Debug utilities for ownership\n */\nexport const OwnershipDebug = {\n  getCurrentOwner,\n  getRootOwner,\n  getOwnerChain,\n  getOwnerDepth,\n  isReactiveContext,\n\n  /**\n   * Get ownership tree information\n   */\n  getOwnershipTree(): object {\n    const root = getRootOwner()\n    if (!root) return { tree: null }\n\n    const buildTree = (owner: Owner): object => ({\n      id: owner.id,\n      disposed: owner.disposed,\n      sourceCount: owner.sources.size,\n      cleanupCount: owner.cleanups.length,\n    })\n\n    return { tree: buildTree(root) }\n  },\n\n  /**\n   * Count total computations in ownership tree\n   */\n  countComputations(): number {\n    const root = getRootOwner()\n    if (!root) return 0\n\n    return root.sources.size\n  },\n}\n"],"names":["isReactiveContext","getCurrentOwner","runOutsideReactiveContext","fn","runWithOwner","createDetachedRoot","createRoot","getRootOwner","owner","getOwnerChain","chain"],"mappings":"iHA8BO,SAASA,GAA6B,CAC3C,OAAOC,EAAAA,aAAsB,IAC/B,CAKO,SAASC,EAA6BC,EAAgB,CAC3D,OAAOC,EAAAA,aAAa,KAAMD,CAAE,CAC9B,CAKO,SAASE,EAAsBF,EAAmC,CACvE,OAAOD,EAA0B,IAAMI,aAAWH,CAAE,CAAC,CACvD,CAKO,SAASI,GAA6B,CAC3C,IAAIC,EAAQP,EAAAA,SAAA,EACZ,GAAI,CAACO,EAAO,OAAO,KAEnB,KAAOA,EAAM,QACXA,EAAQA,EAAM,OAGhB,OAAOA,CACT,CAKO,SAASC,GAAkC,CAChD,MAAMC,EAA0B,CAAA,EAChC,IAAIF,EAAQP,EAAAA,SAAA,EAEZ,KAAOO,GACLE,EAAM,KAAKF,CAAK,EAChBA,EAAQA,EAAM,OAGhB,OAAOE,CACT"}

package/dist/reactive/ownership.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Ownership and reactive context management
+ *
+ * Provides utilities for managing reactive ownership contexts,
+ * which control the lifecycle of reactive computations.
+ */
+import { createRoot, getOwner as getCurrentOwner, runWithOwner } from './context';
+import type { Owner } from './types';
+/**
+ * Get the current owner context
+ */
+export declare function getOwner(): Owner | null;
+/**
+ * Run a function with a specific owner context
+ */
+export { runWithOwner };
+/**
+ * Create a new reactive root context
+ */
+export { createRoot };
+/**
+ * Check if we're currently in a reactive context
+ */
+export declare function isReactiveContext(): boolean;
+/**
+ * Run a function outside of any reactive context
+ */
+export declare function runOutsideReactiveContext<T>(fn: () => T): T;
+/**
+ * Create a detached reactive context that doesn't inherit from parent
+ */
+export declare function createDetachedRoot<T>(fn: (dispose: () => void) => T): T;
+/**
+ * Get the root owner of the current ownership chain
+ */
+export declare function getRootOwner(): Owner | null;
+/**
+ * Get all owners in the ownership chain
+ */
+export declare function getOwnerChain(): (Owner | null)[];
+/**
+ * Check if an owner is an ancestor of another owner
+ */
+export declare function isOwnerAncestor(ancestor: Owner, descendant: Owner): boolean;
+/**
+ * Find the common ancestor of two owners
+ */
+export declare function findCommonAncestor(owner1: Owner, owner2: Owner): Owner | null;
+/**
+ * Get the depth of an owner in the ownership tree
+ */
+export declare function getOwnerDepth(owner: Owner): number;
+/**
+ * Create a child owner context
+ */
+export declare function createChildOwner(): Owner | null;
+/**
+ * Debug utilities for ownership
+ */
+export declare const OwnershipDebug: {
+    getCurrentOwner: typeof getCurrentOwner;
+    getRootOwner: typeof getRootOwner;
+    getOwnerChain: typeof getOwnerChain;
+    getOwnerDepth: typeof getOwnerDepth;
+    isReactiveContext: typeof isReactiveContext;
+    /**
+     * Get ownership tree information
+     */
+    getOwnershipTree(): object;
+    /**
+     * Count total computations in ownership tree
+     */
+    countComputations(): number;
+};
+//# sourceMappingURL=ownership.d.ts.map

package/dist/reactive/ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.d.ts","sourceRoot":"","sources":["../../src/reactive/ownership.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,QAAQ,IAAI,eAAe,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACjF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC;;GAEG;AACH,wBAAgB,QAAQ,IAAI,KAAK,GAAG,IAAI,CAEvC;AAED;;GAEG;AACH,OAAO,EAAE,YAAY,EAAE,CAAA;AAEvB;;GAEG;AACH,OAAO,EAAE,UAAU,EAAE,CAAA;AAErB;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE3D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAEvE;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,KAAK,GAAG,IAAI,CAS3C;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAUhD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,GAAG,OAAO,CAW3E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAoB7E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAUlD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,KAAK,GAAG,IAAI,CAO/C;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;IAOzB;;OAEG;wBACiB,MAAM;IAc1B;;OAEG;yBACkB,MAAM;CAM5B,CAAA"}

package/dist/reactive/ownership.js

@@ -0,0 +1,34 @@
+import { getOwner as n, runWithOwner as r, createRoot as o } from "./context.js";
+function c() {
+  return n() !== null;
+}
+function u(e) {
+  return r(null, e);
+}
+function a(e) {
+  return u(() => o(e));
+}
+function l() {
+  let e = n();
+  if (!e) return null;
+  for (; e.parent; )
+    e = e.parent;
+  return e;
+}
+function w() {
+  const e = [];
+  let t = n();
+  for (; t; )
+    e.push(t), t = t.parent;
+  return e;
+}
+export {
+  a as createDetachedRoot,
+  o as createRoot,
+  w as getOwnerChain,
+  l as getRootOwner,
+  c as isReactiveContext,
+  u as runOutsideReactiveContext,
+  r as runWithOwner
+};
+//# sourceMappingURL=ownership.js.map

package/dist/reactive/ownership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.js","sources":["../../src/reactive/ownership.ts"],"sourcesContent":["/**\n * Ownership and reactive context management\n *\n * Provides utilities for managing reactive ownership contexts,\n * which control the lifecycle of reactive computations.\n */\n\nimport { createRoot, getOwner as getCurrentOwner, runWithOwner } from './context'\nimport type { Owner } from './types'\n\n/**\n * Get the current owner context\n */\nexport function getOwner(): Owner | null {\n  return getCurrentOwner()\n}\n\n/**\n * Run a function with a specific owner context\n */\nexport { runWithOwner }\n\n/**\n * Create a new reactive root context\n */\nexport { createRoot }\n\n/**\n * Check if we're currently in a reactive context\n */\nexport function isReactiveContext(): boolean {\n  return getCurrentOwner() !== null\n}\n\n/**\n * Run a function outside of any reactive context\n */\nexport function runOutsideReactiveContext<T>(fn: () => T): T {\n  return runWithOwner(null, fn)\n}\n\n/**\n * Create a detached reactive context that doesn't inherit from parent\n */\nexport function createDetachedRoot<T>(fn: (dispose: () => void) => T): T {\n  return runOutsideReactiveContext(() => createRoot(fn))\n}\n\n/**\n * Get the root owner of the current ownership chain\n */\nexport function getRootOwner(): Owner | null {\n  let owner = getCurrentOwner()\n  if (!owner) return null\n\n  while (owner.parent) {\n    owner = owner.parent\n  }\n\n  return owner\n}\n\n/**\n * Get all owners in the ownership chain\n */\nexport function getOwnerChain(): (Owner | null)[] {\n  const chain: (Owner | null)[] = []\n  let owner = getCurrentOwner()\n\n  while (owner) {\n    chain.push(owner)\n    owner = owner.parent\n  }\n\n  return chain\n}\n\n/**\n * Check if an owner is an ancestor of another owner\n */\nexport function isOwnerAncestor(ancestor: Owner, descendant: Owner): boolean {\n  let current = descendant.parent\n\n  while (current) {\n    if (current === ancestor) {\n      return true\n    }\n    current = current.parent\n  }\n\n  return false\n}\n\n/**\n * Find the common ancestor of two owners\n */\nexport function findCommonAncestor(owner1: Owner, owner2: Owner): Owner | null {\n  const chain1 = new Set<Owner>()\n  let current: Owner | null = owner1\n\n  // Build chain for owner1\n  while (current) {\n    chain1.add(current)\n    current = current.parent\n  }\n\n  // Walk chain for owner2 and find first common owner\n  current = owner2\n  while (current) {\n    if (chain1.has(current)) {\n      return current\n    }\n    current = current.parent\n  }\n\n  return null\n}\n\n/**\n * Get the depth of an owner in the ownership tree\n */\nexport function getOwnerDepth(owner: Owner): number {\n  let depth = 0\n  let current = owner.parent\n\n  while (current) {\n    depth++\n    current = current.parent\n  }\n\n  return depth\n}\n\n/**\n * Create a child owner context\n */\nexport function createChildOwner(): Owner | null {\n  const parent = getCurrentOwner()\n  if (!parent) return null\n\n  // This would be implemented in the OwnerImpl class\n  // For now, return null as we don't expose the constructor\n  return null\n}\n\n/**\n * Debug utilities for ownership\n */\nexport const OwnershipDebug = {\n  getCurrentOwner,\n  getRootOwner,\n  getOwnerChain,\n  getOwnerDepth,\n  isReactiveContext,\n\n  /**\n   * Get ownership tree information\n   */\n  getOwnershipTree(): object {\n    const root = getRootOwner()\n    if (!root) return { tree: null }\n\n    const buildTree = (owner: Owner): object => ({\n      id: owner.id,\n      disposed: owner.disposed,\n      sourceCount: owner.sources.size,\n      cleanupCount: owner.cleanups.length,\n    })\n\n    return { tree: buildTree(root) }\n  },\n\n  /**\n   * Count total computations in ownership tree\n   */\n  countComputations(): number {\n    const root = getRootOwner()\n    if (!root) return 0\n\n    return root.sources.size\n  },\n}\n"],"names":["isReactiveContext","getCurrentOwner","runOutsideReactiveContext","fn","runWithOwner","createDetachedRoot","createRoot","getRootOwner","owner","getOwnerChain","chain"],"mappings":";AA8BO,SAASA,IAA6B;AAC3C,SAAOC,QAAsB;AAC/B;AAKO,SAASC,EAA6BC,GAAgB;AAC3D,SAAOC,EAAa,MAAMD,CAAE;AAC9B;AAKO,SAASE,EAAsBF,GAAmC;AACvE,SAAOD,EAA0B,MAAMI,EAAWH,CAAE,CAAC;AACvD;AAKO,SAASI,IAA6B;AAC3C,MAAIC,IAAQP,EAAA;AACZ,MAAI,CAACO,EAAO,QAAO;AAEnB,SAAOA,EAAM;AACX,IAAAA,IAAQA,EAAM;AAGhB,SAAOA;AACT;AAKO,SAASC,IAAkC;AAChD,QAAMC,IAA0B,CAAA;AAChC,MAAIF,IAAQP,EAAA;AAEZ,SAAOO;AACL,IAAAE,EAAM,KAAKF,CAAK,GAChBA,IAAQA,EAAM;AAGhB,SAAOE;AACT;"}

package/dist/reactive/scheduler.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var n=Object.defineProperty,o=(e,s,t)=>s in e?n(e,s,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[s]=t,i=(e,s,t)=>o(e,typeof s!="symbol"?s+"":s,t);class d{constructor(){i(this,"pending",new Set),i(this,"isFlushScheduled",!1)}schedule(s){this.pending.add(s),this.isFlushScheduled||(this.isFlushScheduled=!0,queueMicrotask(()=>this.flush()))}flush(){if(this.pending.size===0){this.isFlushScheduled=!1;return}const s=Array.from(this.pending);this.pending.clear(),this.isFlushScheduled=!1;for(const t of s)try{t()}catch(l){console.error("Error in scheduled task:",l)}this.pending.size>0&&(this.isFlushScheduled=!0,queueMicrotask(()=>this.flush()))}}class a{schedule(s){try{s()}catch(t){console.error("Error in sync scheduled task:",t)}}flush(){}}var c=(e=>(e[e.Immediate=0]="Immediate",e[e.High=1]="High",e[e.Normal=2]="Normal",e[e.Low=3]="Low",e[e.Idle=4]="Idle",e))(c||{});class f{constructor(){i(this,"queues",new Map),i(this,"taskIdCounter",0),i(this,"isFlushScheduled",!1);for(const s of Object.values(c))typeof s=="number"&&this.queues.set(s,new Set)}schedule(s,t=2){const l={fn:s,priority:t,id:++this.taskIdCounter},r=this.queues.get(t);r&&r.add(l),this.isFlushScheduled||(this.isFlushScheduled=!0,t===0?this.flush():queueMicrotask(()=>this.flush()))}flush(){this.isFlushScheduled=!1;for(const s of[0,1,2,3,4]){const t=this.queues.get(s);if(!t||t.size===0)continue;const l=Array.from(t).sort((r,h)=>r.id-h.id);t.clear();for(const r of l)try{r.fn()}catch(h){console.error(`Error in priority ${s} task:`,h)}if(t.size===0&&this.hasMoreTasks()){queueMicrotask(()=>this.flush());return}}}hasMoreTasks(){for(const s of this.queues.values())if(s.size>0)return!0;return!1}}let u=new d;function S(){return u}function p(e){u=e}function g(e=!0){e?u=new d:u=new a}function m(e){u.schedule(e)}function q(e,s){u instanceof f?u.schedule(e,s):u.schedule(e)}function b(e){typeof requestIdleCallback<"u"?requestIdleCallback(e):setTimeout(e,0)}exports.TaskPriority=c;exports.enableScheduling=g;exports.getScheduler=S;exports.scheduleIdle=b;exports.scheduleUpdate=m;exports.scheduleWithPriority=q;exports.setScheduler=p;
+//# sourceMappingURL=scheduler.cjs.map

package/dist/reactive/scheduler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.cjs","sources":["../../src/reactive/scheduler.ts"],"sourcesContent":["/**\n * Reactive scheduler for managing update batching and timing\n *\n * Provides utilities for controlling when reactive updates are executed,\n * batching updates for performance, and scheduling priorities.\n */\n\nimport type { Scheduler } from './types'\n\n/**\n * Default scheduler implementation using microtasks\n */\nclass MicrotaskScheduler implements Scheduler {\n  private pending = new Set<() => void>()\n  private isFlushScheduled = false\n\n  schedule(fn: () => void): void {\n    this.pending.add(fn)\n\n    if (!this.isFlushScheduled) {\n      this.isFlushScheduled = true\n      queueMicrotask(() => this.flush())\n    }\n  }\n\n  flush(): void {\n    if (this.pending.size === 0) {\n      this.isFlushScheduled = false\n      return\n    }\n\n    const tasks = Array.from(this.pending)\n    this.pending.clear()\n    this.isFlushScheduled = false\n\n    for (const task of tasks) {\n      try {\n        task()\n      } catch (error) {\n        console.error('Error in scheduled task:', error)\n      }\n    }\n\n    // If new tasks were scheduled during execution, flush again\n    if (this.pending.size > 0) {\n      this.isFlushScheduled = true\n      queueMicrotask(() => this.flush())\n    }\n  }\n}\n\n/**\n * Synchronous scheduler for immediate execution\n */\nclass SyncScheduler implements Scheduler {\n  schedule(fn: () => void): void {\n    try {\n      fn()\n    } catch (error) {\n      console.error('Error in sync scheduled task:', error)\n    }\n  }\n\n  flush(): void {\n    // No-op for sync scheduler\n  }\n}\n\n/**\n * RAF scheduler for animation-friendly updates\n */\nclass RAFScheduler implements Scheduler {\n  private pending = new Set<() => void>()\n  private rafId: number | null = null\n\n  schedule(fn: () => void): void {\n    this.pending.add(fn)\n\n    if (this.rafId === null) {\n      this.rafId = requestAnimationFrame(() => this.flush())\n    }\n  }\n\n  flush(): void {\n    if (this.pending.size === 0) {\n      this.rafId = null\n      return\n    }\n\n    const tasks = Array.from(this.pending)\n    this.pending.clear()\n    this.rafId = null\n\n    for (const task of tasks) {\n      try {\n        task()\n      } catch (error) {\n        console.error('Error in RAF scheduled task:', error)\n      }\n    }\n\n    // If new tasks were scheduled during execution, schedule another RAF\n    if (this.pending.size > 0) {\n      this.rafId = requestAnimationFrame(() => this.flush())\n    }\n  }\n}\n\n/**\n * Priority-based scheduler\n */\nenum TaskPriority {\n  Immediate = 0,\n  High = 1,\n  Normal = 2,\n  Low = 3,\n  Idle = 4,\n}\n\ninterface PriorityTask {\n  fn: () => void\n  priority: TaskPriority\n  id: number\n}\n\nclass PriorityScheduler implements Scheduler {\n  private queues = new Map<TaskPriority, Set<PriorityTask>>()\n  private taskIdCounter = 0\n  private isFlushScheduled = false\n\n  constructor() {\n    // Initialize priority queues\n    for (const priority of Object.values(TaskPriority)) {\n      if (typeof priority === 'number') {\n        this.queues.set(priority, new Set())\n      }\n    }\n  }\n\n  schedule(fn: () => void, priority: TaskPriority = TaskPriority.Normal): void {\n    const task: PriorityTask = {\n      fn,\n      priority,\n      id: ++this.taskIdCounter,\n    }\n\n    const queue = this.queues.get(priority)\n    if (queue) {\n      queue.add(task)\n    }\n\n    if (!this.isFlushScheduled) {\n      this.isFlushScheduled = true\n\n      if (priority === TaskPriority.Immediate) {\n        this.flush()\n      } else {\n        queueMicrotask(() => this.flush())\n      }\n    }\n  }\n\n  flush(): void {\n    this.isFlushScheduled = false\n\n    // Process queues by priority\n    for (const priority of [\n      TaskPriority.Immediate,\n      TaskPriority.High,\n      TaskPriority.Normal,\n      TaskPriority.Low,\n      TaskPriority.Idle,\n    ]) {\n      const queue = this.queues.get(priority)\n      if (!queue || queue.size === 0) continue\n\n      const tasks = Array.from(queue).sort((a, b) => a.id - b.id)\n      queue.clear()\n\n      for (const task of tasks) {\n        try {\n          task.fn()\n        } catch (error) {\n          console.error(`Error in priority ${priority} task:`, error)\n        }\n      }\n\n      // Yield to browser after processing each priority level\n      if (queue.size === 0 && this.hasMoreTasks()) {\n        queueMicrotask(() => this.flush())\n        return\n      }\n    }\n  }\n\n  private hasMoreTasks(): boolean {\n    for (const queue of this.queues.values()) {\n      if (queue.size > 0) return true\n    }\n    return false\n  }\n}\n\n// Global scheduler instance\nlet currentScheduler: Scheduler = new MicrotaskScheduler()\n\n/**\n * Get the current scheduler\n */\nexport function getScheduler(): Scheduler {\n  return currentScheduler\n}\n\n/**\n * Set a custom scheduler\n */\nexport function setScheduler(scheduler: Scheduler): void {\n  currentScheduler = scheduler\n}\n\n/**\n * Enable/disable scheduling (for testing)\n */\nexport function enableScheduling(enabled: boolean = true): void {\n  if (enabled) {\n    currentScheduler = new MicrotaskScheduler()\n  } else {\n    currentScheduler = new SyncScheduler()\n  }\n}\n\n/**\n * Flush all pending updates synchronously\n */\nexport function flushSync(): void {\n  currentScheduler.flush()\n}\n\n/**\n * Schedule a function to run in the next update cycle\n */\nexport function scheduleUpdate(fn: () => void): void {\n  currentScheduler.schedule(fn)\n}\n\n/**\n * Create a scheduler with specific behavior\n */\nexport function createScheduler(type: 'microtask' | 'sync' | 'raf' | 'priority'): Scheduler {\n  switch (type) {\n    case 'microtask':\n      return new MicrotaskScheduler()\n    case 'sync':\n      return new SyncScheduler()\n    case 'raf':\n      return new RAFScheduler()\n    case 'priority':\n      return new PriorityScheduler()\n    default:\n      return new MicrotaskScheduler()\n  }\n}\n\n/**\n * Schedule with priority (if using priority scheduler)\n */\nexport function scheduleWithPriority(fn: () => void, priority: TaskPriority): void {\n  if (currentScheduler instanceof PriorityScheduler) {\n    ;(currentScheduler as any).schedule(fn, priority)\n  } else {\n    currentScheduler.schedule(fn)\n  }\n}\n\n/**\n * Defer execution to idle time\n */\nexport function scheduleIdle(fn: () => void): void {\n  if (typeof requestIdleCallback !== 'undefined') {\n    requestIdleCallback(fn)\n  } else {\n    setTimeout(fn, 0)\n  }\n}\n\n/**\n * Cancel all pending updates\n */\nexport function cancelPendingUpdates(): void {\n  if (\n    currentScheduler instanceof MicrotaskScheduler ||\n    currentScheduler instanceof PriorityScheduler\n  ) {\n    ;(currentScheduler as any).pending?.clear()\n  }\n}\n\n// Export scheduler types\nexport { TaskPriority }\nexport type { Scheduler }\n"],"names":["MicrotaskScheduler","__publicField","fn","tasks","task","error","SyncScheduler","TaskPriority","PriorityScheduler","priority","queue","a","b","currentScheduler","getScheduler","setScheduler","scheduler","enableScheduling","enabled","scheduleUpdate","scheduleWithPriority","scheduleIdle"],"mappings":"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"}

package/dist/reactive/scheduler.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Reactive scheduler for managing update batching and timing
+ *
+ * Provides utilities for controlling when reactive updates are executed,
+ * batching updates for performance, and scheduling priorities.
+ */
+import type { Scheduler } from './types';
+/**
+ * Priority-based scheduler
+ */
+declare enum TaskPriority {
+    Immediate = 0,
+    High = 1,
+    Normal = 2,
+    Low = 3,
+    Idle = 4
+}
+/**
+ * Get the current scheduler
+ */
+export declare function getScheduler(): Scheduler;
+/**
+ * Set a custom scheduler
+ */
+export declare function setScheduler(scheduler: Scheduler): void;
+/**
+ * Enable/disable scheduling (for testing)
+ */
+export declare function enableScheduling(enabled?: boolean): void;
+/**
+ * Flush all pending updates synchronously
+ */
+export declare function flushSync(): void;
+/**
+ * Schedule a function to run in the next update cycle
+ */
+export declare function scheduleUpdate(fn: () => void): void;
+/**
+ * Create a scheduler with specific behavior
+ */
+export declare function createScheduler(type: 'microtask' | 'sync' | 'raf' | 'priority'): Scheduler;
+/**
+ * Schedule with priority (if using priority scheduler)
+ */
+export declare function scheduleWithPriority(fn: () => void, priority: TaskPriority): void;
+/**
+ * Defer execution to idle time
+ */
+export declare function scheduleIdle(fn: () => void): void;
+/**
+ * Cancel all pending updates
+ */
+export declare function cancelPendingUpdates(): void;
+export { TaskPriority };
+export type { Scheduler };
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/reactive/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/reactive/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAqGxC;;GAEG;AACH,aAAK,YAAY;IACf,SAAS,IAAI;IACb,IAAI,IAAI;IACR,MAAM,IAAI;IACV,GAAG,IAAI;IACP,IAAI,IAAI;CACT;AAyFD;;GAEG;AACH,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAEvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,OAAc,GAAG,IAAI,CAM9D;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAEhC;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAEnD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAa1F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAMjF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAMjD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAO3C;AAGD,OAAO,EAAE,YAAY,EAAE,CAAA;AACvB,YAAY,EAAE,SAAS,EAAE,CAAA"}

package/dist/reactive/scheduler.js

@@ -0,0 +1,111 @@
+var d = Object.defineProperty, o = (e, s, t) => s in e ? d(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t, i = (e, s, t) => o(e, typeof s != "symbol" ? s + "" : s, t);
+class c {
+  constructor() {
+    i(this, "pending", /* @__PURE__ */ new Set()), i(this, "isFlushScheduled", !1);
+  }
+  schedule(s) {
+    this.pending.add(s), this.isFlushScheduled || (this.isFlushScheduled = !0, queueMicrotask(() => this.flush()));
+  }
+  flush() {
+    if (this.pending.size === 0) {
+      this.isFlushScheduled = !1;
+      return;
+    }
+    const s = Array.from(this.pending);
+    this.pending.clear(), this.isFlushScheduled = !1;
+    for (const t of s)
+      try {
+        t();
+      } catch (l) {
+        console.error("Error in scheduled task:", l);
+      }
+    this.pending.size > 0 && (this.isFlushScheduled = !0, queueMicrotask(() => this.flush()));
+  }
+}
+class f {
+  schedule(s) {
+    try {
+      s();
+    } catch (t) {
+      console.error("Error in sync scheduled task:", t);
+    }
+  }
+  flush() {
+  }
+}
+var n = /* @__PURE__ */ ((e) => (e[e.Immediate = 0] = "Immediate", e[e.High = 1] = "High", e[e.Normal = 2] = "Normal", e[e.Low = 3] = "Low", e[e.Idle = 4] = "Idle", e))(n || {});
+class a {
+  constructor() {
+    i(this, "queues", /* @__PURE__ */ new Map()), i(this, "taskIdCounter", 0), i(this, "isFlushScheduled", !1);
+    for (const s of Object.values(n))
+      typeof s == "number" && this.queues.set(s, /* @__PURE__ */ new Set());
+  }
+  schedule(s, t = 2) {
+    const l = {
+      fn: s,
+      priority: t,
+      id: ++this.taskIdCounter
+    }, r = this.queues.get(t);
+    r && r.add(l), this.isFlushScheduled || (this.isFlushScheduled = !0, t === 0 ? this.flush() : queueMicrotask(() => this.flush()));
+  }
+  flush() {
+    this.isFlushScheduled = !1;
+    for (const s of [
+      0,
+      1,
+      2,
+      3,
+      4
+      /* Idle */
+    ]) {
+      const t = this.queues.get(s);
+      if (!t || t.size === 0) continue;
+      const l = Array.from(t).sort((r, h) => r.id - h.id);
+      t.clear();
+      for (const r of l)
+        try {
+          r.fn();
+        } catch (h) {
+          console.error(`Error in priority ${s} task:`, h);
+        }
+      if (t.size === 0 && this.hasMoreTasks()) {
+        queueMicrotask(() => this.flush());
+        return;
+      }
+    }
+  }
+  hasMoreTasks() {
+    for (const s of this.queues.values())
+      if (s.size > 0) return !0;
+    return !1;
+  }
+}
+let u = new c();
+function S() {
+  return u;
+}
+function p(e) {
+  u = e;
+}
+function q(e = !0) {
+  e ? u = new c() : u = new f();
+}
+function g(e) {
+  u.schedule(e);
+}
+function m(e, s) {
+  u instanceof a ? u.schedule(e, s) : u.schedule(e);
+}
+function F(e) {
+  typeof requestIdleCallback < "u" ? requestIdleCallback(e) : setTimeout(e, 0);
+}
+export {
+  n as TaskPriority,
+  q as enableScheduling,
+  S as getScheduler,
+  F as scheduleIdle,
+  g as scheduleUpdate,
+  m as scheduleWithPriority,
+  p as setScheduler
+};
+//# sourceMappingURL=scheduler.js.map

package/dist/reactive/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sources":["../../src/reactive/scheduler.ts"],"sourcesContent":["/**\n * Reactive scheduler for managing update batching and timing\n *\n * Provides utilities for controlling when reactive updates are executed,\n * batching updates for performance, and scheduling priorities.\n */\n\nimport type { Scheduler } from './types'\n\n/**\n * Default scheduler implementation using microtasks\n */\nclass MicrotaskScheduler implements Scheduler {\n  private pending = new Set<() => void>()\n  private isFlushScheduled = false\n\n  schedule(fn: () => void): void {\n    this.pending.add(fn)\n\n    if (!this.isFlushScheduled) {\n      this.isFlushScheduled = true\n      queueMicrotask(() => this.flush())\n    }\n  }\n\n  flush(): void {\n    if (this.pending.size === 0) {\n      this.isFlushScheduled = false\n      return\n    }\n\n    const tasks = Array.from(this.pending)\n    this.pending.clear()\n    this.isFlushScheduled = false\n\n    for (const task of tasks) {\n      try {\n        task()\n      } catch (error) {\n        console.error('Error in scheduled task:', error)\n      }\n    }\n\n    // If new tasks were scheduled during execution, flush again\n    if (this.pending.size > 0) {\n      this.isFlushScheduled = true\n      queueMicrotask(() => this.flush())\n    }\n  }\n}\n\n/**\n * Synchronous scheduler for immediate execution\n */\nclass SyncScheduler implements Scheduler {\n  schedule(fn: () => void): void {\n    try {\n      fn()\n    } catch (error) {\n      console.error('Error in sync scheduled task:', error)\n    }\n  }\n\n  flush(): void {\n    // No-op for sync scheduler\n  }\n}\n\n/**\n * RAF scheduler for animation-friendly updates\n */\nclass RAFScheduler implements Scheduler {\n  private pending = new Set<() => void>()\n  private rafId: number | null = null\n\n  schedule(fn: () => void): void {\n    this.pending.add(fn)\n\n    if (this.rafId === null) {\n      this.rafId = requestAnimationFrame(() => this.flush())\n    }\n  }\n\n  flush(): void {\n    if (this.pending.size === 0) {\n      this.rafId = null\n      return\n    }\n\n    const tasks = Array.from(this.pending)\n    this.pending.clear()\n    this.rafId = null\n\n    for (const task of tasks) {\n      try {\n        task()\n      } catch (error) {\n        console.error('Error in RAF scheduled task:', error)\n      }\n    }\n\n    // If new tasks were scheduled during execution, schedule another RAF\n    if (this.pending.size > 0) {\n      this.rafId = requestAnimationFrame(() => this.flush())\n    }\n  }\n}\n\n/**\n * Priority-based scheduler\n */\nenum TaskPriority {\n  Immediate = 0,\n  High = 1,\n  Normal = 2,\n  Low = 3,\n  Idle = 4,\n}\n\ninterface PriorityTask {\n  fn: () => void\n  priority: TaskPriority\n  id: number\n}\n\nclass PriorityScheduler implements Scheduler {\n  private queues = new Map<TaskPriority, Set<PriorityTask>>()\n  private taskIdCounter = 0\n  private isFlushScheduled = false\n\n  constructor() {\n    // Initialize priority queues\n    for (const priority of Object.values(TaskPriority)) {\n      if (typeof priority === 'number') {\n        this.queues.set(priority, new Set())\n      }\n    }\n  }\n\n  schedule(fn: () => void, priority: TaskPriority = TaskPriority.Normal): void {\n    const task: PriorityTask = {\n      fn,\n      priority,\n      id: ++this.taskIdCounter,\n    }\n\n    const queue = this.queues.get(priority)\n    if (queue) {\n      queue.add(task)\n    }\n\n    if (!this.isFlushScheduled) {\n      this.isFlushScheduled = true\n\n      if (priority === TaskPriority.Immediate) {\n        this.flush()\n      } else {\n        queueMicrotask(() => this.flush())\n      }\n    }\n  }\n\n  flush(): void {\n    this.isFlushScheduled = false\n\n    // Process queues by priority\n    for (const priority of [\n      TaskPriority.Immediate,\n      TaskPriority.High,\n      TaskPriority.Normal,\n      TaskPriority.Low,\n      TaskPriority.Idle,\n    ]) {\n      const queue = this.queues.get(priority)\n      if (!queue || queue.size === 0) continue\n\n      const tasks = Array.from(queue).sort((a, b) => a.id - b.id)\n      queue.clear()\n\n      for (const task of tasks) {\n        try {\n          task.fn()\n        } catch (error) {\n          console.error(`Error in priority ${priority} task:`, error)\n        }\n      }\n\n      // Yield to browser after processing each priority level\n      if (queue.size === 0 && this.hasMoreTasks()) {\n        queueMicrotask(() => this.flush())\n        return\n      }\n    }\n  }\n\n  private hasMoreTasks(): boolean {\n    for (const queue of this.queues.values()) {\n      if (queue.size > 0) return true\n    }\n    return false\n  }\n}\n\n// Global scheduler instance\nlet currentScheduler: Scheduler = new MicrotaskScheduler()\n\n/**\n * Get the current scheduler\n */\nexport function getScheduler(): Scheduler {\n  return currentScheduler\n}\n\n/**\n * Set a custom scheduler\n */\nexport function setScheduler(scheduler: Scheduler): void {\n  currentScheduler = scheduler\n}\n\n/**\n * Enable/disable scheduling (for testing)\n */\nexport function enableScheduling(enabled: boolean = true): void {\n  if (enabled) {\n    currentScheduler = new MicrotaskScheduler()\n  } else {\n    currentScheduler = new SyncScheduler()\n  }\n}\n\n/**\n * Flush all pending updates synchronously\n */\nexport function flushSync(): void {\n  currentScheduler.flush()\n}\n\n/**\n * Schedule a function to run in the next update cycle\n */\nexport function scheduleUpdate(fn: () => void): void {\n  currentScheduler.schedule(fn)\n}\n\n/**\n * Create a scheduler with specific behavior\n */\nexport function createScheduler(type: 'microtask' | 'sync' | 'raf' | 'priority'): Scheduler {\n  switch (type) {\n    case 'microtask':\n      return new MicrotaskScheduler()\n    case 'sync':\n      return new SyncScheduler()\n    case 'raf':\n      return new RAFScheduler()\n    case 'priority':\n      return new PriorityScheduler()\n    default:\n      return new MicrotaskScheduler()\n  }\n}\n\n/**\n * Schedule with priority (if using priority scheduler)\n */\nexport function scheduleWithPriority(fn: () => void, priority: TaskPriority): void {\n  if (currentScheduler instanceof PriorityScheduler) {\n    ;(currentScheduler as any).schedule(fn, priority)\n  } else {\n    currentScheduler.schedule(fn)\n  }\n}\n\n/**\n * Defer execution to idle time\n */\nexport function scheduleIdle(fn: () => void): void {\n  if (typeof requestIdleCallback !== 'undefined') {\n    requestIdleCallback(fn)\n  } else {\n    setTimeout(fn, 0)\n  }\n}\n\n/**\n * Cancel all pending updates\n */\nexport function cancelPendingUpdates(): void {\n  if (\n    currentScheduler instanceof MicrotaskScheduler ||\n    currentScheduler instanceof PriorityScheduler\n  ) {\n    ;(currentScheduler as any).pending?.clear()\n  }\n}\n\n// Export scheduler types\nexport { TaskPriority }\nexport type { Scheduler }\n"],"names":["MicrotaskScheduler","__publicField","fn","tasks","task","error","SyncScheduler","TaskPriority","PriorityScheduler","priority","queue","a","b","currentScheduler","getScheduler","setScheduler","scheduler","enableScheduling","enabled","scheduleUpdate","scheduleWithPriority","scheduleIdle"],"mappings":"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"}

package/dist/reactive/signal.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("./context.cjs"),s=require("./types.cjs");var c=Object.defineProperty,f=(e,t,i)=>t in e?c(e,t,{enumerable:!0,configurable:!0,writable:!0,value:i}):e[t]=i,o=(e,t,i)=>f(e,typeof t!="symbol"?t+"":t,i);let d=0;class p{constructor(t){o(this,"id"),o(this,"observers",new Set),o(this,"_value"),this.id=++d,this._value=t}getValue(){const t=a.getCurrentComputation();return t&&t.state!==s.ComputationState.Disposed&&(this.observers.add(t),t.sources.add(this)),this._value}peek(){return this._value}set(t){const i=typeof t=="function"?t(this._value):t;return i!==this._value&&(this._value=i,this.notify()),i}notify(){for(const t of this.observers)t.state!==s.ComputationState.Disposed&&(t.state=s.ComputationState.Dirty,h(t))}removeObserver(t){this.observers.delete(t)}[Symbol.for("tachui.debug")](){return{id:this.id,value:this._value,observerCount:this.observers.size,type:"Signal"}}}const r=new Set;let n=!1;function h(e){r.add(e),!n&&!a.isBatchingUpdates()&&queueMicrotask(u)}function u(){if(!n){n=!0;try{for(;r.size>0;){const e=Array.from(r).sort((t,i)=>t.id-i.id);r.clear();for(const t of e)t.state===s.ComputationState.Dirty&&t.execute()}}finally{n=!1}}}function g(e){const t=new p(e),i=t.getValue.bind(t);i.peek=t.peek.bind(t);const l=t.set.bind(t);return Object.defineProperty(i,Symbol.for("tachui.signal"),{value:t,enumerable:!1}),[i,l]}function b(e){return typeof e=="function"&&Symbol.for("tachui.signal")in e}function m(e){return e[Symbol.for("tachui.signal")]||null}a.setFlushFunction(u);exports.createSignal=g;exports.flushSync=u;exports.getSignalImpl=m;exports.isSignal=b;
+//# sourceMappingURL=signal.cjs.map

package/dist/reactive/signal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.cjs","sources":["../../src/reactive/signal.ts"],"sourcesContent":["/**\n * Signal implementation - core reactive primitive\n *\n * Signals are the foundation of TachUI's reactive system, providing\n * fine-grained reactivity similar to SolidJS signals.\n */\n\nimport { getCurrentComputation, isBatchingUpdates, setFlushFunction } from './context'\nimport type { Computation, SignalImpl as ISignal } from './types'\nimport { ComputationState } from './types'\n\nlet signalIdCounter = 0\n\n/**\n * Signal setter function type\n */\nexport type SignalSetter<T> = (value: T | ((prev: T) => T)) => T\n\n/**\n * Internal signal implementation (keeping original behavior)\n */\nclass SignalImpl<T> implements ISignal<T> {\n  readonly id: number\n  readonly observers = new Set<Computation>()\n  private _value: T\n\n  constructor(initialValue: T) {\n    this.id = ++signalIdCounter\n    this._value = initialValue\n  }\n\n  /**\n   * Get the current value and track dependency\n   */\n  getValue(): T {\n    const computation = getCurrentComputation()\n    if (computation && computation.state !== ComputationState.Disposed) {\n      // Track this signal as a dependency\n      this.observers.add(computation)\n      computation.sources.add(this)\n    }\n    return this._value\n  }\n\n  /**\n   * Get the current value without tracking dependency\n   */\n  peek(): T {\n    return this._value\n  }\n\n  /**\n   * Set a new value and notify observers\n   */\n  set(newValue: T | ((prev: T) => T)): T {\n    const value =\n      typeof newValue === 'function' ? (newValue as (prev: T) => T)(this._value) : newValue\n\n    if (value !== this._value) {\n      this._value = value\n      this.notify()\n    }\n\n    return value\n  }\n\n  /**\n   * Notify all observers that this signal has changed\n   */\n  private notify(): void {\n    for (const observer of this.observers) {\n      if (observer.state !== ComputationState.Disposed) {\n        observer.state = ComputationState.Dirty\n        scheduleUpdate(observer)\n      }\n    }\n  }\n\n  /**\n   * Remove an observer (cleanup)\n   */\n  removeObserver(computation: Computation): void {\n    this.observers.delete(computation)\n  }\n\n  /**\n   * Get debug information about this signal\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      value: this._value,\n      observerCount: this.observers.size,\n      type: 'Signal',\n    }\n  }\n}\n\n/**\n * Update queue for batching reactive updates\n */\nconst updateQueue = new Set<Computation>()\nlet isFlushingUpdates = false\n\n/**\n * Schedule a computation for update\n */\nfunction scheduleUpdate(computation: Computation): void {\n  updateQueue.add(computation)\n\n  if (!isFlushingUpdates && !isBatchingUpdates()) {\n    queueMicrotask(flushUpdates)\n  }\n}\n\n/**\n * Flush all pending updates\n */\nfunction flushUpdates(): void {\n  if (isFlushingUpdates) return\n\n  isFlushingUpdates = true\n\n  try {\n    // Keep processing until no more computations are added\n    while (updateQueue.size > 0) {\n      // Process updates in order of computation ID for deterministic execution\n      const computations = Array.from(updateQueue).sort((a, b) => a.id - b.id)\n      updateQueue.clear()\n\n      for (const computation of computations) {\n        if (computation.state === ComputationState.Dirty) {\n          computation.execute()\n        }\n      }\n    }\n  } finally {\n    isFlushingUpdates = false\n  }\n}\n\n/**\n * Create a new reactive signal\n *\n * @param initialValue The initial value of the signal\n * @returns A tuple of [getter, setter] functions\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * console.log(count()) // 0\n * setCount(5)\n * console.log(count()) // 5\n *\n * // Functional update\n * setCount(prev => prev + 1)\n * console.log(count()) // 6\n * ```\n */\nexport function createSignal<T>(initialValue: T): [() => T, SignalSetter<T>] {\n  const signal = new SignalImpl(initialValue)\n\n  const getter = signal.getValue.bind(signal) as (() => T) & { peek: () => T }\n  getter.peek = signal.peek.bind(signal)\n\n  const setter: SignalSetter<T> = signal.set.bind(signal)\n\n  // Add debug information\n  Object.defineProperty(getter, Symbol.for('tachui.signal'), {\n    value: signal,\n    enumerable: false,\n  })\n\n  return [getter, setter]\n}\n\n/**\n * Type guard to check if a value is a signal\n */\nexport function isSignal<T = any>(value: any): value is (() => T) & { peek: () => T } {\n  return typeof value === 'function' && Symbol.for('tachui.signal') in value\n}\n\n/**\n * Get the underlying signal implementation for debugging\n */\nexport function getSignalImpl<T>(signal: (() => T) & { peek: () => T }): SignalImpl<T> | null {\n  return (signal as any)[Symbol.for('tachui.signal')] || null\n}\n\n/**\n * Public Signal type export (callable getter)\n */\nexport type { Signal } from './types'\n\n// Export flush function for testing and manual control\nexport { flushUpdates as flushSync }\n\n// Register flush function with context module\nsetFlushFunction(flushUpdates)\n"],"names":["signalIdCounter","SignalImpl","initialValue","__publicField","computation","getCurrentComputation","ComputationState","newValue","value","observer","scheduleUpdate","updateQueue","isFlushingUpdates","isBatchingUpdates","flushUpdates","computations","a","b","createSignal","signal","getter","setter","isSignal","getSignalImpl","setFlushFunction"],"mappings":"sSAWA,IAAIA,EAAkB,EAUtB,MAAMC,CAAoC,CAKxC,YAAYC,EAAiB,CAJ7BC,EAAA,KAAS,IAAA,EACTA,EAAA,KAAS,gBAAgB,GAAiB,EAC1CA,EAAA,KAAQ,QAAA,EAGN,KAAK,GAAK,EAAEH,EACZ,KAAK,OAASE,CAChB,CAKA,UAAc,CACZ,MAAME,EAAcC,EAAAA,sBAAA,EACpB,OAAID,GAAeA,EAAY,QAAUE,EAAAA,iBAAiB,WAExD,KAAK,UAAU,IAAIF,CAAW,EAC9BA,EAAY,QAAQ,IAAI,IAAI,GAEvB,KAAK,MACd,CAKA,MAAU,CACR,OAAO,KAAK,MACd,CAKA,IAAIG,EAAmC,CACrC,MAAMC,EACJ,OAAOD,GAAa,WAAcA,EAA4B,KAAK,MAAM,EAAIA,EAE/E,OAAIC,IAAU,KAAK,SACjB,KAAK,OAASA,EACd,KAAK,OAAA,GAGAA,CACT,CAKQ,QAAe,CACrB,UAAWC,KAAY,KAAK,UACtBA,EAAS,QAAUH,EAAAA,iBAAiB,WACtCG,EAAS,MAAQH,EAAAA,iBAAiB,MAClCI,EAAeD,CAAQ,EAG7B,CAKA,eAAeL,EAAgC,CAC7C,KAAK,UAAU,OAAOA,CAAW,CACnC,CAKA,CAAC,OAAO,IAAI,cAAc,CAAC,GAAY,CACrC,MAAO,CACL,GAAI,KAAK,GACT,MAAO,KAAK,OACZ,cAAe,KAAK,UAAU,KAC9B,KAAM,QAAA,CAEV,CACF,CAKA,MAAMO,MAAkB,IACxB,IAAIC,EAAoB,GAKxB,SAASF,EAAeN,EAAgC,CACtDO,EAAY,IAAIP,CAAW,EAEvB,CAACQ,GAAqB,CAACC,EAAAA,qBACzB,eAAeC,CAAY,CAE/B,CAKA,SAASA,GAAqB,CAC5B,GAAI,CAAAF,EAEJ,CAAAA,EAAoB,GAEpB,GAAI,CAEF,KAAOD,EAAY,KAAO,GAAG,CAE3B,MAAMI,EAAe,MAAM,KAAKJ,CAAW,EAAE,KAAK,CAACK,EAAGC,IAAMD,EAAE,GAAKC,EAAE,EAAE,EACvEN,EAAY,MAAA,EAEZ,UAAWP,KAAeW,EACpBX,EAAY,QAAUE,EAAAA,iBAAiB,OACzCF,EAAY,QAAA,CAGlB,CACF,QAAA,CACEQ,EAAoB,EACtB,EACF,CAqBO,SAASM,EAAgBhB,EAA6C,CAC3E,MAAMiB,EAAS,IAAIlB,EAAWC,CAAY,EAEpCkB,EAASD,EAAO,SAAS,KAAKA,CAAM,EAC1CC,EAAO,KAAOD,EAAO,KAAK,KAAKA,CAAM,EAErC,MAAME,EAA0BF,EAAO,IAAI,KAAKA,CAAM,EAGtD,cAAO,eAAeC,EAAQ,OAAO,IAAI,eAAe,EAAG,CACzD,MAAOD,EACP,WAAY,EAAA,CACb,EAEM,CAACC,EAAQC,CAAM,CACxB,CAKO,SAASC,EAAkBd,EAAoD,CACpF,OAAO,OAAOA,GAAU,YAAc,OAAO,IAAI,eAAe,IAAKA,CACvE,CAKO,SAASe,EAAiBJ,EAA6D,CAC5F,OAAQA,EAAe,OAAO,IAAI,eAAe,CAAC,GAAK,IACzD,CAWAK,EAAAA,iBAAiBV,CAAY"}