@medyll/idae-machine 0.124.0 → 0.125.0

package/dist/main/machineForge.d.ts

@@ -0,0 +1,57 @@
+import type { TplCollectionName, TplFields } from "@medyll/idae-idbql";
+import type { IDbFieldType, IDbFieldRules, IDbForgeArgs } from "./machineDb.js";
+/**
+ * Represents the structure for database field forging.
+ * Used to describe and construct database field definitions dynamically.
+ */
+export type IDbForge = {
+    /** Name of the collection (table) */
+    collection?: TplCollectionName;
+    /** Name of the field within the collection */
+    fieldName?: keyof TplFields;
+    /** Type of the field (e.g., string, number, fk, array, etc.) */
+    fieldType?: IDbFieldType;
+    /** Field rule string describing the type and constraints */
+    fieldRule?: IDbFieldRules;
+    /** Additional arguments for the field (properties, options, etc.) */
+    fieldArgs?: IDbForgeArgs | undefined;
+    /** The resolved type (array, object, fk, primitive) */
+    is: unknown;
+};
+/**
+ * Utility class for parsing and constructing database field definitions (IDbForge).
+ * Provides methods to analyze field rules and extract type information for schema generation.
+ */
+export declare class MachineForge {
+    /**
+     * Create a new MachineForge instance.
+     */
+    constructor();
+    /**
+     * Test if a field rule matches a specific type (array, object, fk, primitive).
+     * @param what - The type to test for ("array", "object", "fk", "primitive").
+     * @param fieldRule - The field rule string to analyze.
+     * @returns Partial IDbForge object if the rule matches, otherwise undefined.
+     */
+    testIs(what: "array" | "object" | "fk" | "primitive", fieldRule: IDbFieldRules): Partial<IDbForge> | undefined;
+    /**
+     * Returns a partial IDbForge object for the given type and field rule.
+     * @param what - The type to extract ("array", "object", "fk", "primitive").
+     * @param fieldRule - The field rule string to analyze.
+     * @returns Partial IDbForge object with extracted type info.
+     */
+    is(what: "array" | "object" | "fk" | "primitive", fieldRule: IDbFieldRules): Partial<IDbForge>;
+    /**
+     * Extracts type, rule, and argument information from a field rule string.
+     * @param type - The type to extract ("array", "object", "fk", "primitive").
+     * @param fieldRule - The field rule string to analyze.
+     * @returns Partial IDbForge object with extracted details.
+     */
+    extract(type: "array" | "object" | "fk" | "primitive", fieldRule: IDbFieldRules): Partial<IDbForge>;
+    /**
+     * Constructs an IDbForge object from its components.
+     * @param params - The components of the IDbForge object.
+     * @returns A complete IDbForge object.
+     */
+    forge({ collection, fieldName, fieldType, fieldRule, fieldArgs, is, }: IDbForge): IDbForge;
+}

package/dist/main/machineForge.js

