@medyll/idae-machine 0.108.0 → 0.109.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export * from './machine.js';
 export * from './types/appschemeTypes.js';
+export * from './main/machine.js';
+export * from './main/machine.spec.js';
 export { default as Skeleton } from './fragments/Skeleton.svelte';
 export { default as Selector } from './fragments/Selector.svelte';
 export { default as List } from './fragments/List.svelte';

package/dist/index.js

@@ -1,6 +1,7 @@
 // auto exports of entry components
-export * from './machine.js';
 export * from './types/appschemeTypes.js';
+export * from './main/machine.js';
+export * from './main/machine.spec.js';
 export { default as Skeleton } from './fragments/Skeleton.svelte';
 export { default as Selector } from './fragments/Selector.svelte';
 export { default as List } from './fragments/List.svelte';

package/dist/main/machine.d.ts

@@ -0,0 +1,78 @@
+import { IDbCollections } from '../db/dbFields.js';
+import { createIdbqDb, type IdbqModel } from '@medyll/idae-idbql';
+/**
+ * Machine: main entry point for managing the IDBQL connection and centralized data access.
+ */
+export declare class Machine {
+    /**
+  
+     * IDBQL (readonly collections instance)
+     */
+    _idbql: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbql"] | undefined;
+    /**
+     * IDBQL (stateful collections instance)
+     */
+    _idbqlState: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"] | undefined;
+    /**
+     * Direct access to IndexedDB (core)
+     */
+    _idbDatabase: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbDatabase"] | undefined;
+    /**
+     * IDBQL data model
+     */
+    _idbqModel: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqModel"] | undefined;
+    /**
+     * Centralized access to schema and collection logic
+     */
+    _collections: IDbCollections | undefined;
+    /**
+     * Database name
+     */
+    _dbName: string;
+    /**
+     * Schema version
+     */
+    _version: number;
+    /**
+     * Data model
+     */
+    _model: IdbqModel;
+    /**
+     * Main constructor
+     * @param dbName Database name (default: 'idae-machine')
+     * @param version Schema version (default: 1)
+     * @param model Data model (default: schemeModel)
+     */
+    constructor(dbName?: string, version?: number, model?: IdbqModel);
+    /**
+     * Start the machine: initialize collections and IDBQL connection.
+     * @param options Optional overrides: { dbName, version, model }
+     */
+    start(options?: {
+        dbName?: string;
+        version?: number;
+        model?: IdbqModel;
+    }): void;
+    private createCollections;
+    private createStore;
+    /**
+     * Get the IDbCollections (schema logic) instance
+     */
+    get collections(): IDbCollections | undefined;
+    /**
+     * IDBQL (readonly) instance
+     */
+    get idbql(): import("@medyll/idae-idbql").ReadonlyCollections<IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    /**
+     * IDBQL (stateful) instance
+     */
+    get idbqlState(): import("@medyll/idae-idbql").StateCollections<IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    /**
+     * IndexedDB (core) instance
+     */
+    get indexedb(): import("@medyll/idae-idbql").IdbqlIndexedCore<IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    /**
+     * IDBQL data model instance
+     */
+    get idbqModel(): IdbqModel<Record<string, Record<string, any>>> | undefined;
+}

package/dist/main/machine.js

