@almadar/ui 5.75.0 → 5.76.1

package/dist/hooks/useAgentTrace.d.ts

@@ -1,85 +0,0 @@
-import type { TraceActivity, TraceSubagent, TraceSubagentMessage, TraceChatMessage } from '@almadar/core';
-/** Coarse run status surfaced by the trace UI (drives ChatBar's action button). */
-export type TraceStatus = 'idle' | 'running' | 'paused' | 'complete' | 'error';
-/** The accumulated view-model the trace components render. */
-export interface AgentTraceState {
-    activities: TraceActivity[];
-    subagents: TraceSubagent[];
-    coordinatorMessages: TraceChatMessage[];
-    status: TraceStatus;
-}
-/**
- * A pre-mapped update the runner feeds in. Each variant is a view-model delta —
- * no raw SSE/transport shapes. Subagents upsert by `id`; coordinator messages
- * upsert by index (the runner owns ordering); activities append.
- */
-export type TraceUpdate = 
-/** Append one already-mapped activity to the page-level stream. */
-{
-    kind: 'activity';
-    activity: TraceActivity;
-}
-/**
- * Upsert a subagent by `id`. A partial patch merges into the existing record
- * (status/duration/task changes); a full record inserts when `id` is new.
- */
- | {
-    kind: 'subagent-upsert';
-    id: string;
-    subagent: SubagentUpsert;
-}
-/** Append a progress message to a known subagent's running log. */
- | {
-    kind: 'subagent-message';
-    id: string;
-    message: TraceSubagentMessage;
-}
-/**
- * Set a coordinator message at `index`. The runner emits messages in order;
- * a known index replaces (e.g. streaming content grew), a new index appends.
- */
- | {
-    kind: 'coordinator-message';
-    index: number;
-    message: TraceChatMessage;
-}
-/** Set the coarse run status. */
- | {
-    kind: 'status';
-    status: TraceStatus;
-}
-/** Reset the whole view-model (new turn). */
- | {
-    kind: 'reset';
-};
-/**
- * A subagent upsert payload: every field optional except `name`/`role`/`task`
- * are required only when the id is new. Partial patches merge into the existing
- * record; that's why the fields are all optional here and the reducer fills
- * defaults on first insert.
- */
-export interface SubagentUpsert {
-    name?: string;
-    role?: string;
-    orbitalName?: string;
-    parentId?: string;
-    status?: TraceSubagent['status'];
-    task?: string;
-    durationMs?: number;
-}
-/** What the hook returns: the state plus an `apply` to feed it updates. */
-export interface UseAgentTraceResult extends AgentTraceState {
-    /** Apply one pre-mapped view-model update (from the runner). */
-    apply: (update: TraceUpdate) => void;
-    /** Apply a batch of updates in order (single render). */
-    applyAll: (updates: readonly TraceUpdate[]) => void;
-    /** Reset to the empty view-model. */
-    reset: () => void;
-}
-/**
- * Accumulate agent-trace view-model from pre-mapped updates.
- *
- * The consumer maps SSE/runner events to `TraceUpdate`s upstream and calls
- * `apply`/`applyAll`; this hook holds nothing but the accumulated render state.
- */
-export declare function useAgentTrace(): UseAgentTraceResult;

package/dist/hooks/useEntities.d.ts

