mountain-ui 1.0.55 → 1.0.56

package/src/lib/registry/entryActionTypeRegistry/entryActionTypes/PrefillNewEntry/Properties.svelte

@@ -0,0 +1,147 @@
+<script>
+	import EntitiesSelector from '../../../entityRegistry/components/EntitiesSelector.svelte';
+	import EntityFieldContainer from '../../../entityRegistry/components/EntityFieldContainer.svelte';
+	import FieldBinding from '../../../entityRegistry/components/FieldBinding.svelte';
+	import FieldRow from '../../../entityRegistry/components/FieldRow.svelte';
+	import { entityRegistry } from '../../../entityRegistry/registry.svelte';
+	import { fieldTypeRegistry } from '../../../fieldTypeRegistry/registry.svelte';
+	import { Button } from 'hamzus-ui';
+	import Binding from './component/Binding.svelte';
+
+	let {
+		props = $bindable({
+			fromEntityId: null,
+			toEntityId: null,
+			bindings: [
+				// {
+				//     fromFieldId:null,
+				//     toFieldId:null,
+				//     bindings:[] // disponible lorsque il y a un type imbriquer comme line
+				// }
+			]
+		}),
+        onChange = (props)=>{}
+	} = $props();
+
+	let fromEntityId = $derived(props.fromEntityId);
+	let toEntityId = $derived(props.toEntityId);
+
+	const fromEntity = $derived(entityRegistry.get(fromEntityId));
+	const toEntity = $derived(entityRegistry.get(toEntityId));
+
+	$effect(() => {
+		let newProps = {
+			fromEntityId: fromEntityId,
+			toEntityId: toEntityId
+		};
+		if (!fromEntity) {
+			props = {
+				...newProps,
+				bindings: []
+			};
+			return null;
+		}
+
+		let newBindings = [];
+
+		for (const field of fromEntity.fields) {
+			newBindings.push({
+				fromFieldId: field.id,
+				toFieldId: null,
+				bindings: []
+			});
+		}
+
+		props = {
+			...newProps,
+			bindings: [...newBindings]
+		};
+	});
+
+	function getBinding(fieldId) {
+		return props.bindings?.find((binding) => binding?.fromFieldId === fieldId);
+	}
+</script>
+
+<div class="props">
+	<div class="transfer">
+		<EntitiesSelector bind:activeEntityId={fromEntityId}></EntitiesSelector>
+		<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+			<path
+				d="M14.4291 18.8201C14.2391 18.8201 14.0491 18.7501 13.8991 18.6001C13.6091 18.3101 13.6091 17.8301 13.8991 17.5401L19.4391 12.0001L13.8991 6.46012C13.6091 6.17012 13.6091 5.69012 13.8991 5.40012C14.1891 5.11012 14.6691 5.11012 14.9591 5.40012L21.0291 11.4701C21.3191 11.7601 21.3191 12.2401 21.0291 12.5301L14.9591 18.6001C14.8091 18.7501 14.6191 18.8201 14.4291 18.8201Z"
+				fill="#292D32"
+			/>
+			<path
+				d="M20.33 12.75H3.5C3.09 12.75 2.75 12.41 2.75 12C2.75 11.59 3.09 11.25 3.5 11.25H20.33C20.74 11.25 21.08 11.59 21.08 12C21.08 12.41 20.74 12.75 20.33 12.75Z"
+				fill="#292D32"
+			/>
+		</svg>
+
+		<EntitiesSelector bind:activeEntityId={toEntityId}></EntitiesSelector>
+	</div>
+
+	{#if fromEntity && toEntity}
+		{#key `${fromEntityId}-${toEntityId}`}
+			<EntityFieldContainer>
+				<!-- afficher les fieldId a bind dispo -->
+				{#each fromEntity.fields as field, index}
+					{#if !field.is_hidden && field.type !== 'primary'}
+						{@const binding = getBinding(field.id)}
+
+						{#if binding}
+							<Binding
+								slot="right"
+								fieldId={binding.fromFieldId}
+								{toEntityId}
+								props={binding}
+								onChange={(newBinding) => {
+									props = {
+										...props,
+										bindings: props.bindings.map((b) =>
+											b.fromFieldId === field.id ? { ...newBinding } : b
+										)
+									};
+								}}
+							/>
+						{/if}
+					{/if}
+				{/each}
+			</EntityFieldContainer>
+		{/key}
+	{/if}
+</div>
+
+<style>
+	.props {
+		display: flex;
+		flex-direction: column;
+		row-gap: var(--pad-m);
+		padding: var(--pad-m);
+	}
+
+	.transfer {
+		width: 100%;
+		display: grid;
+		grid-template-columns: 1fr 50px 1fr;
+		justify-content: space-between;
+	}
+	.transfer > :global(:nth-child(3n + 1)) {
+		justify-self: start;
+	}
+
+	.transfer > :global(:nth-child(3n + 2)) {
+		justify-self: center;
+	}
+
+	.transfer > :global(:nth-child(3n)) {
+		justify-self: end;
+	}
+
+	.transfer svg {
+		width: 24px;
+		height: 24px;
+	}
+	.transfer svg path {
+		fill: var(--font-2);
+	}
+</style>

package/src/lib/registry/entryActionTypeRegistry/entryActionTypes/PrefillNewEntry/component/Binding.svelte

@@ -0,0 +1,103 @@
+<script>
+	import FieldBinding from '../../../../entityRegistry/components/FieldBinding.svelte';
+	import BindingClone from './BindingClone.svelte';
+	import FieldRow from '../../../../entityRegistry/components/FieldRow.svelte';
+	import { entityRegistry } from '../../../../entityRegistry/registry.svelte';
+	import { fieldTypeRegistry } from '../../../../fieldTypeRegistry/registry.svelte';
+	import EntityFieldContainer from '../../../../entityRegistry/components/EntityFieldContainer.svelte';
+
+	let { fieldId, toEntityId, props = null, onChange = (newProps) => {} } = $props();
+
+	const fromField = $derived(entityRegistry.getField(props.fromFieldId));
+	const fromFieldType = $derived(fieldTypeRegistry.get(fromField.type));
+
+	const toField = $derived(entityRegistry.getField(props.toFieldId));
+	const toFieldType = $derived(fieldTypeRegistry.get(toField.type));
+	const toEntity = $derived.by(() => {
+		const childEntityId = toFieldType.getChildEntityId(toField);
+		console.log(childEntityId);
+		if (childEntityId) {
+			return entityRegistry.get(childEntityId);
+		}
+
+		return null;
+	});
+
+	function handleBind(fromFieldId, toFieldId) {
+		let newProps = {
+			fromFieldId: fromFieldId,
+			toFieldId: toFieldId,
+			bindings: []
+		};
+
+		const field = entityRegistry.getField(toFieldId);
+		const fieldType = fieldTypeRegistry.get(field.type);
+
+		// verifier si il y a du bindings
+		const childFieldIds = fieldType.getChildsBindings(field);
+
+		if (childFieldIds && childFieldIds.length > 0) {
+			newProps.bindings = childFieldIds.map((childFieldId) => ({
+				fromFieldId: childFieldId,
+				toFieldId: null,
+				bindings: []
+			}));
+		}
+
+		props = { ...newProps };
+
+		onChange(props);
+	}
+</script>
+
+<FieldRow id={fieldId}>
+	<FieldBinding
+		onChange={(toFieldId) => {
+			handleBind(fieldId, toFieldId);
+		}}
+		allowedType={(field) => {
+			if (field.entity_id != toEntityId) return false;
+
+			const allowedTypes = fromFieldType.allowBindings;
+
+			for (const allowedBind of allowedTypes) {
+				if (field.type.startsWith(allowedBind)) {
+					return true;
+				}
+			}
+
+			return false;
+		}}
+		slot="right"
+	></FieldBinding>
+	<div slot="bottom" class="bindings" class:active={props.bindings && props.bindings.length > 0}>
+		{#if props.bindings && props.bindings.length > 0}
+			<EntityFieldContainer>
+				{#each props.bindings as binding, index}
+					<BindingClone
+						slot="right"
+						fieldId={binding.fromFieldId}
+						toEntityId={toEntity.id}
+						props={binding}
+						onChange={(newBinding) => {
+							props = {
+								...props,
+								bindings: props.bindings.map((b) =>
+									b.fromFieldId === binding.fromFieldId ? { ...newBinding } : b
+								)
+							};
+
+							onChange(props);
+						}}
+					/>
+				{/each}
+			</EntityFieldContainer>
+		{/if}
+	</div>
+</FieldRow>
+
+<style>
+	.bindings.active {
+		padding: var(--pad-m);
+	}
+</style>

package/src/lib/registry/entryActionTypeRegistry/entryActionTypes/PrefillNewEntry/component/BindingClone.svelte

@@ -0,0 +1,103 @@
+<script>
+	import FieldBinding from '../../../../entityRegistry/components/FieldBinding.svelte';
+	import Binding from './Binding.svelte';
+	import FieldRow from '../../../../entityRegistry/components/FieldRow.svelte';
+	import { entityRegistry } from '../../../../entityRegistry/registry.svelte';
+	import { fieldTypeRegistry } from '../../../../fieldTypeRegistry/registry.svelte';
+	import EntityFieldContainer from '../../../../entityRegistry/components/EntityFieldContainer.svelte';
+
+	let { fieldId, toEntityId, props = null, onChange = (newProps) => {} } = $props();
+
+	const fromField = $derived(entityRegistry.getField(props.fromFieldId));
+	const fromFieldType = $derived(fieldTypeRegistry.get(fromField.type));
+
+	const toField = $derived(entityRegistry.getField(props.toFieldId));
+	const toFieldType = $derived(fieldTypeRegistry.get(toField.type));
+	const toEntity = $derived.by(() => {
+		const childEntityId = toFieldType.getChildEntityId(toField);
+		console.log(childEntityId);
+		if (childEntityId) {
+			return entityRegistry.get(childEntityId);
+		}
+
+		return null;
+	});
+
+	function handleBind(fromFieldId, toFieldId) {
+		let newProps = {
+			fromFieldId: fromFieldId,
+			toFieldId: toFieldId,
+			bindings: []
+		};
+
+		const field = entityRegistry.getField(toFieldId);
+		const fieldType = fieldTypeRegistry.get(field.type);
+
+		// verifier si il y a du bindings
+		const childFieldIds = fieldType.getChildsBindings(field);
+
+		if (childFieldIds && childFieldIds.length > 0) {
+			newProps.bindings = childFieldIds.map((childFieldId) => ({
+				fromFieldId: childFieldId,
+				toFieldId: null,
+				bindings: []
+			}));
+		}
+
+		props = { ...newProps };
+
+		onChange(props);
+	}
+</script>
+
+<FieldRow id={fieldId}>
+	<FieldBinding
+		onChange={(toFieldId) => {
+			handleBind(fieldId, toFieldId);
+		}}
+		allowedType={(field) => {
+			if (field.entity_id != toEntityId) return false;
+
+			const allowedTypes = fromFieldType.allowBindings;
+
+			for (const allowedBind of allowedTypes) {
+				if (field.type.startsWith(allowedBind)) {
+					return true;
+				}
+			}
+
+			return false;
+		}}
+		slot="right"
+	></FieldBinding>
+	<div slot="bottom" class="bindings" class:active={props.bindings && props.bindings.length > 0}>
+		{#if props.bindings && props.bindings.length > 0}
+			<EntityFieldContainer>
+				{#each props.bindings as binding, index}
+					<Binding
+						slot="right"
+						fieldId={binding.fromFieldId}
+						toEntityId={toEntity.id}
+						props={binding}
+						onChange={(newBinding) => {
+							props = {
+								...props,
+								bindings: props.bindings.map((b) =>
+									b.fromFieldId === binding.fromFieldId ? { ...newBinding } : b
+								)
+							};
+
+							onChange(props);
+						}}
+					/>
+				{/each}
+			</EntityFieldContainer>
+		{/if}
+	</div>
+</FieldRow>
+
+<style>
+	.bindings.active {
+		padding: var(--pad-m);
+	}
+</style>

package/src/lib/registry/entryActionTypeRegistry/entryActionTypes/PrefillNewEntry/index.js

@@ -0,0 +1,77 @@
+import { goto } from '$app/navigation';
+import { page } from '$app/state';
+import { entityRegistry } from '../../../entityRegistry/registry.svelte';
+import { fieldTypeRegistry } from '../../../fieldTypeRegistry/registry.svelte';
+import { createEntryActionType } from '../../createEntryActionType';
+
+import Card from './Card.svelte'
+import Properties from './Properties.svelte'
+
+export default createEntryActionType({
+    type: "prefill-new-entry",
+    name: "Préremplir une nouvelle entrée",
+    description: "Permet d'ouvrir la page sur un formulaire pour crée une nouvelle entrée deja précomplété avec les infos de l'entrée initial.",
+    defaultProps: {
+        fromEntityId: null,
+        toEntityId: null,
+        bindings: [
+            // {
+            //     fromFieldId:null,
+            //     toFieldId:null,
+            //     bindings:[] // disponible lorsque il y a un type imbriquer comme line
+            // }
+        ]
+    },
+    getEntityIdFromProps: (props)=>{
+        return props?.fromEntityId ?? null
+    },
+    canPerformAction: (entity, entry, props) => {
+        if (props.fromEntityId === entity.id) return true
+    },
+    action: (entity, entry, props) => {
+        const toEntity = entityRegistry.get(props?.toEntityId ?? null)
+        if (!toEntity) {
+            return
+        }
+
+        // ici il faut convertir l entrée avec les valeur binder
+        const newEntryCtx = createNewCtxFromBinding(entity, entry, props.bindings)
+        
+
+        goto(`/exemple/${page.params.project_normalized_name}/${toEntity.slug}/create?prefill=${JSON.stringify(newEntryCtx)}`)
+        
+    },
+    components: {
+        card: Card,
+        properties: Properties,
+    },
+});
+
+// fonction pour crée une entrée configuré a partir de l entrée initial et du binding
+export function createNewCtxFromBinding(entity, entry, bindings) {
+    
+    let newEntryCtx = {}
+    // parcourir le binding
+    for (const entityField of entity.fields) {
+        for (const binding of bindings) {
+            if (binding.fromFieldId !== entityField.id) continue
+
+            // récuperer le champs actuel et le prochain champs ou la valeur sera injecter
+            const fromField = entityRegistry.getField(binding.fromFieldId, entityField.entity_id)
+            const toField = entityRegistry.getField(binding.toFieldId)
+
+            const valueFromActualEntry = entry[fromField.id] ?? null
+
+            // il faux peut etre altérer le binding du field en fonction de son type
+            const fromFieldType = fieldTypeRegistry.get(fromField.type)
+            
+
+            try {
+                newEntryCtx[toField.id] = fromFieldType.computeBindings(valueFromActualEntry, fromField, binding.bindings)
+            } catch (error) {
+            }
+        }
+    }
+
+    return newEntryCtx
+}

package/src/lib/registry/entryActionTypeRegistry/registerDefaultEntryActionTypes.js

@@ -0,0 +1,7 @@
+import { entryActionTypeRegistry } from './registry.svelte';
+import PrefillNewEntry from './entryActionTypes/PrefillNewEntry';
+
+
+export function registerDefaultEntryActionTypes() {
+	entryActionTypeRegistry.register(PrefillNewEntry)
+}

package/src/lib/registry/entryActionTypeRegistry/registry.svelte.js

@@ -0,0 +1,48 @@
+import { writable, derived, get } from 'svelte/store';
+
+function createEntryActionTypeRegistry() {
+	const store = writable({});
+
+	const all = derived(store, ($entryActionTypes) => Object.values($entryActionTypes));
+
+	return {
+		subscribe: store.subscribe,
+
+		register(entryActionType) {
+			store.update((entryActionTypes) => ({
+				...entryActionTypes,
+				[entryActionType.type]: entryActionType
+			}));
+		},
+
+		unregister(type) {
+			store.update((entryActionTypes) => {
+				const copy = { ...entryActionTypes };
+
+				delete copy[type];
+
+				return copy;
+			});
+		},
+
+		unregisterAll(type) {
+			store.update((entryActionTypes) => {
+				return {};
+			});
+		},
+
+		get(type) {
+			return get(store)[type];
+		},
+
+		select(type) {
+			return derived(store, ($entryActionTypes) => $entryActionTypes[type]);
+		},
+
+		getAll() {
+			return all;
+		}
+	};
+}
+
+export const entryActionTypeRegistry = createEntryActionTypeRegistry();

package/src/lib/registry/fieldTypeRegistry/createFieldType.js

@@ -24,6 +24,14 @@ export function createFieldType(config) {
 			properties: null
 		},
 
+        
+        // bindings
+        allowBindings:[],
+		getChildEntityId: (field) => { return null},
+		getChildsBindings: (field) => { return null},
+		getMoreFieldBindings: (field) => { return null},
+		computeBindings: (value, bindings) => { return value},
+
 		formatter: (value) => value,
 		parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/Lines/index.js

@@ -6,6 +6,8 @@ import Card from './Card.svelte';
 import Input from './Input.svelte';
 import TableView from './TableView.svelte';
 import View from './View.svelte';
+import { entityRegistry } from '../../../entityRegistry/registry.svelte';
+import { createNewCtxFromBinding } from '../../../entryActionTypeRegistry/entryActionTypes/PrefillNewEntry';
 
 export default createFieldType({
 	type: 'lines',
@@ -34,6 +36,56 @@ export default createFieldType({
 		properties: null
 	},
 
+
+    allowBindings:["lines"],
+    getChildsBindings:(field)=>{
+        if (!field.props.linkId) return null;
+        
+        const lineEntity = entityRegistry.get(field.props.linkId)
+
+        return lineEntity.fields.map(f=>f.id)
+    },
+    getChildEntityId:(field)=>{
+        if (!field.props.linkId) return null;
+        
+        return parseInt(field.props.linkId)
+    },
+    getMoreFieldBindings:(field)=>{
+        if (!field.props.columns) return null;
+        
+        let allFieldIds = []
+
+        for (const column of field.props.columns) {
+            for (const columnRow of column.rows) {
+                allFieldIds.push(columnRow.fieldId)
+            }
+        }
+
+        return allFieldIds
+    },
+    computeBindings:(value, field, bindings)=>{
+        if (!value) return value;
+        if (!field.props.linkId) return value;
+        
+        
+        const lineEntity = entityRegistry.get(field.props.linkId)
+        
+        if (!lineEntity) return value;
+        
+        const lines = JSON.parse(value)
+
+        let newLines = []
+
+        for (const lineCtx of lines) {
+            const newLineCtx = createNewCtxFromBinding(lineEntity, lineCtx, bindings)
+
+            newLines.push(newLineCtx)
+        }
+
+        return JSON.stringify(newLines)
+    },
+
+
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/Link/index.js

@@ -33,6 +33,9 @@ export default createFieldType({
 		properties: null
 	},
 
+
+    allowBindings:["link", "text", "number"],
+
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/Primary/index.js

@@ -33,6 +33,7 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["number", "text", "link"],
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/calculation/CalculationColumn/index.js

@@ -33,6 +33,8 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["text", "number"],
+
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/calculation/CalculationLine/index.js

@@ -34,6 +34,8 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["text", "number"],
+    
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/list/ListRadio/index.js

@@ -40,6 +40,7 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["text"],
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/localisation/LocalisationLand/index.js

@@ -33,6 +33,8 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["localisation-land"],
+    
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/money/MoneyCurrency/index.js

@@ -33,6 +33,8 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["money-currency"],
+
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/number/NumberInt/index.js

@@ -37,6 +37,7 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["number", "text"],
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/number/float/NumberFloatDefault/index.js

@@ -37,6 +37,8 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["number-float", "text"],
+
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/number/float/NumberFloatPercent/index.js

@@ -37,6 +37,7 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["number-float", "text"],
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/number/float/NumberFloatPrice/index.js

@@ -37,6 +37,7 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["number-float", "text"],
 	formatter: (value) => value,
 	parser: (value) => value,
 

package/src/lib/registry/fieldTypeRegistry/fieldTypes/text/TextTextarea/index.js

@@ -33,6 +33,8 @@ export default createFieldType({
 		properties: null
 	},
 
+    allowBindings:["text-textarea"],
+
 	formatter: (value) => value,
 	parser: (value) => value,