@@ -0,0 +1,105 @@
+/**
+ * Utility class for parsing and constructing database field definitions (IDbForge).
+ * Provides methods to analyze field rules and extract type information for schema generation.
+ */
+export class MachineForge {
+    /**
+     * Create a new MachineForge instance.
+     */
+    constructor() { }
+    /**
+     * Test if a field rule matches a specific type (array, object, fk, primitive).
+     * @param what - The type to test for ("array", "object", "fk", "primitive").
+     * @param fieldRule - The field rule string to analyze.
+     * @returns Partial IDbForge object if the rule matches, otherwise undefined.
+     */
+    testIs(what, fieldRule) {
+        const typeMappings = {
+            fk: "fk-",
+            array: "array-of-",
+            object: "object-",
+            primitive: "",
+        };
+        const prefix = typeMappings[what];
+        // For primitive, ensure it does not start with any other type prefix
+        if (what === "primitive") {
+            if (!fieldRule.startsWith("array-of-") &&
+                !fieldRule.startsWith("object-") &&
+                !fieldRule.startsWith("fk-")) {
+                return this.is(what, fieldRule);
+            }
+            return undefined;
+        }
+        // For other types, check if the rule starts with the expected prefix
+        if (fieldRule.startsWith(prefix)) {
+            return this.is(what, fieldRule);
+        }
+        return undefined;
+    }
+    /**
+     * Returns a partial IDbForge object for the given type and field rule.
+     * @param what - The type to extract ("array", "object", "fk", "primitive").
+     * @param fieldRule - The field rule string to analyze.
+     * @returns Partial IDbForge object with extracted type info.
+     */
+    is(what, fieldRule) {
+        return this.extract(what, fieldRule);
+    }
+    /**
+     * Extracts type, rule, and argument information from a field rule string.
+     * @param type - The type to extract ("array", "object", "fk", "primitive").
+     * @param fieldRule - The field rule string to analyze.
+     * @returns Partial IDbForge object with extracted details.
+     */
+    extract(type, fieldRule) {
+        /**
+         * Helper to extract the substring after a given pattern, before any arguments.
+         * @param pattern - The prefix pattern to remove.
+         * @param source - The field rule string.
+         * @returns The substring after the pattern.
+         */
+        function extractAfter(pattern, source) {
+            const reg = source?.split("(")?.[0];
+            return reg.split(pattern)[1];
+        }
+        /**
+         * Helper to extract the main type and argument list from a field rule string.
+         * @param source - The field rule string.
+         * @returns Object with the main type (piece) and argument array (args).
+         */
+        function extractArgs(source) {
+            const [piece, remaining] = source.split("(");
+            if (!remaining)
+                return { piece: piece.trim(), args: undefined };
+            const [central] = remaining?.split(")");
+            const args = central?.split(" ");
+            return { piece: piece.trim(), args };
+        }
+        const extractedArgs = extractArgs(fieldRule);
+        let fieldType;
+        const fieldArgs = extractedArgs?.args;
+        switch (type) {
+            case "array":
+                fieldType = extractAfter("array-of-", fieldRule);
+                break;
+            case "object":
+                fieldType = extractAfter("object-", fieldRule);
+                break;
+            case "fk":
+                fieldType = "fk-" + extractAfter("fk-", fieldRule);
+                break;
+            case "primitive":
+                fieldType = extractedArgs?.piece;
+                break;
+        }
+        return { fieldType, fieldRule, fieldArgs, is: type };
+    }
+    /**
+     * Constructs an IDbForge object from its components.
+     * @param params - The components of the IDbForge object.
+     * @returns A complete IDbForge object.
+     */
+    forge({ collection, fieldName, fieldType, fieldRule, fieldArgs, is, }) {
+        return { collection, fieldName, fieldType, fieldRule, fieldArgs, is };
+    }
+}

package/dist/{form → ui}/CollectionButton.svelte

@@ -4,8 +4,8 @@
  -->
 <script lang="ts" generics="COL">
 	import { Button, openWindow } from '@medyll/idae-slotui-svelte';
-	import CreateUpdate from './CreateUpdate.svelte';
-	import { type CreateUpdateProps } from './types';
+	import CreateUpdate from '../form/CreateUpdate.svelte';
+	import { type CreateUpdateProps } from '../form/types.js';
 
 	type CollectionButtonProps = {
 		collection: string;

package/dist/{form → ui}/CollectionButton.svelte.d.ts

@@ -1,4 +1,4 @@
-import { type CreateUpdateProps } from './types';
+import { type CreateUpdateProps } from '../form/types.js';
 type CollectionButtonProps = {
     collection: string;
     withData?: Record<string, any>;

package/dist/{form → ui}/CollectionFks.svelte

@@ -10,13 +10,11 @@
 		collectionId?: any;
 		where?:        Where;
 	};
-	let { collection }: CollectionFksProps = $props();
 
-	// idbqlState[fkCollection].get(fkId);
+	let { collection,collectionId,where }: CollectionFksProps = $props();
 
-	const dbFields = machine.collections;
-	const collections = new MachineDb(schemeModel);
-	const fks = $derived(collections.fks(collection));
+ 
+	const fks = $derived(machine.collections.fks(collection)); 
 </script>
 
 <Looper data={Object.entries(fks)}>

package/dist/{form → ui}/CollectionList.svelte

@@ -8,7 +8,7 @@
 		type Props,
 		Looper
 	} from '@medyll/idae-slotui-svelte';
