@uistate/examples 1.0.0

package/eventState/032-todo-app-with-eventTest/devtools/stateTracker.js

@@ -0,0 +1,246 @@
+// stateTracker.js — OCP-friendly utility widget
+// Purpose: When imported, renders a floating button you can click to cycle between
+// the four corners of the viewport. Double-click toggles a full-height sidebar
+// that opens on the left or right depending on the button's current horizontal corner.
+//
+// Design:
+// - No external deps. Pure JS + a single <style> tag for cosmetics.
+// - Open/Closed: exposes installStateTracker(opts) returning an uninstall function.
+//   Auto-installs on import with defaults, but can be disabled via global flag.
+// - Minimal footprint and no global CSS leakage (scoped class names).
+
+(function(){
+  const AUTO_INSTALL = true; // set to false if you prefer manual install only
+
+  const STYLE_CSS = `
+    .stt-pill { pointer-events: auto; position: fixed; display: inline-flex; gap: 6px; padding: 4px; border-radius: 999px;
+      background: rgba(17,17,17,.9); backdrop-filter: saturate(120%) blur(4px); box-shadow: 0 2px 10px rgba(0,0,0,.25);
+      border: 1px solid rgba(255,255,255,.12); z-index: 2147483600;
+    }
+    .stt-btn { width: 36px; height: 36px; border-radius: 18px; display: grid; place-items: center;
+      font: 600 12px/1 system-ui, -apple-system, Segoe UI, Roboto, sans-serif; color: #fff; background: #111;
+      border: 1px solid rgba(255,255,255,.15); cursor: pointer; user-select: none;
+    }
+    .stt-btn:hover { background: #1a1a1a; }
+    .stt-btn:active { transform: translateY(1px); }
+
+    .stt-corner-top-left { top: 12px; left: 12px; }
+    .stt-corner-top-right { top: 12px; right: 12px; }
+    .stt-corner-bottom-right { bottom: 12px; right: 12px; }
+    .stt-corner-bottom-left { bottom: 12px; left: 12px; }
+
+    .stt-sidebar { pointer-events: auto; position: fixed; top: 0; height: 100vh; width: min(80vw, 320px);
+      background: var(--stt-sidebar-bg, #181818); color: var(--stt-sidebar-fg, #eee);
+      border-inline: 1px solid rgba(255,255,255,.12); box-shadow: 0 0 24px rgba(0,0,0,.25);
+      transform: translateX(var(--stt-x, 0)); transition: transform 180ms ease, opacity 180ms ease;
+      opacity: var(--stt-opacity, 0); will-change: transform, opacity; z-index: 2147483600;
+    }
+    .stt-sidebar.right { right: 0; --stt-x: 100%; }
+    .stt-sidebar.left { left: 0; --stt-x: -100%; }
+    .stt-open .stt-sidebar { --stt-x: 0; --stt-opacity: 1; }
+
+    .stt-sidebar header { padding: 8px 10px; font-weight: 700; border-bottom: 1px solid rgba(255,255,255,.08);
+      display: flex; align-items: center; justify-content: space-between; gap: 8px; }
+    .stt-header-title { font-size: 12px; font-weight: 700; letter-spacing: .3px; opacity: .9; }
+    .stt-header-actions { display: inline-flex; gap: 6px; }
+    .stt-icon-btn { width: 26px; height: 26px; border-radius: 6px; display: grid; place-items: center;
+      font: 600 12px/1 system-ui, -apple-system, Segoe UI, Roboto, sans-serif; color: #eee; background: #222;
+      border: 1px solid rgba(255,255,255,.12); cursor: pointer; user-select: none; }
+    .stt-icon-btn:hover { background: #2a2a2a; }
+    .stt-sidebar .stt-content { padding: 12px 14px; font-size: 12px; line-height: 1.35;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+      white-space: pre; overflow: auto; max-height: calc(100vh - 48px);
+    }
+    /* Inline tools inside sidebar */
+    .stt-row { display: flex; gap: 6px; padding: 6px 0; flex-wrap: wrap; }
+    .stt-btn-sm { height: 28px; padding: 4px 10px; border-radius: 6px;
+      font: 600 12px/1 system-ui, -apple-system, Segoe UI, Roboto, sans-serif; color: #eee; background: #222;
+      border: 1px solid rgba(255,255,255,.12); cursor: pointer; user-select: none; }
+    .stt-btn-sm:hover { background: #2a2a2a; }
+  `;
+
+  const CORNERS = ['top-left','top-right','bottom-right','bottom-left'];
+
+  function createEl(tag, cls){ const el = document.createElement(tag); if (cls) el.className = cls; return el; }
+
+  function installStateTracker({
+    corner = 'bottom-right',
+    appendTo = document.body,
+    title = 'ST',
+    store = undefined,
+    pathPrefix = 'ui.stateTracker',
+  } = {}){
+    if (!appendTo) appendTo = document.body;
+    // Allow global opt-in binding without importing store here (keeps OCP)
+    if (!store && typeof window !== 'undefined' && window.stateTrackerStore){
+      store = window.stateTrackerStore;
+    }
+
+    // Inject style once
+    let styleEl = document.getElementById('stt-style');
+    if (!styleEl){
+      styleEl = document.createElement('style');
+      styleEl.id = 'stt-style';
+      styleEl.textContent = STYLE_CSS;
+      document.head.appendChild(styleEl);
+    }
+
+    const pill = createEl('div', 'stt-pill');
+    const btnMove = createEl('button', 'stt-btn stt-btn-move');
+    btnMove.type = 'button'; btnMove.title = 'Move'; btnMove.textContent = '◷';
+    const btnToggle = createEl('button', 'stt-btn stt-btn-toggle');
+    btnToggle.type = 'button'; btnToggle.title = 'Toggle'; btnToggle.textContent = title;
+    pill.appendChild(btnMove);
+    pill.appendChild(btnToggle);
+
+    const sidebar = createEl('aside', 'stt-sidebar');
+    const header = createEl('header');
+    const hTitle = createEl('div', 'stt-header-title'); hTitle.textContent = 'State Tracker';
+    const hActions = createEl('div', 'stt-header-actions');
+    const btnCopy = createEl('button', 'stt-icon-btn'); btnCopy.type = 'button'; btnCopy.title = 'Copy state'; btnCopy.textContent = '⎘';
+    const btnClose = createEl('button', 'stt-icon-btn'); btnClose.type = 'button'; btnClose.title = 'Close'; btnClose.textContent = '×';
+    hActions.appendChild(btnCopy); hActions.appendChild(btnClose);
+    header.appendChild(hTitle); header.appendChild(hActions);
+    const content = createEl('div', 'stt-content');
+    // Helper to create a button with safe handler
+    function mkBtn(label, title, handler){
+      const b = document.createElement('button');
+      b.className = 'stt-btn-sm'; b.type = 'button'; b.textContent = label; if (title) b.title = title;
+      b.addEventListener('click', (e) => { try { handler && handler(e); } catch(err){ console.warn('[stateTracker]', err); } });
+      return b;
+    }
+
+    // State JSON directly visible (no accordion)
+    const pre = document.createElement('pre');
+    pre.className = 'stt-pre';
+    pre.textContent = 'Loading state…';
+    content.appendChild(pre);
+    sidebar.appendChild(header); sidebar.appendChild(content);
+
+    document.body.appendChild(pill);
+    document.body.appendChild(sidebar);
+
+    function applyCorner(){
+      pill.classList.remove(
+        'stt-corner-top-left','stt-corner-top-right','stt-corner-bottom-right','stt-corner-bottom-left'
+      );
+      const cls = `stt-corner-${corner}`;
+      pill.classList.add(cls);
+      const isRight = corner.includes('right');
+      sidebar.classList.toggle('right', isRight);
+      sidebar.classList.toggle('left', !isRight);
+    }
+
+    let open = false;
+    function setOpen(v){
+      open = !!v;
+      document.documentElement.classList.toggle('stt-open', open);
+      if (store && typeof store.set === 'function'){
+        try { store.set(`${pathPrefix}.open`, open); } catch {}
+      }
+    }
+
+    applyCorner();
+
+    // Render full state tree (if store provided), throttled to animation frame
+    let scheduled = false;
+    function renderState(){
+      if (!store) return;
+      try {
+        const obj = store.get();
+        pre.textContent = JSON.stringify(obj, null, 2);
+      } catch (e) {
+        pre.textContent = '[stateTracker] Unable to render state: ' + (e && e.message ? e.message : e);
+      }
+    }
+    function scheduleRender(){
+      if (scheduled) return; scheduled = true;
+      requestAnimationFrame(() => { scheduled = false; renderState(); });
+    }
+    if (store){ renderState(); }
+
+    // Left button: move between corners
+    btnMove.addEventListener('click', (e) => {
+      console.log('[stateTracker] move click', { corner });
+      const idx = CORNERS.indexOf(corner);
+      corner = CORNERS[(idx + 1) % CORNERS.length];
+      applyCorner();
+      if (store && typeof store.set === 'function'){
+        try { store.set(`${pathPrefix}.corner`, corner); } catch {}
+      }
+    });
+
+    // Right button: toggle sidebar
+    btnToggle.addEventListener('click', (e) => {
+      console.log('[stateTracker] toggle click', { openBefore: open });
+      setOpen(!open);
+      console.log('[stateTracker] toggle result', { openAfter: open });
+      if (open && store) scheduleRender();
+    });
+
+    // Close via header close button or ESC
+    btnClose.addEventListener('click', () => setOpen(false));
+    window.addEventListener('keydown', (e) => { if (e.key === 'Escape') setOpen(false); });
+
+    // Copy state structure
+    async function copyState(){
+      try {
+        // ensure latest state text
+        renderState();
+        const text = pre.textContent || '';
+        if (navigator.clipboard && navigator.clipboard.writeText){
+          await navigator.clipboard.writeText(text);
+        } else {
+          const ta = document.createElement('textarea');
+          ta.value = text; document.body.appendChild(ta); ta.select();
+          document.execCommand('copy'); ta.remove();
+        }
+        const old = btnCopy.textContent; btnCopy.textContent = '✓';
+        setTimeout(() => { btnCopy.textContent = old; }, 900);
+      } catch(err){
+        console.warn('[stateTracker] copy failed', err);
+      }
+    }
+    btnCopy.addEventListener('click', copyState);
+
+    // Subscribe to all store changes to refresh view (if store provided)
+    let unsubscribe = null;
+    if (store && typeof store.subscribe === 'function'){
+      try {
+        unsubscribe = store.subscribe('*', () => { if (open) scheduleRender(); });
+      } catch {}
+    }
+
+    // Clean up function
+    const uninstall = () => {
+      try { pill.remove(); } catch {}
+      try { sidebar.remove(); } catch {}
+      window.removeEventListener('keydown', () => {});
+      if (unsubscribe){ try { unsubscribe(); } catch {} }
+    };
+
+    return {
+      setCorner(next){ if (CORNERS.includes(next)){ corner = next; applyCorner(); } },
+      getCorner(){ return corner; },
+      isOpen(){ return open; },
+      open(){ setOpen(true); },
+      close(){ setOpen(false); },
+      toggle(){ setOpen(!open); },
+      uninstall,
+      elements: { pill, btnMove, btnToggle, sidebar },
+    };
+  }
+
+  // Auto-install on import (but still export installer)
+  const api = { installStateTracker };
+  if (AUTO_INSTALL) {
+    // Guard against SSR/non-DOM contexts
+    if (typeof document !== 'undefined' && document.body){
+      api.instance = installStateTracker();
+    }
+  }
+
+  // UMD-lite export
+  if (typeof module !== 'undefined' && module.exports){ module.exports = api; }
+  else if (typeof window !== 'undefined'){ window.stateTracker = api; }
+})();

