@ratiosolver/coco 0.0.2

package/README.md

@@ -0,0 +1,3 @@
+# CoCo-lib
+
+The deduCtiOn and abduCtiOn (CoCo) visualization library.

package/dist/coco/coco.d.ts

@@ -0,0 +1,313 @@
+export declare namespace coco {
+    class CoCo implements CoCoListener {
+        private static instance;
+        private readonly property_types;
+        private readonly types;
+        private readonly items;
+        private readonly intents;
+        private readonly entities;
+        private readonly coco_listeners;
+        private constructor();
+        static get_instance(): CoCo;
+        add_property_type(pt: taxonomy.PropertyType<any>): void;
+        get_types(): MapIterator<taxonomy.Type>;
+        get_items(): MapIterator<taxonomy.Item>;
+        new_type(type: taxonomy.Type): void;
+        new_item(item: taxonomy.Item): void;
+        new_intent(intent: llm.Intent): void;
+        new_entity(entity: llm.Entity): void;
+        /**
+         * Loads data for a given taxonomy item within a specified date range.
+         *
+         * @param item - The taxonomy item for which data is to be loaded.
+         * @param from - The start date of the range (in milliseconds since the Unix epoch). Defaults to 14 days ago.
+         * @param to - The end date of the range (in milliseconds since the Unix epoch). Defaults to the current date and time.
+         *
+         * If the request is successful, the item's values are updated with the fetched data.
+         * If the request fails, an error message is displayed using the application's toast mechanism.
+         */
+        load_data(item: taxonomy.Item, from?: number, to?: number): void;
+        publish(item: taxonomy.Item, data: Record<string, unknown>): void;
+        fake_data(type: taxonomy.Type, pars?: string[] | undefined): Promise<Record<string, unknown>>;
+        update_coco(message: UpdateCoCoMessage | any): void;
+        private init;
+        private refine_type;
+        private make_item;
+        get_type(name: string): taxonomy.Type;
+        get_item(id: string): taxonomy.Item;
+        add_coco_listener(listener: CoCoListener): void;
+        remove_coco_listener(listener: CoCoListener): void;
+    }
+    interface CoCoListener {
+        new_type(type: taxonomy.Type): void;
+        new_item(item: taxonomy.Item): void;
+        new_intent(intent: llm.Intent): void;
+        new_entity(entity: llm.Entity): void;
+    }
+    namespace taxonomy {
+        abstract class PropertyType<P extends Property<unknown>> {
+            protected readonly cc: CoCo;
+            private readonly name;
+            constructor(cc: CoCo, name: string);
+            get_name(): string;
+            abstract make_property(property_message: PropertyMessage | any): P;
+            abstract to_string(val: unknown): string;
+        }
+        class BoolPropertyType extends PropertyType<BoolProperty> {
+            constructor(cc: CoCo);
+            make_property(property_message: PropertyMessage | any): BoolProperty;
+            to_string(val: boolean): string;
+        }
+        class IntPropertyType extends PropertyType<IntProperty> {
+            constructor(cc: CoCo);
+            make_property(property_message: PropertyMessage | any): IntProperty;
+            to_string(val: number): string;
+        }
+        class FloatPropertyType extends PropertyType<FloatProperty> {
+            constructor(cc: CoCo);
+            make_property(property_message: PropertyMessage | any): FloatProperty;
+            to_string(val: number): string;
+        }
+        class StringPropertyType extends PropertyType<StringProperty> {
+            constructor(cc: CoCo);
+            make_property(property_message: PropertyMessage | any): StringProperty;
+            to_string(val: string): string;
+        }
+        class SymbolPropertyType extends PropertyType<SymbolProperty> {
+            constructor(cc: CoCo);
+            make_property(property_message: PropertyMessage | any): SymbolProperty;
+            to_string(val: string | string[]): string;
+        }
+        class ItemPropertyType extends PropertyType<ItemProperty> {
+            constructor(cc: CoCo);
+            make_property(property_message: PropertyMessage | any): ItemProperty;
+            to_string(val: string | string[]): string;
+        }
+        class JSONPropertyType extends PropertyType<JSONProperty> {
+            constructor(cc: CoCo);
+            make_property(property_message: PropertyMessage | any): JSONProperty;
+            to_string(val: JSON): string;
+        }
+        class Property<V> {
+            protected readonly type: PropertyType<Property<V>>;
+            protected readonly default_value: V | undefined;
+            constructor(type: PropertyType<Property<V>>, default_value?: V);
+            get_type(): PropertyType<Property<V>>;
+            has_default_value(): boolean;
+            get_default_value(): V | undefined;
+            to_string(): string;
+        }
+        class BoolProperty extends Property<boolean> {
+            constructor(type: BoolPropertyType, default_value?: boolean);
+            to_string(): string;
+        }
+        class IntProperty extends Property<number> {
+            private readonly min?;
+            private readonly max?;
+            constructor(type: IntPropertyType, min?: number, max?: number, default_value?: number);
+            get_min(): number | undefined;
+            get_max(): number | undefined;
+            to_string(): string;
+        }
+        class FloatProperty extends Property<number> {
+            private readonly min?;
+            private readonly max?;
+            constructor(type: FloatPropertyType, min?: number, max?: number, default_value?: number);
+            get_min(): number | undefined;
+            get_max(): number | undefined;
+            to_string(): string;
+        }
+        class StringProperty extends Property<string> {
+            constructor(type: StringPropertyType, default_value?: string);
+            to_string(): string;
+        }
+        class SymbolProperty extends Property<string | string[]> {
+            private readonly multiple;
+            private readonly symbols?;
+            constructor(type: SymbolPropertyType, multiple: boolean, symbols?: string[], default_value?: string | string[]);
+            is_multiple(): boolean;
+            get_symbols(): string[] | undefined;
+            to_string(): string;
+        }
+        class ItemProperty extends Property<Item | Item[]> {
+            private readonly domain;
+            private readonly multiple;
+            constructor(type: ItemPropertyType, domain: Type, multiple: boolean, default_value?: Item | Item[]);
+            get_domain(): Type;
+            is_multiple(): boolean;
+            to_string(): string;
+        }
+        class JSONProperty extends Property<Record<string, any>> {
+            private readonly schema;
+            constructor(type: JSONPropertyType, schema: Record<string, any>, default_value?: Record<string, any>);
+            to_string(): string;
+        }
+        class Type {
+            private readonly name;
+            private parents?;
+            private data?;
+            private static_properties?;
+            private dynamic_properties?;
+            readonly _instances: Set<Item>;
+            private readonly listeners;
+            constructor(name: string, parents?: Type[], data?: Record<string, any>, static_properties?: Map<string, Property<unknown>>, dynamic_properties?: Map<string, Property<unknown>>);
+            get_name(): string;
+            get_parents(): Type[] | undefined;
+            get_data(): Record<string, any> | undefined;
+            get_static_properties(): Map<string, Property<unknown>> | undefined;
+            get_all_static_properties(): Map<string, Property<unknown>>;
+            get_dynamic_properties(): Map<string, Property<unknown>> | undefined;
+            get_all_dynamic_properties(): Map<string, Property<unknown>>;
+            get_instances(): Set<Item>;
+            _set_parents(ps?: Type[]): void;
+            _set_data(data?: Record<string, any>): void;
+            _set_static_properties(sp?: Map<string, Property<unknown>>): void;
+            _set_dynamic_properties(dp?: Map<string, Property<unknown>>): void;
+            to_string(): string;
+            add_type_listener(l: TypeListener): void;
+            remove_type_listener(l: TypeListener): void;
+        }
+        interface TypeListener {
+            parents_updated(type: Type): void;
+            data_updated(type: Type): void;
+            static_properties_updated(type: Type): void;
+            dynamic_properties_updated(type: Type): void;
+        }
+        type Datum = {
+            data: Record<string, unknown>;
+            timestamp: Date;
+        };
+        class Item {
+            private readonly id;
+            private readonly type;
+            private properties?;
+            private datum?;
+            private slots?;
+            private data;
+            private readonly listeners;
+            constructor(id: string, type: Type, properties?: Record<string, unknown>, value?: Datum, slots?: Record<string, unknown>);
+            get_id(): string;
+            get_type(): Type;
+            get_properties(): Record<string, unknown> | undefined;
+            get_datum(): Datum | undefined;
+            get_data(): Datum[];
+            get_slots(): Record<string, unknown> | undefined;
+            _set_properties(props?: Record<string, unknown>): void;
+            _set_data(data: Datum[]): void;
+            _set_datum(datum: Datum): void;
+            _set_slots(slots?: Record<string, unknown>): void;
+            add_item_listener(l: ItemListener): void;
+            remove_item_listener(l: ItemListener): void;
+            to_string(): string;
+        }
+        interface ItemListener {
+            properties_updated(item: Item): void;
+            values_updated(item: Item): void;
+            new_value(item: Item, v: Datum): void;
+            slots_updated(item: Item): void;
+        }
+    }
+    class User {
+        private readonly id;
+        private readonly personal_data;
+        constructor(id: string, personal_data: Record<string, unknown>);
+        get_id(): string;
+        get_personal_data(): Record<string, unknown>;
+    }
+    namespace llm {
+        class Intent {
+            private readonly name;
+            private readonly description;
+            constructor(name: string, description: string);
+            get_name(): string;
+            get_description(): string;
+        }
+        enum EntityType {
+            string = 0,
+            int = 1,
+            float = 2,
+            bool = 3,
+            symbol = 4
+        }
+        class Entity {
+            private readonly name;
+            private readonly type;
+            private readonly description;
+            constructor(name: string, type: EntityType, description: string);
+            get_name(): string;
+            get_type(): EntityType;
+            get_description(): string;
+        }
+    }
+}
+type UpdateCoCoMessage = {
+    msg_type: string;
+} & (CoCoMessage | NewTypeMessage | NewItemMessage | NewDataMessage);
+interface CoCoMessage {
+    types?: Record<string, TypeMessage>;
+    items?: Record<string, ItemMessage>;
+    intents?: Record<string, IntentMessage>;
+    entities?: Record<string, EntityMessage>;
+}
+interface NewTypeMessage extends TypeMessage {
+    name: string;
+}
+interface NewItemMessage extends ItemMessage {
+    id: string;
+}
+interface NewDataMessage extends ValueMessage {
+    id: string;
+}
+interface PropMessage<V> {
+    type: string;
+    default_value?: V;
+}
+interface BoolPropertyMessage extends PropMessage<boolean> {
+}
+interface IntPropertyMessage extends PropMessage<number> {
+    min?: number;
+    max?: number;
+}
+interface FloatPropertyMessage extends PropMessage<number> {
+    min?: number;
+    max?: number;
+}
+interface StringPropertyMessage extends PropMessage<string> {
+}
+interface SymbolPropertyMessage extends PropMessage<string | string[]> {
+    multiple: boolean;
+    values?: string[];
+}
+interface ItemPropertyMessage extends PropMessage<string | string[]> {
+    domain: string;
+    multiple: boolean;
+}
+interface JSONPropertyMessage extends PropMessage<Record<string, any>> {
+    schema: Record<string, any>;
+}
+type PropertyMessage = BoolPropertyMessage | IntPropertyMessage | FloatPropertyMessage | StringPropertyMessage | SymbolPropertyMessage | ItemPropertyMessage | JSONPropertyMessage;
+interface TypeMessage {
+    parents?: string[];
+    data?: Record<string, any>;
+    static_properties?: Record<string, PropertyMessage>;
+    dynamic_properties?: Record<string, PropertyMessage>;
+}
+interface ValueMessage {
+    data: Record<string, unknown>;
+    timestamp: number;
+}
+interface ItemMessage {
+    type: string;
+    properties?: Record<string, unknown>;
+    value?: ValueMessage;
+}
+interface IntentMessage {
+    name: string;
+    description: string;
+}
+interface EntityMessage {
+    name: string;
+    type: string;
+    description: string;
+}
+export {};