@@ -1,52 +0,0 @@
-import { getEntity, getByType, getAllEntities, getSingleton, spawnEntity, updateEntity, updateSingleton, removeEntity, clearEntities } from '../stores/entityStore';
-import type { Entity } from '../stores/entityStore';
-export type { Entity };
-/**
- * Hook to access all entities
- */
-export declare function useEntities(): {
-    entities: Map<string, Entity>;
-    getEntity: typeof getEntity;
-    getByType: typeof getByType;
-    getAllEntities: typeof getAllEntities;
-    getSingleton: typeof getSingleton;
-    spawnEntity: typeof spawnEntity;
-    updateEntity: typeof updateEntity;
-    updateSingleton: typeof updateSingleton;
-    removeEntity: typeof removeEntity;
-    clearEntities: typeof clearEntities;
-};
-/**
- * Hook to access a specific entity by ID
- */
-export declare function useEntity(id: string): Entity | undefined;
-/**
- * Hook to access entities of a specific type
- */
-export declare function useEntitiesByType(type: string): Entity[];
-/**
- * Hook to access a singleton entity by type
- */
-export declare function useSingletonEntity<T extends Entity = Entity>(type: string): T | undefined;
-/**
- * Hook for Player entity (convenience)
- */
-export declare function usePlayer(): {
-    player: Entity | undefined;
-    updatePlayer: (updates: Partial<Entity>) => void;
-};
-/**
- * Hook for Physics entity (convenience)
- */
-export declare function usePhysics(): {
-    physics: Entity | undefined;
-    updatePhysics: (updates: Partial<Entity>) => void;
-};
-/**
- * Hook for Input entity (convenience)
- */
-export declare function useInput(): {
-    input: Entity | undefined;
-    updateInput: (updates: Partial<Entity>) => void;
-};
-export { spawnEntity, updateEntity, updateSingleton, removeEntity, clearEntities, getEntity, getByType, getAllEntities, getSingleton, };

package/dist/hooks/usePinchZoom.d.ts

@@ -1,22 +0,0 @@
-import type React from 'react';
-export interface PinchZoomResult {
-    /** Current zoom scale (1 = no zoom) */
-    scale: number;
-    /** Whether a pinch gesture is active */
-    isPinching: boolean;
-    /** Props to spread on the zoomable container */
-    gestureProps: {
-        onTouchStart: (e: React.TouchEvent) => void;
-        onTouchMove: (e: React.TouchEvent) => void;
-        onTouchEnd: () => void;
-    };
-    /** Reset zoom to 1 */
-    resetZoom: () => void;
-}
-export interface PinchZoomOptions {
-    /** Minimum zoom scale (default: 0.5) */
-    minScale?: number;
-    /** Maximum zoom scale (default: 4) */
-    maxScale?: number;
-}
-export declare function usePinchZoom(options?: PinchZoomOptions): PinchZoomResult;

package/dist/runtime/types.d.ts

@@ -1,37 +0,0 @@
-/**
- * OrbitalRuntime Types
- *
- * Re-exports IR types from @almadar/core.
- * This ensures runtime uses the same types as the compiler.
- *
- * @packageDocumentation
- */
-export type { TransitionFrom, ResolvedField, ResolvedEntity, ResolvedEntityBinding, ResolvedTraitState, ResolvedTraitEvent, ResolvedTraitTransition, ResolvedTraitGuard, ResolvedTraitTick, ResolvedTraitDataEntity, ResolvedTraitUIBinding, ResolvedTrait, ResolvedTraitBinding, ResolvedPattern, ResolvedSectionEvent, ResolvedSection, ResolvedNavigation, ResolvedPage, ResolvedIR, } from '@almadar/core';
-import type { ResolvedTraitListener as CoreResolvedTraitListener } from '@almadar/core';
-/**
- * Listen scope descriptor carried by the resolved orb at runtime.
- *
- * Emitted by the compiler in the `listens[i].source` field of each
- * `ResolvedTraitListener`. Core's type doesn't declare this field yet
- * (@almadar/core 5.7.0) even though the Rust compiler and .lolo parser
- * both populate it. We declare it here in @almadar/ui (the consumer)
- * rather than modify core.
- *
- * - `any`: accept emits from any trait
- * - `trait`: only accept emits whose `BusEvent.source.trait` matches
- * - `orbital`: only accept emits whose `source.orbital[.trait?]` matches
- */
-export interface ListenSource {
-    kind?: 'any' | 'trait' | 'orbital';
-    trait?: string;
-    orbital?: string;
-}
-/**
- * Extended `ResolvedTraitListener` carrying the runtime-only `source`
- * scope descriptor that `@almadar/core`'s type hasn't picked up yet.
- * Intended as a local shim until core publishes a version with `source`.
- */
-export type ResolvedTraitListener = CoreResolvedTraitListener & {
-    source?: ListenSource;
-};
-export { createEmptyResolvedTrait, createEmptyResolvedPage, createResolvedField, inferTsType, isResolvedIR, } from '@almadar/core';

