@kosdev-code/kos-ui-sdk 0.1.0-dev.5053

package/models/models/kos-time/kos-time-registration.d.ts

@@ -0,0 +1,87 @@
+import { KosTimeOptions } from './types';
+import { KosTimeModel } from './kos-time-model';
+import { SingletonKosModelRegistrationBean } from '../../../core';
+
+/**
+ * # KosTime
+ *
+ * The registration bean includes convenience methods for creating and working with KosTimeModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: KosTime.type, id: "kosTimeId"})
+ * private kosTimeModel: KosTimeModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new KosTimeModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = KosTime.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a KosTimeModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (KosTime.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to KosTimeModel
+ *    // and the compiler will know that the model has the KosTimeModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { KosTime } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...KosTime.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The kosTime model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ * @private
+ * */
+export declare const KosTime: Readonly<SingletonKosModelRegistrationBean<KosTimeModel, KosTimeOptions>>;
+//# sourceMappingURL=kos-time-registration.d.ts.map

package/models/models/kos-time/kos-time-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-time-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-time/kos-time-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,eAAe,CAAC;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,OAAO,EAAE,QAAQ,CAC5B,iCAAiC,CAAC,YAAY,EAAE,cAAc,CAAC,CAWhE,CAAC"}

package/models/models/kos-time/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './kos-time-services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/kos-time/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-time/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/models/models/kos-time/services/kos-time-services.d.ts

@@ -0,0 +1,16 @@
+interface TimeBean {
+    hour: number;
+    min: number;
+    sec: number;
+}
+interface DateBean {
+    month: number;
+    day: number;
+    year: number;
+}
+export declare const setTime: (time: TimeBean) => Promise<any>;
+export declare const setDate: (date: DateBean) => Promise<any>;
+export declare const setTimezone: (timezone: string) => Promise<any>;
+export declare const getTimezone: () => Promise<string>;
+export {};
+//# sourceMappingURL=kos-time-services.d.ts.map

package/models/models/kos-time/services/kos-time-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-time-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-time/services/kos-time-services.ts"],"names":[],"mappings":"AAWA,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,UAAU,QAAQ;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAcD,eAAO,MAAM,OAAO,SAAgB,QAAQ,iBAW3C,CAAC;AAEF,eAAO,MAAM,OAAO,SAAgB,QAAQ,iBAW3C,CAAC;AAEF,eAAO,MAAM,WAAW,aAAoB,MAAM,iBAUjD,CAAC;AAEF,eAAO,MAAM,WAAW,uBAUvB,CAAC"}