package/eventState/032-todo-app-with-eventTest/devtools/telemetry.js

@@ -0,0 +1,104 @@
+// telemetry.dev.js — dev-only console buffer + copy-to-clipboard button
+// Safe to include in production: it will bail out immediately when not in DEV.
+
+import store from '../app/store.js';
+
+// if (import.meta && import.meta.env && import.meta.env.DEV) {
+  const MAX = 500;
+  const buf = [];
+  const orig = {
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console),
+    debug: console.debug.bind(console),
+  };
+
+  function push(level, args){
+    buf.push({ t: Date.now(), level, args: Array.from(args) });
+    if (buf.length > MAX) buf.shift();
+  }
+
+  console.log = (...a) => { push('log', a); orig.log(...a); };
+  console.warn = (...a) => { push('warn', a); orig.warn(...a); };
+  console.error = (...a) => { push('error', a); orig.error(...a); };
+  console.info = (...a) => { push('info', a); orig.info(...a); };
+  console.debug = (...a) => { push('debug', a); orig.debug(...a); };
+
+  // Expose a simple API
+  window.__telemetry = {
+    get: () => buf.slice(),
+    clear: () => { buf.length = 0; },
+    copy: async () => {
+      try {
+        const text = JSON.stringify(buf, null, 2);
+        await navigator.clipboard.writeText(text);
+        orig.info('[telemetry] Copied console buffer to clipboard (', buf.length, 'entries )');
+      } catch (e) {
+        orig.warn('[telemetry] Clipboard copy failed', e);
+      }
+    }
+  };
+
+  // Register with shared dev dock if available
+  if (window.__devdock && typeof window.__devdock.register === 'function'){
+    window.__devdock.register({ id: 'copy-console', label: 'Console', title: 'Copy console buffer', onClick: () => window.__telemetry.copy() });
+  } else {
+    // Fallback: simple floating button
+    const dockId = 'dev-tools-dock';
+    let dock = document.getElementById(dockId);
+    if (!dock){
+      dock = document.createElement('div');
+      dock.id = dockId;
+      Object.assign(dock.style, {
+        position: 'fixed', left: '10px', bottom: '10px', zIndex: 9999,
+        display: 'flex', gap: '6px', alignItems: 'center',
+      });
+      document.body.appendChild(dock);
+    }
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.textContent = 'Copy Console';
+    Object.assign(btn.style, {
+      appearance: 'none', border: '1px solid #ddd', background: '#fff',
+      borderRadius: '6px', padding: '6px 10px', cursor: 'pointer',
+      boxShadow: '0 1px 2px rgba(0,0,0,0.06)'
+    });
+    btn.addEventListener('click', () => window.__telemetry.copy());
+    dock.appendChild(btn);
+  }
+
+  // ============================================
+  // SITEWIDE TELEMETRY: Log all state changes
+  // ============================================
+  if (typeof window !== 'undefined') {
+    if (!store) {
+      orig.error('[telemetry] Store is undefined!');
+    } else if (!store.subscribe) {
+      orig.error('[telemetry] Store has no subscribe method!', store);
+    } else {
+      // Log all state changes (except noisy ones)
+      store.subscribe('*', (detail) => {
+        const { path, value } = detail;
+        
+        // Skip transitioning state (too noisy)
+        if (path === 'ui.route.transitioning') return;
+        
+        // Skip intent paths here (logged separately below)
+        if (path.startsWith('intent.')) return;
+        
+        // Format like existing telemetry
+        console.log(`[state] ${path}`, value);
+      });
+
+      // Log all intents separately (more prominent)
+      store.subscribe('intent.*', (detail) => {
+        const { path, value } = detail;
+        const intentName = path.replace('intent.', '');
+        console.log(`[intent] ${intentName}`, value);
+      });
+
+      orig.info('[telemetry] Sitewide state tracking enabled');
+    }
+  }
+// }