package/dist/stores/entityStore.d.ts

@@ -1,99 +0,0 @@
-/**
- * Entity Store
- *
- * Simple module-level store for runtime entities.
- * No providers needed - hooks import and use directly.
- *
- * NOTE: Mutations create new Map instances to trigger React rerenders
- * when using useSyncExternalStore.
- */
-import { type EntityFilterValue, type FilterOperator, type EntityFilters, applyFilters, createFilter } from './filtering';
-export type { EntityFilterValue, FilterOperator, EntityFilters };
-export { applyFilters, createFilter };
-export interface Entity {
-    id: string;
-    type: string;
-    [key: string]: unknown;
-}
-type Listener = () => void;
-/**
- * Subscribe to store changes
- */
-export declare function subscribe(listener: Listener): () => void;
-/**
- * Get all entities
- */
-export declare function getEntities(): Map<string, Entity>;
-/**
- * Get entity by ID
- */
-export declare function getEntity(id: string): Entity | undefined;
-/**
- * Get entities by type
- */
-export declare function getByType(type: string | string[]): Entity[];
-/**
- * Get all entities as array
- */
-export declare function getAllEntities(): Entity[];
-/**
- * Get singleton entity by type (first of that type)
- */
-export declare function getSingleton(type: string): Entity | undefined;
-/**
- * Spawn a new entity
- */
-export declare function spawnEntity(config: {
-    type: string;
-    id?: string;
-    [key: string]: unknown;
-}): string;
-/**
- * Update an entity
- */
-export declare function updateEntity(id: string, updates: Partial<Entity>): void;
-/**
- * Update singleton entity by type
- */
-export declare function updateSingleton(type: string, updates: Partial<Entity>): void;
-/**
- * Remove an entity
- */
-export declare function removeEntity(id: string): void;
-/**
- * Clear all entities
- */
-export declare function clearEntities(): void;
-/**
- * Set a filter for an entity type
- * @param entityType - The entity type to filter (e.g., "Player", "Enemy")
- * @param field - The filter key (e.g., 'status' or 'date_from')
- * @param value - The filter value
- * @param operator - The comparison operator
- * @param targetField - The actual record field to compare (defaults to field)
- */
-export declare function setFilter(entityType: string, field: string, value: unknown, operator?: FilterOperator, targetField?: string): void;
-/**
- * Clear a specific filter
- */
-export declare function clearFilter(entityType: string, field: string): void;
-/**
- * Clear all filters for an entity type
- */
-export declare function clearAllFilters(entityType: string): void;
-/**
- * Get active filters for an entity type
- */
-export declare function getFilters(entityType: string): EntityFilters;
-/**
- * Get entities by type with optional filtering
- */
-export declare function getByTypeFiltered(type: string | string[]): Entity[];
-/**
- * Get snapshot for React useSyncExternalStore
- */
-export declare function getSnapshot(): Map<string, Entity>;
-/**
- * Get filter snapshot for React useSyncExternalStore
- */
-export declare function getFilterSnapshot(): Map<string, EntityFilters>;

package/dist/stores/filtering.d.ts