-	import CreateUpdate from './CreateUpdate.svelte'; 
+	import CreateUpdate from '../form/CreateUpdate.svelte'; 
 	import { hydrate, type Snippet } from 'svelte';
 	import type { Where } from '@medyll/idae-idbql';
 

package/dist/{form → ui}/CollectionListMenu.svelte

@@ -1,8 +1,9 @@
 <script lang="ts" generics="COL = Record<string,any>">
 	import { type MenuListProps, Button, MenuList, MenuListItem, openWindow, type Props } from '@medyll/idae-slotui-svelte';
-	import CreateUpdate from './CreateUpdate.svelte';
+	import CreateUpdate from '../form/CreateUpdate.svelte';
 	import { idbqlState } from '../db/dbSchema.js';
-	import { MachineDb, IDbCollectionValues } from '../main/machineDb.js';
+	import { MachineDb } from '../main/machineDb.js';
+	import { IDbCollectionValues } from '../main/IDbCollectionValues';
 	import { hydrate } from 'svelte';
 	import type { Where } from '@medyll/idae-idbql';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medyll/idae-machine",
-  "version": "0.124.0",
+  "version": "0.125.0",
   "files": [
     "dist",
     "!dist/**/*.test.*",
@@ -49,8 +49,8 @@
   "scope": "@medyll",
   "dependencies": {
     "@huggingface/prettier-plugin-vertical-align": "^0.2.3",
-    "@medyll/idae-slotui-svelte": "0.177.0",
-    "@medyll/idae-idbql": "0.174.0"
+    "@medyll/idae-slotui-svelte": "0.178.0",
+    "@medyll/idae-idbql": "0.175.0"
   },
   "scripts": {
     "dev": "vite dev",

package/dist/form/DataList.svelte

@@ -1,60 +0,0 @@
-<!-- DataList.svelte - Composant listant les items d'une collection
-   Migré depuis _work, adapté pour /lib/form et Svelte 5
-   Props : collection, displayMode, where, items, onItemClick
--->
-<script lang="ts">
-	let {
-		collection,
-		displayMode = 'grid',
-		where = {},
-		items = [],
-		onItemClick = null
-	}: {
-		collection: string,
-		displayMode?: 'grid' | 'list',
-		where?: any,
-		items?: any[],
-		onItemClick?: ((item: any, idx: number) => void) | null
-	} = $props();
-</script>
-
-<div class="data-list" data-mode={displayMode}>
-	<h2>{collection} ({displayMode})</h2>
-	<div class={displayMode === 'grid' ? 'grid' : 'list'}>
-		{#each items as item, idx}
-			<div
-				class="item"
-				role="button"
-				tabindex="0"
-				onclick={() => onItemClick && onItemClick(item, idx)}
-				onkeydown={e => (e.key === 'Enter' || e.key === ' ') && onItemClick && onItemClick(item, idx)}
-			>
-				{item.name || `Item ${idx+1}`}
-			</div>
-		{:else}
-			<p>No items to display.</p>
-		{/each}
-	</div>
-</div>
-
-<style>
-	.data-list {
-		padding: 1rem;
-	}
-	.grid {
-		display: grid;
-		grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
-		gap: 1rem;
-	}
-	.list {
-		display: flex;
-		flex-direction: column;
-		gap: 0.5rem;
-	}
-	.item {
-		background: #f0f0f0;
-		border-radius: 6px;
-		padding: 0.75rem;
-		cursor: pointer;
-	}
-</style>

package/dist/form/DataList.svelte.d.ts

@@ -1,10 +0,0 @@
-type $$ComponentProps = {
-    collection: string;
-    displayMode?: 'grid' | 'list';
-    where?: any;
-    items?: any[];
-    onItemClick?: ((item: any, idx: number) => void) | null;
-};
-declare const DataList: import("svelte").Component<$$ComponentProps, {}, "">;
-type DataList = ReturnType<typeof DataList>;
-export default DataList;