modality-kit 0.8.10 → 0.8.11

package/dist/types/schemas/schemas_symbol.d.ts

@@ -3,11 +3,11 @@ declare const positionSchema: z.ZodObject<{
     line: z.ZodNumber;
     col: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    col: number;
     line: number;
-}, {
     col: number;
+}, {
     line: number;
+    col: number;
 }>;
 export declare const symbolKinds: readonly ["File", "Module", "Namespace", "Package", "Class", "Method", "Property", "Field", "Constructor", "Enum", "Interface", "Function", "Variable", "Constant", "String", "Number", "Boolean", "Array", "Object", "Key", "Null", "EnumMember", "Struct", "Event", "Operator", "TypeParameter"];
 export declare const symbolKindSchema: z.ZodEnum<["File", "Module", "Namespace", "Package", "Class", "Method", "Property", "Field", "Constructor", "Enum", "Interface", "Function", "Variable", "Constant", "String", "Number", "Boolean", "Array", "Object", "Key", "Null", "EnumMember", "Struct", "Event", "Operator", "TypeParameter"]>;
@@ -17,39 +17,39 @@ export declare const rangeSchema: z.ZodObject<{
         line: z.ZodNumber;
         col: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        col: number;
         line: number;
-    }, {
         col: number;
+    }, {
         line: number;
+        col: number;
     }>;
     end: z.ZodObject<{
         line: z.ZodNumber;
         col: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        col: number;
         line: number;
-    }, {
         col: number;
+    }, {
         line: number;
+        col: number;
     }>;
 }, "strip", z.ZodTypeAny, {
     start: {
-        col: number;
         line: number;
+        col: number;
     };
     end: {
-        col: number;
         line: number;
+        col: number;
     };
 }, {
     start: {
-        col: number;
         line: number;
+        col: number;
     };
     end: {
-        col: number;
         line: number;
+        col: number;
     };
 }>;
 export type Position = z.infer<typeof positionSchema>;
@@ -92,12 +92,12 @@ declare const fileEntrySchema: z.ZodObject<{
     type: z.ZodEnum<["file", "directory"]>;
     lastModified: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
-    path: string;
     type: "file" | "directory";
+    path: string;
     lastModified?: number | null | undefined;
 }, {
-    path: string;
     type: "file" | "directory";
+    path: string;
     lastModified?: number | null | undefined;
 }>;
 export type FileEntryType = z.infer<typeof fileEntrySchema>;

package/dist/types/util_mcp_tools_converter.d.ts