@@ -1,51 +0,0 @@
-/**
- * Entity Filtering Utilities
- *
- * Provides filter types and utility functions for filtering entity records.
- * Used by EntityStore and can be imported by runtime preview.
- */
-/** Filter value for a single field (entity filtering) */
-export interface EntityFilterValue {
-    /** The field key (may include suffix like _from, _to for date ranges) */
-    field: string;
-    /** The actual record field to compare against (defaults to field if not specified) */
-    targetField?: string;
-    value: unknown;
-    /** Comparison operator for filtering
-     * - eq: exact match (default)
-     * - contains: substring match for strings
-     * - in: value is in array
-     * - date_eq: same date (ignoring time)
-     * - date_gte: on or after date
-     * - date_lte: on or before date
-     */
-    operator?: FilterOperator;
-}
-/** Operator type for filter */
-export type FilterOperator = 'eq' | 'contains' | 'in' | 'date_eq' | 'date_gte' | 'date_lte' | 'search';
-/** Filter state for an entity - Map of field key to filter value */
-export type EntityFilters = Map<string, EntityFilterValue>;
-/** Record type that can be filtered */
-export interface FilterableRecord {
-    id: string;
-    [key: string]: unknown;
-}
-/**
- * Extract date part from ISO string or Date object.
- * Returns format: "YYYY-MM-DD"
- */
-export declare function getDateString(value: unknown): string | null;
-/**
- * Apply a single filter to check if a record matches.
- * Returns true if the record passes the filter.
- */
-export declare function matchesFilter(record: FilterableRecord, filter: EntityFilterValue): boolean;
-/**
- * Apply all filters to a list of records.
- * Returns only records that match ALL filters.
- */
-export declare function applyFilters<T extends FilterableRecord>(records: T[], entityFilters: EntityFilters): T[];
-/**
- * Create a filter value with proper defaults.
- */
-export declare function createFilter(field: string, value: unknown, operator?: FilterOperator, targetField?: string): EntityFilterValue;

package/dist/stores/index.cjs