package/eventState/032-todo-app-with-eventTest/devtools/typeGenerator.js

@@ -0,0 +1,339 @@
+// typeGenerator.js — Generate TypeScript definitions from telemetry
+// Analyzes runtime telemetry to extract state shape and generate .d.ts files
+
+import store from '../app/store.js';
+
+class TypeGenerator {
+  constructor() {
+    this.pathTypes = new Map(); // path → type info
+    this.pathSamples = new Map(); // path → sample values
+  }
+
+  /**
+   * Observe a state change and infer its type
+   */
+  observe(path, value) {
+    const type = this.inferType(value);
+    
+    // Store sample for complex types
+    if (typeof value === 'object' && value !== null) {
+      if (!this.pathSamples.has(path)) {
+        this.pathSamples.set(path, []);
+      }
+      const samples = this.pathSamples.get(path);
+      if (samples.length < 10) {
+        samples.push(value);
+      }
+    }
+    
+    // Merge with existing type info
+    if (this.pathTypes.has(path)) {
+      const existing = this.pathTypes.get(path);
+      this.pathTypes.set(path, this.mergeTypes(existing, type));
+    } else {
+      this.pathTypes.set(path, type);
+    }
+  }
+
+  /**
+   * Infer TypeScript type from a value
+   */
+  inferType(value) {
+    if (value === null) return 'null';
+    if (value === undefined) return 'undefined';
+    
+    if (Array.isArray(value)) {
+      if (value.length === 0) return 'Array<unknown>';
+      
+      // Sample first few elements and merge their types
+      const samples = value.slice(0, 10);
+      let mergedElementType = null;
+      
+      for (const sample of samples) {
+        const elementType = this.inferType(sample);
+        if (mergedElementType === null) {
+          mergedElementType = elementType;
+        } else {
+          mergedElementType = this.mergeTypes(mergedElementType, elementType);
+        }
+      }
+      
+      return `Array<${this.typeToString(mergedElementType)}>`;
+    }
+    
+    if (typeof value === 'object') {
+      // Infer object shape
+      const shape = {};
+      for (const [key, val] of Object.entries(value)) {
+        shape[key] = this.inferType(val);
+      }
+      return shape;
+    }
+    
+    // Primitives
+    if (typeof value === 'string') return 'string';
+    if (typeof value === 'number') return 'number';
+    if (typeof value === 'boolean') return 'boolean';
+    
+    return 'unknown';
+  }
+
+  /**
+   * Convert type representation to string
+   */
+  typeToString(type) {
+    if (typeof type === 'string') return type;
+    
+    if (typeof type === 'object' && !Array.isArray(type)) {
+      const props = Object.entries(type)
+        .map(([k, v]) => `${k}: ${this.typeToString(v)}`)
+        .join('; ');
+      return `{ ${props} }`;
+    }
+    
+    return 'unknown';
+  }
+
+  /**
+   * Merge two type definitions (for union types)
+   */
+  mergeTypes(type1, type2) {
+    // Normalize for comparison
+    const str1 = this.normalizeType(type1);
+    const str2 = this.normalizeType(type2);
+    
+    if (str1 === str2) return type1;
+    
+    // Handle string types
+    if (typeof type1 === 'string' && typeof type2 === 'string') {
+      if (type1 === type2) return type1;
+      // Avoid duplicate unions
+      if (type1.includes(type2)) return type1;
+      if (type2.includes(type1)) return type2;
+      return `${type1} | ${type2}`;
+    }
+    
+    // Handle object merging (merge properties, not create union)
+    if (typeof type1 === 'object' && typeof type2 === 'object' && 
+        !Array.isArray(type1) && !Array.isArray(type2)) {
+      const merged = { ...type1 };
+      for (const [key, val] of Object.entries(type2)) {
+        if (key in merged) {
+          merged[key] = this.mergeTypes(merged[key], val);
+        } else {
+          merged[key] = val;
+        }
+      }
+      return merged;
+    }
+    
+    // Mixed types: create union
+    if (typeof type1 === 'string' && typeof type2 === 'object') {
+      return `${type1} | ${this.typeToString(type2)}`;
+    }
+    if (typeof type1 === 'object' && typeof type2 === 'string') {
+      return `${this.typeToString(type1)} | ${type2}`;
+    }
+    
+    return type1; // Default: keep first type
+  }
+
+  /**
+   * Normalize type for comparison
+   */
+  normalizeType(type) {
+    if (typeof type === 'string') return type;
+    return JSON.stringify(type, Object.keys(type).sort());
+  }
+
+  /**
+   * Build hierarchical tree from flat paths
+   */
+  buildTree() {
+    const tree = {};
+    
+    for (const [path, type] of this.pathTypes) {
+      const parts = path.split('.');
+      let current = tree;
+      
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        
+        if (i === parts.length - 1) {
+          // Leaf node
+          current[part] = { __type: type };
+        } else {
+          // Branch node
+          if (!current[part]) {
+            current[part] = {};
+          }
+          current = current[part];
+        }
+      }
+    }
+    
+    return tree;
+  }
+
+  /**
+   * Generate TypeScript interface from type info
+   */
+  generateInterface(obj, indent = 0) {
+    const lines = [];
+    const spaces = '  '.repeat(indent);
+    
+    for (const [key, value] of Object.entries(obj)) {
+      if (value.__type !== undefined) {
+        // Leaf node with type
+        const type = this.formatType(value.__type);
+        lines.push(`${spaces}${key}: ${type};`);
+      } else {
+        // Nested object
+        lines.push(`${spaces}${key}: {`);
+        lines.push(this.generateInterface(value, indent + 1));
+        lines.push(`${spaces}};`);
+      }
+    }
+    
+    return lines.join('\n');
+  }
+
+  /**
+   * Format type for TypeScript output
+   */
+  formatType(type) {
+    if (typeof type === 'string') {
+      return type;
+    }
+    
+    if (typeof type === 'object' && !Array.isArray(type)) {
+      // Inline object type
+      const props = Object.entries(type)
+        .map(([k, v]) => `${k}: ${this.formatType(v)}`)
+        .join('; ');
+      return `{ ${props} }`;
+    }
+    
+    return 'unknown';
+  }
+
+  /**
+   * Generate complete .d.ts file
+   */
+  generateDTS() {
+    const lines = [
+      '// Auto-generated from runtime telemetry',
+      '// DO NOT EDIT - regenerate by using the app and clicking "Generate Types"',
+      '',
+      'export interface StoreState {',
+    ];
+    
+    const tree = this.buildTree();
+    lines.push(this.generateInterface(tree, 1));
+    lines.push('}');
+    lines.push('');
+    lines.push('export default StoreState;');
+    lines.push('');
+    
+    return lines.join('\n');
+  }
+
+  /**
+   * Parse telemetry buffer and extract types
+   */
+  parseBuffer(buffer) {
+    for (const entry of buffer) {
+      if (entry.level !== 'log') continue;
+      
+      const args = entry.args;
+      if (!args || args.length < 2) continue;
+      
+      const tag = args[0];
+      
+      // Parse [state] entries
+      if (typeof tag === 'string' && tag.startsWith('[state]')) {
+        const path = tag.replace('[state] ', '');
+        const value = args[1];
+        this.observe(path, value);
+      }
+      
+      // Parse [intent] entries
+      if (typeof tag === 'string' && tag.startsWith('[intent]')) {
+        const intentName = tag.replace('[intent] ', '');
+        const path = `intent.${intentName}`;
+        const value = args[1];
+        this.observe(path, value);
+      }
+    }
+  }
+
+  /**
+   * Parse test assertions and extract types
+   */
+  parseTestAssertions(assertions) {
+    for (const assertion of assertions) {
+      const { path, type, elementShape, shape } = assertion;
+      
+      if (type === 'array' && elementShape) {
+        // Array type with element shape
+        this.pathTypes.set(path, `Array<${this.typeToString(elementShape)}>`);
+      } else if (type === 'object' && shape) {
+        // Object type with shape
+        this.pathTypes.set(path, shape);
+      } else if (type) {
+        // Primitive type
+        this.pathTypes.set(path, type);
+      }
+    }
+  }
+
+  /**
+   * Save .d.ts file (browser download)
+   */
+  save(filename = 'store.d.ts') {
+    const dts = this.generateDTS();
+    const blob = new Blob([dts], { type: 'text/plain' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+}
+
+// Create and expose type generator
+const typeGenerator = new TypeGenerator();
+window.__typeGenerator = typeGenerator;
+
+// Subscribe to all state changes for live type inference
+if (store && store.subscribe) {
+  store.subscribe('*', (detail) => {
+    const { path, value } = detail;
+    typeGenerator.observe(path, value);
+  });
+  
+  console.info('[typeGenerator] Live type inference enabled');
+}
+
+// Register with dev dock
+if (window.__devdock && typeof window.__devdock.register === 'function') {
+  window.__devdock.register({
+    id: 'generate-types',
+    label: 'Types',
+    title: 'Generate TypeScript definitions',
+    onClick: () => {
+      // Also parse telemetry buffer for historical data
+      if (window.__telemetry) {
+        const buffer = window.__telemetry.get();
+        typeGenerator.parseBuffer(buffer);
+      }
+      
+      typeGenerator.save('store.d.ts');
+      console.info('[typeGenerator] Generated store.d.ts');
+    }
+  });
+}
+
+export default typeGenerator;
+export { TypeGenerator };