@@ -1,4 +1,4 @@
-import { FastMCP } from "fastmcp";
+import type { FastMCP } from "fastmcp";
 import type { AITools } from "./schemas/schemas_tool_config.ts";
 /**
  * Setup function that optionally registers AITools with MCP server

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.8.10",
+  "version": "0.8.11",
   "name": "modality-kit",
   "repository": {
     "type": "git",
@@ -11,33 +11,23 @@
   "author": "Hill <hill@kimo.com>",
   "license": "ISC",
   "devDependencies": {
-    "@happy-dom/global-registrator": "^18.0.1",
-    "@types/browser-or-node": "^1.3.2",
     "@types/bun": "^1.2.19",
     "fastmcp": "^3.12.0",
     "typescript": "^5.8.3",
     "zod": "3.x"
   },
   "exports": {
-    ".": {
-      "require": "./dist/index.js",
-      "import": "./dist/index.js",
-      "types": "./dist/types/index.d.ts"
-    },
-    "./browser": {
-      "require": "./dist/browser.js",
-      "import": "./dist/browser.js",
-      "types": "./dist/types/browser.d.ts"
-    }
+    "require": "./dist/index.js",
+    "import": "./dist/index.js",
+    "types": "./dist/types/index.d.ts"
   },
   "scripts": {
     "update-compile-sh": "yo reshow:compile-sh",
     "build:clean": "find ./dist -name '*.*' | xargs rm -rf",
-    "dev": "bunx concurrently 'bunx --watch tsc  -p ./' 'bun build:src -- --watch --sourcemap=inline'",
     "build:types": "bunx tsc -p ./",
     "build:src": "bun build src/index.ts --outdir dist",
-    "build:browser": "bun build src/browser.ts --outdir dist --format cjs --target browser --external @valibot/to-json-schema --external sury --external effect",
-    "build": "bun run build:clean && bun run build:src && bun run build:browser && bun run build:types",
+    "build": "bun run build:clean && bun run build:src && bun run build:types",
+    "dev": "bunx concurrently 'bunx --watch tsc  -p ./' 'bun build:src -- --watch --sourcemap=inline'",
     "test": "bun test",
     "prepublishOnly": "npm run build && npm run test"
   },

package/dist/browser.js

@@ -1,263 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/browser.ts
-var exports_browser = {};
-__export(exports_browser, {
-  render: () => render,
-  registerStore: () => registerStore,
-  ReactiveComponent: () => ReactiveComponent
-});
-module.exports = __toCommonJS(exports_browser);
-
-// src/ReactiveComponent.ts
-class ReactiveComponent extends HTMLElement {
-  #state;
-  #isRendering = false;
-  #pendingUpdate = false;
-  #hasRendered = false;
-  #shadow;
-  #options;
-  #delegatedEventListeners = {};
-  #eventTypes = [
-    "click",
-    "dblclick",
-    "mousedown",
-    "mouseup",
-    "mousemove",
-    "mouseover",
-    "mouseout",
-    "focus",
-    "blur",
-    "change",
-    "input",
-    "submit",
-    "keydown",
-    "keyup",
-    "keypress"
-  ];
-  _stores;
-  _storeListeners;
-  constructor(options = {}) {
-    super();
-    this.#options = options;
-    this.#state = options.initialState || {};
-  }
-  get state() {
-    return Object.freeze({ ...this.#state });
-  }
-  setState(updator, _action, prevState) {
-    const oldState = prevState || { ...this.#state };
-    let newUpdates;
-    if (typeof updator === "function") {
-      newUpdates = updator(this.#state);
-    } else {
-      newUpdates = updator;
-    }
-    const newState = { ...this.#state, ...newUpdates };
-    if (this.#options.shouldUpdate && !this.#options.shouldUpdate(newState, oldState)) {
-      return this.#state;
-    } else {
-      this.#state = newState;
-      this.#scheduleUpdate(oldState);
-      return newState;
-    }
-  }
-  forceUpdate() {
-    this.#scheduleUpdate({ ...this.#state });
-  }
-  #scheduleUpdate(previousState) {
-    if (this.#isRendering || this.#pendingUpdate) {
-      return;
-    }
-    this.#pendingUpdate = true;
-    queueMicrotask(() => {
-      if (this.#pendingUpdate && this.isConnected) {
-        this.#performUpdate(previousState);
-      }
-    });
-  }
-  #performUpdate(previousState) {
-    this.#isRendering = true;
-    this.#pendingUpdate = false;
-    const wasFirstRender = !this.#hasRendered;
-    const prevState = previousState || { ...this.#state };
-    try {
-      this.#updateDOM();
-      this.#hasRendered = true;
-      if (!wasFirstRender && typeof this.componentDidUpdate === "function") {
-        this.componentDidUpdate(this.#state, prevState);
-      }
-    } catch (error) {
-      console.error("Error during component update:", error);
-    } finally {
-      this.#isRendering = false;
-    }
-  }
-  static #trustedTypesPolicy = (() => {
-    if (typeof window !== "undefined" && window.trustedTypes && window.trustedTypes.createPolicy) {
-      try {
-        return window.trustedTypes.createPolicy("reactive-component", {
-          createHTML: (string) => string
-        });
-      } catch (e) {
-        console.warn("Failed to create trusted types policy:", e);
-        return null;
-      }
-    }
-    return null;
-  })();
-  #safeSetInnerHTML(element, html) {
-    if (ReactiveComponent.#trustedTypesPolicy) {
-      element.innerHTML = ReactiveComponent.#trustedTypesPolicy.createHTML(html);
-    } else {
-      element.innerHTML = html;
-    }
-  }
-  #updateDOM() {
-    if (!this.#shadow) {
-      this.#shadow = this.shadowRoot || this.attachShadow({ mode: "open" });
-      this.#setupEventDelegation();
-    }
-    if (typeof window !== "undefined" && window.trustedTypes && window.trustedTypes.emptyHTML) {
-      this.#shadow.innerHTML = window.trustedTypes.emptyHTML;
-    } else {
-      while (this.#shadow.firstChild) {
-        this.#shadow.removeChild(this.#shadow.firstChild);
-      }
-    }
-    const renderResult = this.render();
-    if (typeof renderResult === "string") {
-      const template = document.createElement("template");
-      this.#safeSetInnerHTML(template, renderResult);
-      this.#shadow.appendChild(template.content.cloneNode(true));
-    } else if (renderResult instanceof DocumentFragment || renderResult instanceof Element) {
-      this.#shadow.appendChild(renderResult);
-    }
-  }
-  #setupEventDelegation() {
-    this.#eventTypes.forEach((eventType) => {
-      const listener = (e) => {
-        this.#handleDelegatedEvent(e);
-      };
-      this.#delegatedEventListeners[eventType] = listener;
-      const usePassive = !["mousedown", "keydown", "submit"].includes(eventType);
-      this.#shadow.addEventListener(eventType, listener, {
-        passive: usePassive
-      });
-    });
-  }
-  #handleDelegatedEvent(e) {
-    const eventType = e.type;
-    const target = e.target;
-    if (!target)
-      return;
-    const handlerAttribute = `data-${eventType}`;
-    const elementsWithHandlers = this.#shadow.querySelectorAll(`[${handlerAttribute}]`);
-    Array.from(elementsWithHandlers).forEach((element) => {
-      if (target.isSameNode(element) || element.contains(target)) {
-        const handlerName = element.getAttribute(handlerAttribute);
-        if (handlerName && typeof this[handlerName] === "function") {
-          this[handlerName](e);
-        }
-      }
-    });
-  }
-  connectedCallback() {
-    if (this._stores && this._stores.length > 0) {
-      this._storeListeners = [];
-      this._stores.forEach((store) => {
-        const boundSetState = this.setState.bind(this);
-        store.addListener(boundSetState);
-        this._storeListeners.push({ store, listener: boundSetState });
-        const initialState = store.getState();
-        this.setState(initialState);
-      });
-    }
-    this.#performUpdate();
-    if (typeof this.componentDidMount === "function") {
-      this.componentDidMount();
-    }
-  }
-  disconnectedCallback() {
-    if (this.#shadow && Object.keys(this.#delegatedEventListeners).length > 0) {
-      this.#eventTypes.forEach((eventType) => {
-        const listener = this.#delegatedEventListeners[eventType];
-        if (listener) {
-          this.#shadow.removeEventListener(eventType, listener);
-        }
-      });
-      this.#delegatedEventListeners = {};
-    }
-    if (this._storeListeners && this._storeListeners.length > 0) {
-      this._storeListeners.forEach(({ store, listener }) => {
-        store.removeListener(listener);
-      });
-      this._storeListeners = [];
-    }
-  }
-}
-function render(componentName, props = {}, stores) {
-  const element = document.createElement(componentName);
-  const { appendTo = document.body, ...restProps } = props;
-  Object.keys(restProps).forEach((key) => {
-    const value = restProps[key];
-    if (value != null) {
-      const stringValue = typeof value === "object" ? JSON.stringify(value) : String(value);
-      element.setAttribute(key, stringValue);
-    }
-  });
-  if (stores && stores.length > 0) {
-    element._stores = stores;
-  }
-  if (appendTo instanceof HTMLElement) {
-    appendTo.appendChild(element);
-  }
-  return element;
-}
-var lazyStores = { current: {} };
-function registerStore(componentName, stores) {
-  const connectionSectionElement = document.querySelector("connection-section");
-  if (connectionSectionElement) {
-    connectionSectionElement._stores = stores;
-  } else {
-    lazyStores.current[componentName] = stores;
-  }
-}
-if (typeof document !== "undefined") {
-  document.addEventListener("DOMContentLoaded", () => {
-    const promise = Object.keys(lazyStores.current).map(async (componentName) => {
-      const connectionSectionElement = document.querySelector(componentName);
-      if (connectionSectionElement) {
-        connectionSectionElement._stores = lazyStores.current[componentName];
-        delete lazyStores.current[componentName];
-      }
-    });
-    Promise.all(promise);
-  });
-}

package/dist/types/ReactiveComponent.d.ts

@@ -1,64 +0,0 @@
-/**
- * ReactiveComponent - Base class for React-like Web Components
- * Adds state management and automatic re-rendering capabilities
- */
-interface ReactiveComponentOptions<T> {
-    initialState?: T;
-    shouldUpdate?: (newState: T, oldState: T) => boolean;
-}
-type StateCallbackHandler<TState> = (prevState: TState) => Partial<TState>;
-type StateType<TState> = Partial<TState> | StateCallbackHandler<TState> | TState;
-/**
- * Base class for reactive web components
- */
-export declare abstract class ReactiveComponent<TState = any> extends HTMLElement {
-    #private;
-    _stores?: Array<any>;
-    _storeListeners?: Array<{
-        store: any;
-        listener: Function;
-    }>;
-    constructor(options?: ReactiveComponentOptions<TState>);
-    /**
-     * Get current state (immutable)
-     */
-    get state(): Readonly<TState>;
-    /**
-     * Update state and trigger re-render (React-like setState)
-     * Also compatible with reshow-flux-base listener: setState(state, action, prevState)
-     */
-    setState(updator: StateType<TState>, _action?: any, prevState?: TState): TState;
-    /**
-     * Force a re-render without state change
-     */
-    forceUpdate(): void;
-    /**
-     * Lifecycle method - called when component is connected
-     */
-    connectedCallback(): void;
-    /**
-     * Lifecycle method - called when component is disconnected
-     */
-    disconnectedCallback(): void;
-    /**
-     * Optional lifecycle method - called after component updates
-     * Override this method to perform side effects after the component updates
-     */
-    componentDidUpdate?(newState: TState, previousState: TState): void;
-    /**
-     * Optional lifecycle method - called after component is mounted (first render)
-     * Override this method to perform setup logic after the component is added to DOM
-     */
-    componentDidMount?(): void;
-    /**
-     * Abstract render method - must be implemented by subclasses
-     */
-    abstract render(): string | DocumentFragment | Element;
-}
-export type { ReactiveComponentOptions };
-/**
- * Generic render function for ReactiveHTMLElement components
- * Creates and displays a component with specified componentName and optional stores
- */
-export declare function render<T extends ReactiveComponent>(componentName: string, props?: Record<string, any>, stores?: Array<any>): T;
-export declare function registerStore(componentName: string, stores: Array<any>): void;

package/dist/types/__tests__/ReactiveComponent.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/browser.d.ts

@@ -1 +0,0 @@
-export { ReactiveComponent, render, registerStore } from "./ReactiveComponent";