@@ -0,0 +1,136 @@
+/**
+ * Example usage:
+ *
+ * import { Machine } from './machine.js';
+ *
+ * // Create a new Machine instance with default parameters
+ * const machine = new Machine( 'example-db', 1, { collections: {} });
+ *
+ * // Start the machine (initialize collections and IDBQL connection)
+ * machine.start();
+ *
+ * // Access collections (schema logic)
+ * const collections = machine.collections;
+ *
+ * // Access IDBQL (readonly)
+ * const idbql = machine.idbql;
+ *
+ * // Access IDBQL (stateful)
+ * const idbqlState = machine.idbqlState;
+ *
+ * // Access IndexedDB core
+ * const db = machine.indexedb;
+ *
+ * // Access the IDBQL data model
+ * const model = machine.idbqModel;
+ */
+import { schemeModel } from '../db/dbSchema.js';
+import { IDbCollections } from '../db/dbFields.js';
+import { createIdbqDb } from '@medyll/idae-idbql';
+/**
+ * Machine: main entry point for managing the IDBQL connection and centralized data access.
+ */
+export class Machine {
+    /**
+  
+     * IDBQL (readonly collections instance)
+     */
+    _idbql;
+    /**
+     * IDBQL (stateful collections instance)
+     */
+    _idbqlState;
+    /**
+     * Direct access to IndexedDB (core)
+     */
+    _idbDatabase;
+    /**
+     * IDBQL data model
+     */
+    _idbqModel;
+    /**
+     * Centralized access to schema and collection logic
+     */
+    _collections;
+    /**
+     * Database name
+     */
+    _dbName;
+    /**
+     * Schema version
+     */
+    _version;
+    /**
+     * Data model
+     */
+    _model;
+    /**
+     * Main constructor
+     * @param dbName Database name (default: 'idae-machine')
+     * @param version Schema version (default: 1)
+     * @param model Data model (default: schemeModel)
+     */
+    constructor(dbName = 'idae-machine', version = 1, model = schemeModel) {
+        this._dbName = dbName;
+        this._version = version;
+        this._model = model;
+    }
+    /**
+     * Start the machine: initialize collections and IDBQL connection.
+     * @param options Optional overrides: { dbName, version, model }
+     */
+    start(options) {
+        this._dbName = options?.dbName ?? this._dbName;
+        this._version = options?.version ?? this._version;
+        this._model = options?.model ?? this._model;
+        this.createCollections();
+        this.createStore();
+    }
+    createCollections() {
+        if (!this._model) {
+            throw new Error('Data model is not defined');
+        }
+        this._collections = new IDbCollections(this._model);
+    }
+    createStore() {
+        if (!this._model || !this._dbName || !this._version) {
+            throw new Error('Model, dbName, or version is not defined');
+        }
+        const idbqStore = createIdbqDb(this._model, this._version);
+        const { idbql, idbqlState, idbDatabase, idbqModel } = idbqStore.create(this._dbName);
+        this._idbql = idbql;
+        this._idbqlState = idbqlState;
+        this._idbDatabase = idbDatabase;
+        this._idbqModel = idbqModel;
+    }
+    /**
+     * Get the IDbCollections (schema logic) instance
+     */
+    get collections() {
+        return this._collections;
+    }
+    /**
+     * IDBQL (readonly) instance
+     */
+    get idbql() {
+        return this._idbql;
+    }
+    /**
+     * IDBQL (stateful) instance
+     */
+    get idbqlState() {
+        return this._idbqlState;
+    }
+    /**
+     * IndexedDB (core) instance
+     */
+    get indexedb() {
+        return this._idbDatabase;
+    }
+    /**
+     * IDBQL data model instance
+     */
+    get idbqModel() {
+        return this._idbqModel;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@medyll/idae-machine",
-	"version": "0.108.0",
+	"version": "0.109.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",

package/dist/machine.d.ts

@@ -1,76 +0,0 @@
-import { IDbCollections } from './db/dbFields.js';
-import { createIdbqDb } from '@medyll/idae-idbql';
-/**
- * Machine: main entry point for managing the IDBQL connection and centralized data access.
- */
-export declare class Machine {
-    /**
-  
-     * IDBQL (readonly collections instance)
-     */
-    idbql: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbql"] | undefined;
-    /**
-     * IDBQL (stateful collections instance)
-     */
-    idbqlState: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"] | undefined;
-    /**
-     * Direct access to IndexedDB (core)
-     */
-    idbDatabase: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbDatabase"] | undefined;
-    /**
-     * IDBQL data model
-     */
-    idbqModel: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqModel"] | undefined;
-    /**
-     * Centralized access to schema and collection logic
-     */
-    collections: IDbCollections | undefined;
-    /**
-     * Database name
-     */
-    dbName: string;
-    /**
-     * Schema version
-     */
-    version: number;
-    /**
-     * Data model
-     */
-    model: any;
-    /**
-     * Main constructor
-     * @param dbName Database name (default: 'idae-machine')
-     * @param version Schema version (default: 1)
-     * @param model Data model (default: schemeModel)
-     */
-    constructor(dbName?: string, version?: number, model?: import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>);
-    /**
-     * Start the machine: initialize collections and IDBQL connection.
-     * @param options Optional overrides: { dbName, version, model }
-     */
-    start(options?: {
-        dbName?: string;
-        version?: number;
-        model?: any;
-    }): void;
-    /**
-     * Get the IDbCollections (schema logic) instance
-     */
-    getCollections(): IDbCollections | undefined;
-    /**
-     * Get the IDBQL (readonly) instance
-     */
-    getIdbql(): import("@medyll/idae-idbql").ReadonlyCollections<import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>> | undefined;
-    /**
-     * Get the IDBQL (stateful) instance
-     */
-    getIdbqlState(): import("@medyll/idae-idbql").StateCollections<import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>> | undefined;
-    /**
-     * Get the IndexedDB (core) instance
-     */
-    getIdbDatabase(): import("@medyll/idae-idbql").IdbqlIndexedCore<import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>> | undefined;
-    /**
-     * Get the IDBQL data model instance
-     */
-    getIdbqModel(): import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>> | undefined;
-}

package/dist/machine.js

@@ -1,129 +0,0 @@
-/**
- * Example usage:
- *
- * import { Machine } from './machine.js';
- *
- * // Create a new Machine instance with default parameters
- * const machine = new Machine();
- *
- * // Start the machine (initialize collections and IDBQL connection)
- * machine.start();
- *
- * // Access collections (schema logic)
- * const collections = machine.getCollections();
- *
- * // Access IDBQL (readonly)
- * const idbql = machine.getIdbql();
- *
- * // Access IDBQL (stateful)
- * const idbqlState = machine.getIdbqlState();
- *
- * // Access IndexedDB core
- * const db = machine.getIdbDatabase();
- *
- * // Access the IDBQL data model
- * const model = machine.getIdbqModel();
- */
-import { schemeModel } from './db/dbSchema.js';
-import { IDbCollections } from './db/dbFields.js';
-import { createIdbqDb } from '@medyll/idae-idbql';
-/**
- * Machine: main entry point for managing the IDBQL connection and centralized data access.
- */
-export class Machine {
-    /**
-  
-     * IDBQL (readonly collections instance)
-     */
-    idbql;
-    /**
-     * IDBQL (stateful collections instance)
-     */
-    idbqlState;
-    /**
-     * Direct access to IndexedDB (core)
-     */
-    idbDatabase;
-    /**
-     * IDBQL data model
-     */
-    idbqModel;
-    /**
-     * Centralized access to schema and collection logic
-     */
-    collections;
-    /**
-     * Database name
-     */
-    dbName;
-    /**
-     * Schema version
-     */
-    version;
-    /**
-     * Data model
-     */
-    model;
-    /**
-     * Main constructor
-     * @param dbName Database name (default: 'idae-machine')
-     * @param version Schema version (default: 1)
-     * @param model Data model (default: schemeModel)
-     */
-    constructor(dbName = 'idae-machine', version = 1, model = schemeModel) {
-        this.dbName = dbName;
-        this.version = version;
-        this.model = model;
-        this.collections = undefined;
-        this.idbql = undefined;
-        this.idbqlState = undefined;
-        this.idbDatabase = undefined;
-        this.idbqModel = undefined;
-    }
-    /**
-     * Start the machine: initialize collections and IDBQL connection.
-     * @param options Optional overrides: { dbName, version, model }
-     */
-    start(options) {
-        const dbName = options?.dbName ?? this.dbName;
-        const version = options?.version ?? this.version;
-        const model = options?.model ?? this.model;
-        this.collections = new IDbCollections(model);
-        const idbqStore = createIdbqDb(model, version);
-        const { idbql, idbqlState, idbDatabase, idbqModel } = idbqStore.create(dbName);
-        this.idbql = idbql;
-        this.idbqlState = idbqlState;
-        this.idbDatabase = idbDatabase;
-        this.idbqModel = idbqModel;
-    }
-    /**
-     * Get the IDbCollections (schema logic) instance
-     */
-    getCollections() {
-        return this.collections;
-    }
-    /**
-     * Get the IDBQL (readonly) instance
-     */
-    getIdbql() {
-        return this.idbql;
-    }
-    /**
-     * Get the IDBQL (stateful) instance
-     */
-    getIdbqlState() {
-        return this.idbqlState;
-    }
-    /**
-     * Get the IndexedDB (core) instance
-     */
-    getIdbDatabase() {
-        return this.idbDatabase;
-    }
-    /**
-     * Get the IDBQL data model instance
-     */
-    getIdbqModel() {
-        return this.idbqModel;
-    }
-}