package/models/models/kos-time/types/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Time value structure for system time operations.
+ *
+ * Represents a specific time of day with hour, minute, and second components.
+ * Used when updating system time through the KosTime model.
+ *
+ * @example
+ * ```typescript
+ * const morningTime: TimeBean = {
+ *   hour: 9,    // 9 AM (24-hour format)
+ *   min: 30,    // 30 minutes
+ *   sec: 0      // 0 seconds
+ * };
+ *
+ * const afternoonTime: TimeBean = {
+ *   hour: 15,   // 3 PM (24-hour format)
+ *   min: 45,
+ *   sec: 30
+ * };
+ *
+ * await timeModel.updateSystemTime(morningTime);
+ * ```
+ *
+ * @category System Integration
+ * @category Time Management
+ */
+export interface TimeBean {
+  /** Hour in 24-hour format (0-23) */
+  hour: number;
+  /** Minutes (0-59) */
+  min: number;
+  /** Seconds (0-59) */
+  sec: number;
+}
+
+/**
+ * Date value structure for system date operations.
+ *
+ * Represents a specific calendar date with month, day, and year components.
+ * Used when updating system date through the KosTime model.
+ *
+ * @example
+ * ```typescript
+ * const newYear: DateBean = {
+ *   month: 1,   // January
+ *   day: 1,     // 1st
+ *   year: 2024  // 2024
+ * };
+ *
+ * const independence: DateBean = {
+ *   month: 7,   // July
+ *   day: 4,     // 4th
+ *   year: 2024
+ * };
+ *
+ * await timeModel.updateSystemDate(newYear);
+ * ```
+ *
+ * @category System Integration
+ * @category Time Management
+ */
+export interface DateBean {
+  /** Month (1-12, where 1 = January, 12 = December) */
+  month: number;
+  /** Day of the month (1-31, depending on month) */
+  day: number;
+  /** Full year (e.g., 2024) */
+  year: number;
+}
+
+/**
+ * Configuration options for KosTime model instances.
+ *
+ * Currently an empty interface but reserved for future time-related
+ * configuration options such as default timezone, time format preferences,
+ * or synchronization settings.
+ *
+ * @example
+ * ```typescript
+ * const options: KosTimeOptions = {
+ *   // Future options will be added here
+ * };
+ *
+ * const timeModel = KosTime.instance()
+ *   .options(options)
+ *   .build();
+ * ```
+ *
+ * @category Model Configuration
+ * @category System Integration
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface KosTimeOptions {}

package/models/models/kos-token/index.d.ts

@@ -0,0 +1,11 @@
+export interface IKosToken {
+    token?: string;
+}
+declare class KosToken implements IKosToken {
+    private _token?;
+    constructor();
+    get token(): string | undefined;
+    set token(token: string | undefined);
+}
+export default KosToken;
+//# sourceMappingURL=index.d.ts.map

package/models/models/kos-token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-token/index.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AACD,cAAM,QAAS,YAAW,SAAS;IACjC,OAAO,CAAC,MAAM,CAAC,CAAS;;IAQxB,IAAI,KAAK,uBAER;IAED,IAAI,KAAK,CAAC,KAAK,oBAAA,EAEd;CACF;AAED,eAAe,QAAQ,CAAC"}

package/models/models/log-block/index.d.ts

@@ -0,0 +1,6 @@
+export { LogBlockContainer } from './log-block-container-registration';
+export { LogBlock } from './log-block-registration';
+export type * from './types';
+export type { LogBlockModel } from './log-block-model';
+export type { LogBlockContainerModel } from './log-block-container-model';
+//# sourceMappingURL=index.d.ts.map

package/models/models/log-block/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,YAAY,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}

package/models/models/log-block/log-block-container-model.d.ts

@@ -0,0 +1,155 @@
+import { LogBlockContainerOptions } from './types';
+import { LogBlockModel } from './log-block-model';
+import { IKosModelHolder, PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+import { IKosModelContainer } from '../../../core/core/kos-container-model';
+
+export declare const MODEL_TYPE = "log-block-container-model";
+/**
+ * Log Block Container Model - Manages multiple log blocks with automatic sorting and organization.
+ *
+ * This container model manages collections of LogBlockModel instances, providing organized access
+ * to log blocks with automatic sorting by block number. It serves as the storage layer within
+ * LogStreamModel instances, handling the efficient organization and retrieval of log blocks
+ * that make up a complete log stream.
+ *
+ * ## Key Features
+ * - **Automatic Sorting** - Maintains blocks sorted by block number for sequential access
+ * - **Block Management** - Add, remove, and retrieve log blocks efficiently
+ * - **Memory Organization** - Organized storage of log blocks within streams
+ * - **Stream Integration** - Essential component of LogStreamModel architecture
+ * - **Sequential Access** - Optimized for accessing blocks in chronological order
+ *
+ * ## Architecture Role
+ * The container fits into the log streaming architecture as:
+ * - **LogStreamModel** uses LogBlockContainerModel to organize its blocks
+ * - **LogBlockContainerModel** manages multiple LogBlockModel instances
+ * - **LogBlockModel** contains the actual log lines and metadata
+ * - Automatic sorting by blockNum ensures proper sequential log ordering
+ *
+ * ## Common Use Cases
+ * - **Stream Block Storage** - Central storage for all blocks within a log stream
+ * - **Sequential Block Access** - Navigate through log blocks in chronological order
+ * - **Block Organization** - Maintain sorted collections of log segments
+ * - **Memory Management** - Efficiently organize log data for stream processing
+ * - **Block Lifecycle** - Handle adding and removing blocks as streams evolve
+ *
+ * @example Container Usage Within Stream
+ * ```typescript
+ * // Typically used internally by LogStreamModel
+ * const logStream = LogStream.instance('system-logs').build();
+ * await logStream.load();
+ *
+ * // Access the container through the stream
+ * const blockContainer = logStream._blocks; // Internal container
+ * const blocks = logStream.blocks; // Public access to blocks
+ *
+ * // Container automatically sorts blocks by blockNum
+ * console.log(`Stream has ${blocks.length} blocks`);
+ * blocks.forEach(block => {
+ *   console.log(`Block ${block.blockNum}: ${block.lineCount} lines`);
+ * });
+ * ```
+ *
+ * @example Direct Container Operations
+ * ```typescript
+ * // Create container (typically done internally)
+ * const container = LogBlockContainer.instance('log-blocks')
+ *   .options({})
+ *   .build();
+ *
+ * // Add blocks to container
+ * const block1 = LogBlock.instance('block-1')
+ *   .options({
+ *     nodeId: 'primary',
+ *     stream: 'app-logs',
+ *     blockNum: 1,
+ *     startLineNum: 1,
+ *     endLineNum: 100,
+ *     startTime: new Date('2024-01-01T10:00:00Z'),
+ *     endTime: new Date('2024-01-01T10:05:00Z'),
+ *     lineCount: 100
+ *   })
+ *   .build();
+ *
+ * const block2 = LogBlock.instance('block-2')
+ *   .options({
+ *     nodeId: 'primary',
+ *     stream: 'app-logs',
+ *     blockNum: 2,
+ *     startLineNum: 101,
+ *     endLineNum: 200,
+ *     startTime: new Date('2024-01-01T10:05:00Z'),
+ *     endTime: new Date('2024-01-01T10:10:00Z'),
+ *     lineCount: 100
+ *   })
+ *   .build();
+ *
+ * container.addModel(block1);
+ * container.addModel(block2);
+ *
+ * // Blocks are automatically sorted by blockNum
+ * const sortedBlocks = container.data;
+ * console.log(`First block: ${sortedBlocks[0].blockNum}`); // 1
+ * console.log(`Second block: ${sortedBlocks[1].blockNum}`); // 2
+ * ```
+ *
+ * @example React Block List Component
+ * ```typescript
+ * const BlockList: React.FC<{ container: LogBlockContainerModel }> = kosComponent(({ container }) => {
+ *   return (
+ *     <div className="block-list">
+ *       <h3>Log Blocks ({container.data.length})</h3>
+ *       <div className="blocks">
+ *         {container.data.map(block => (
+ *           <div key={block.id} className="block-item">
+ *             <div className="block-header">
+ *               <span className="block-num">Block {block.blockNum}</span>
+ *               <span className="line-range">
+ *                 Lines {block.startLineNum}-{block.endLineNum}
+ *               </span>
+ *             </div>
+ *             <div className="block-details">
+ *               <span>Stream: {block.stream}</span>
+ *               <span>Lines: {block.lineCount}</span>
+ *               <span>Loaded: {block.lines.length}</span>
+ *             </div>
+ *             <div className="block-time">
+ *               {block.startTime.toLocaleString()} - {block.endTime.toLocaleString()}
+ *             </div>
+ *           </div>
+ *         ))}
+ *       </div>
+ *     </div>
+ *   );
+ * });
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ * @interface
+ *
+ * @see {@link LogStreamModel} - Parent stream model that uses this container
+ * @see {@link LogBlockModel} - Individual log blocks managed by this container
+ * @see {@link LogBlockContainerOptions} - Configuration options for the container
+ */
+export type LogBlockContainerModel = PublicModelInterface<LogBlockContainerModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class LogBlockContainerModelImpl implements IKosIdentifiable, IKosModelHolder<LogBlockModel>, IKosDataModel {
+    id: string;
+    private logger;
+    private _models;
+    constructor(modelId: string, options: LogBlockContainerOptions, context: KosCreationContext);
+    getModel(id: string): LogBlockModel | undefined;
+    get models(): IKosModelContainer<LogBlockModel>;
+    get data(): LogBlockModel[];
+    addModel(model: LogBlockModel): void;
+    removeModel(id: string): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=log-block-container-model.d.ts.map

package/models/models/log-block/log-block-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-block-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/log-block-container-model.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,eAAO,MAAM,UAAU,8BAA8B,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+HG;AACH,MAAM,MAAM,sBAAsB,GAChC,oBAAoB,CAAC,0BAA0B,CAAC,CAAC;AAEnD;;;GAGG;AACH,qBACa,0BACX,YAAW,gBAAgB,EAAE,eAAe,CAAC,aAAa,CAAC,EAAE,aAAa;IAE1E,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACvB,OAAO,CAAC,OAAO,CAAoC;gBAE3D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,kBAAkB;IAa7B,QAAQ,CAAC,EAAE,EAAE,MAAM;IAGnB,IAAI,MAAM,sCAET;IACD,IAAI,IAAI,oBAEP;IAED,QAAQ,CAAC,KAAK,EAAE,aAAa;IAI7B,WAAW,CAAC,EAAE,EAAE,MAAM;IAKhB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/models/models/log-block/log-block-container-registration.d.ts

@@ -0,0 +1,87 @@
+import { LogBlockContainerOptions } from './types';
+import { LogBlockContainerModel } from './log-block-container-model';
+import { KosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # LogBlockContainer
+ *
+ * The registration bean includes convenience methods for creating and working with LogBlockContainerModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: LogBlockContainer.type, id: "logBlockContainerId"})
+ * private logBlockContainerModel: LogBlockContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new LogBlockContainerModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = LogBlockContainer.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a LogBlockContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (LogBlockContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to LogBlockContainerModel
+ *    // and the compiler will know that the model has the LogBlockContainerModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { LogBlockContainer } from "@kosdev-code/kos-ui-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...LogBlockContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The logBlockContainer model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const LogBlockContainer: KosModelRegistrationFactory<LogBlockContainerModel, LogBlockContainerOptions>;
+//# sourceMappingURL=log-block-container-registration.d.ts.map

package/models/models/log-block/log-block-container-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-block-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-block/log-block-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAM1E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,iBAAiB,+EAM5B,CAAC"}