@@ -1,217 +0,0 @@
-'use strict';
-
-// stores/filtering.ts
-function getDateString(value) {
-  if (!value) return null;
-  if (typeof value === "string") {
-    const match = value.match(/^(\d{4}-\d{2}-\d{2})/);
-    return match ? match[1] : null;
-  }
-  if (value instanceof Date) {
-    return value.toISOString().split("T")[0];
-  }
-  return null;
-}
-function matchesFilter(record, filter) {
-  const fieldToCompare = filter.targetField || filter.field;
-  const recordValue = record[fieldToCompare];
-  const filterValue = filter.value;
-  const operator = filter.operator || "eq";
-  if (filterValue === null || filterValue === void 0 || filterValue === "") {
-    return true;
-  }
-  switch (operator) {
-    case "eq":
-      if (typeof recordValue === "string" && typeof filterValue === "string") {
-        return recordValue.toLowerCase() === filterValue.toLowerCase();
-      }
-      return recordValue === filterValue;
-    case "contains":
-      if (typeof recordValue !== "string") return false;
-      return recordValue.toLowerCase().includes(String(filterValue).toLowerCase());
-    case "in":
-      if (Array.isArray(filterValue)) {
-        const normalizedFilterValues = filterValue.map(
-          (v) => typeof v === "string" ? v.toLowerCase() : v
-        );
-        const normalizedRecordValue = typeof recordValue === "string" ? recordValue.toLowerCase() : recordValue;
-        return normalizedFilterValues.includes(normalizedRecordValue);
-      }
-      return false;
-    case "date_eq": {
-      const recordDate = getDateString(recordValue);
-      const filterDate = getDateString(filterValue);
-      return Boolean(recordDate && filterDate && recordDate === filterDate);
-    }
-    case "date_gte": {
-      const recordDate = getDateString(recordValue);
-      const filterDate = getDateString(filterValue);
-      return Boolean(recordDate && filterDate && recordDate >= filterDate);
-    }
-    case "date_lte": {
-      const recordDate = getDateString(recordValue);
-      const filterDate = getDateString(filterValue);
-      return Boolean(recordDate && filterDate && recordDate <= filterDate);
-    }
-    case "search": {
-      if (typeof filterValue !== "string" || !filterValue.trim()) {
-        return true;
-      }
-      const searchTerm = filterValue.toLowerCase();
-      return Object.values(record).some((value) => {
-        if (value === null || value === void 0) return false;
-        return String(value).toLowerCase().includes(searchTerm);
-      });
-    }
-    default:
-      return true;
-  }
-}
-function applyFilters(records, entityFilters) {
-  if (entityFilters.size === 0) return records;
-  return records.filter((record) => {
-    for (const [, filter] of entityFilters) {
-      if (!matchesFilter(record, filter)) {
-        return false;
-      }
-    }
-    return true;
-  });
-}
-function createFilter(field, value, operator = "eq", targetField) {
-  return {
-    field,
-    value,
-    operator,
-    targetField: targetField || field
-  };
-}
-
-// stores/entityStore.ts
-var entities = /* @__PURE__ */ new Map();
-var filters = /* @__PURE__ */ new Map();
-var listeners = /* @__PURE__ */ new Set();
-var idCounter = 0;
-function subscribe(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-function notify() {
-  listeners.forEach((listener) => listener());
-}
-function getEntities() {
-  return entities;
-}
-function getEntity(id) {
-  return entities.get(id);
-}
-function getByType(type) {
-  const types = Array.isArray(type) ? type : [type];
-  return [...entities.values()].filter((e) => types.includes(e.type));
-}
-function getAllEntities() {
-  return [...entities.values()];
-}
-function getSingleton(type) {
-  return [...entities.values()].find((e) => e.type === type);
-}
-function spawnEntity(config) {
-  const id = config.id ?? `entity_${++idCounter}`;
-  const entity = { ...config, id };
-  entities = new Map(entities);
-  entities.set(id, entity);
-  notify();
-  return id;
-}
-function updateEntity(id, updates) {
-  const entity = entities.get(id);
-  if (entity) {
-    entities = new Map(entities);
-    entities.set(id, { ...entity, ...updates });
-    notify();
-  }
-}
-function updateSingleton(type, updates) {
-  const entity = getSingleton(type);
-  if (entity) {
-    updateEntity(entity.id, updates);
-  }
-}
-function removeEntity(id) {
-  if (entities.has(id)) {
-    entities = new Map(entities);
-    entities.delete(id);
-    notify();
-  }
-}
-function clearEntities() {
-  entities = /* @__PURE__ */ new Map();
-  notify();
-}
-function setFilter(entityType, field, value, operator = "eq", targetField) {
-  filters = new Map(filters);
-  const entityFilters = new Map(filters.get(entityType) || []);
-  entityFilters.set(field, createFilter(field, value, operator, targetField));
-  filters.set(entityType, entityFilters);
-  notify();
-}
-function clearFilter(entityType, field) {
-  const entityFilters = filters.get(entityType);
-  if (entityFilters && entityFilters.has(field)) {
-    filters = new Map(filters);
-    const newFilters = new Map(entityFilters);
-    newFilters.delete(field);
-    filters.set(entityType, newFilters);
-    notify();
-  }
-}
-function clearAllFilters(entityType) {
-  if (filters.has(entityType)) {
-    filters = new Map(filters);
-    filters.set(entityType, /* @__PURE__ */ new Map());
-    notify();
-  }
-}
-function getFilters(entityType) {
-  return filters.get(entityType) || /* @__PURE__ */ new Map();
-}
-function getByTypeFiltered(type) {
-  const types = Array.isArray(type) ? type : [type];
-  let result = [...entities.values()].filter((e) => types.includes(e.type));
-  for (const t of types) {
-    const typeFilters = filters.get(t);
-    if (typeFilters && typeFilters.size > 0) {
-      result = applyFilters(result, typeFilters);
-    }
-  }
-  return result;
-}
-function getSnapshot() {
-  return entities;
-}
-function getFilterSnapshot() {
-  return filters;
-}
-
-exports.applyFilters = applyFilters;
-exports.clearAllFilters = clearAllFilters;
-exports.clearEntities = clearEntities;
-exports.clearFilter = clearFilter;
-exports.createFilter = createFilter;
-exports.getAllEntities = getAllEntities;
-exports.getByType = getByType;
-exports.getByTypeFiltered = getByTypeFiltered;
-exports.getDateString = getDateString;
-exports.getEntities = getEntities;
-exports.getEntity = getEntity;
-exports.getFilterSnapshot = getFilterSnapshot;
-exports.getFilters = getFilters;
-exports.getSingleton = getSingleton;
-exports.getSnapshot = getSnapshot;
-exports.matchesFilter = matchesFilter;
-exports.removeEntity = removeEntity;
-exports.setFilter = setFilter;
-exports.spawnEntity = spawnEntity;
-exports.subscribe = subscribe;
-exports.updateEntity = updateEntity;
-exports.updateSingleton = updateSingleton;

package/dist/stores/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Stores
- *
- * Module-level state management for entities and filtering.
- */
-export * from './filtering';
-export * from './entityStore';