@elyx-code/editor-ui 0.0.2

package/src/services/editor/create/condition.ts

@@ -0,0 +1,25 @@
+import { IConnectionDrawingOptions } from '..';
+import {
+	ProjectState,
+	ActionDescriptorState,
+	ConditionState,
+	ChangeSet,
+	ChangeSetEntityChangeType,
+} from '@elyx-code/project-logic-tree';
+import { connectPassthroughCallable } from './utils';
+
+export function createConditionFromActionDescriptor(
+	from: ActionDescriptorState,
+	connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+): ConditionState {
+	// Create a new function-declaration that implements the abstract entity
+	const newCondition = from.implementAsCondition(changeSet);
+
+	changeSet.add(newCondition, ChangeSetEntityChangeType.Added);
+
+	connectPassthroughCallable(newCondition, connectionOptions, project, changeSet);
+
+	return newCondition;
+}

package/src/services/editor/create/definition-entity.ts

@@ -0,0 +1,29 @@
+import { IConnectionDrawingOptions } from '..';
+import {
+	ProjectState,
+	BuiltInBaseEntityState,
+	DefinitionEntityState,
+	ChangeSet,
+	ChangeSetEntityChangeType,
+} from '@elyx-code/project-logic-tree';
+import { findNextAvailableName } from './utils';
+
+export function createDefinitionEntityFromBuiltInBaseEntity(
+	from: BuiltInBaseEntityState,
+	_connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+): DefinitionEntityState {
+	const newName = findNextAvailableName('New definition', project.entities);
+
+	// Create a new definition entity of this built-in-base-entity at this coordinates
+	const newDefinition = from.implement(newName, changeSet);
+
+	if (!!newDefinition) {
+		changeSet.add(newDefinition, ChangeSetEntityChangeType.Added);
+
+		return newDefinition as DefinitionEntityState;
+	}
+
+	return null;
+}

package/src/services/editor/create/function-call.ts

@@ -0,0 +1,25 @@
+import { IConnectionDrawingOptions } from '..';
+import {
+	ProjectState,
+	FunctionDeclarationState,
+	FunctionCallState,
+	ChangeSet,
+	ChangeSetEntityChangeType,
+} from '@elyx-code/project-logic-tree';
+import { connectPassthroughCallable } from './utils';
+
+export function createFunctionCallFromFunctionDeclaration(
+	from: FunctionDeclarationState,
+	connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+): FunctionCallState {
+	// Create a new function call of this function declaration at this coordinates
+	const newCall = from.createCall(changeSet);
+
+	changeSet.add(newCall, ChangeSetEntityChangeType.Added);
+
+	connectPassthroughCallable(newCall, connectionOptions, project, changeSet);
+
+	return newCall;
+}

package/src/services/editor/create/global-event.ts

@@ -0,0 +1,33 @@
+import {
+	ChangeSet,
+	ChangeSetEntityChangeType,
+	EntityType,
+	GlobalEventNames,
+	IGlobalEventTransfer,
+} from '@elyx-code/project-logic-tree';
+import { IConnectionDrawingOptions } from '..';
+import {
+	ProjectState,
+	ActionDescriptorState,
+	GlobalEventState,
+	createStateFromTypeAndSubscribe,
+} from '@elyx-code/project-logic-tree';
+import { createSemanticId } from '@elyx-code/project-logic-tree';
+import { resolveEntityName } from '@elyx-code/project-logic-tree';
+
+export function createGlobalEventFromActionDescriptor(
+	from: ActionDescriptorState,
+	_connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+): GlobalEventState {
+	// Create a new function-declaration that implements the abstract entity
+	const newInstance = from.implementAsGlobalEvent(
+		changeSet,
+		project,
+	) as GlobalEventState;
+
+	changeSet.add(newInstance, ChangeSetEntityChangeType.Added);
+
+	return newInstance;
+}

package/src/services/editor/create/loop.ts

@@ -0,0 +1,25 @@
+import { IConnectionDrawingOptions } from '..';
+import {
+	ProjectState,
+	ActionDescriptorState,
+	LoopState,
+	ChangeSet,
+	ChangeSetEntityChangeType,
+} from '@elyx-code/project-logic-tree';
+import { connectPassthroughCallable } from './utils';
+
+export function createLoopFromActionDescriptor(
+	from: ActionDescriptorState,
+	connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+): LoopState {
+	// Create a new function-declaration that implements the abstract entity
+	const newLoop = from.implementAsLoop(changeSet);
+
+	changeSet.add(newLoop, ChangeSetEntityChangeType.Added);
+
+	connectPassthroughCallable(newLoop, connectionOptions, project, changeSet);
+
+	return newLoop;
+}

package/src/services/editor/create/operation.ts

@@ -0,0 +1,30 @@
+import { IConnectionDrawingOptions } from '..';
+import {
+	ProjectState,
+	ActionDescriptorState,
+	OperationState,
+	ChangeSet,
+	ChangeSetEntityChangeType,
+} from '@elyx-code/project-logic-tree';
+import { connectPassthroughCallable } from './utils';
+
+export function createOperationFromActionDescriptor(
+	from: ActionDescriptorState,
+	connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+): OperationState {
+	// Create a new function-declaration that implements the abstract entity
+	const newOperation = from.implementAsOperation(changeSet);
+
+	changeSet.add(newOperation, ChangeSetEntityChangeType.Added);
+
+	connectPassthroughCallable(
+		newOperation,
+		connectionOptions,
+		project,
+		changeSet
+	);
+
+	return newOperation;
+}

package/src/services/editor/create/utils.ts

@@ -0,0 +1,140 @@
+import { Logger } from '@elyx-code/common-ts-utils';
+import { ConnectionNodeType, IConnectionDrawingOptions } from '..';
+import {
+	EntryPointEntityState,
+	DraggablePassThroughCallableEntityState,
+	ProjectState,
+	ChangeSet,
+	EntityWithLogicScopeState,
+	CallerEntityState,
+	ArgumentDeclarationState,
+	OutputMapState,
+	ValueDescriptorState,
+	VariableState,
+	ExecutableEntityState,
+	InputMapState,
+	EntityWithNames,
+} from '@elyx-code/project-logic-tree';
+import { getScopeOwner } from '@elyx-code/project-logic-tree';
+
+export function connectPassthroughCallable(
+	newPassThroughCallable: DraggablePassThroughCallableEntityState,
+	connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+) {
+	if (connectionOptions?.nodeType === ConnectionNodeType.EntryPointCaller) {
+		newPassThroughCallable.addEntryCaller(
+			connectionOptions.source as EntryPointEntityState,
+			changeSet,
+			true
+		);
+		(connectionOptions.source as EntryPointEntityState).addCall(
+			newPassThroughCallable,
+			changeSet
+		);
+
+		newPassThroughCallable.setParent(
+			connectionOptions.source as EntryPointEntityState,
+			changeSet
+		);
+	} else if (connectionOptions?.nodeType === ConnectionNodeType.SuccessCaller) {
+		Logger.log(
+			'Adding success call from node-type: ',
+			ConnectionNodeType.SuccessCaller
+		);
+		newPassThroughCallable.addSuccessCaller(
+			connectionOptions.source as DraggablePassThroughCallableEntityState,
+			changeSet,
+			true
+		);
+		(
+			connectionOptions.source as DraggablePassThroughCallableEntityState
+		).addSuccessCall(newPassThroughCallable, changeSet, true);
+
+		const callerOwner = getScopeOwner(connectionOptions.source, project);
+
+		if (callerOwner) {
+			newPassThroughCallable.setParent(callerOwner, changeSet);
+		}
+	} else if (connectionOptions?.nodeType === ConnectionNodeType.ErrorCaller) {
+		
+		newPassThroughCallable.addErrorCaller(
+			connectionOptions.source as DraggablePassThroughCallableEntityState,
+			changeSet,
+			true
+		);
+		(
+			connectionOptions.source as DraggablePassThroughCallableEntityState
+		).addErrorCall(newPassThroughCallable, changeSet, true);
+
+		const callerOwner = getScopeOwner(connectionOptions.source, project);
+
+		if (callerOwner) {
+			newPassThroughCallable.setParent(callerOwner, changeSet);
+		}
+	} else if (connectionOptions?.nodeType === ConnectionNodeType.CalledBy) {
+		Logger.log(
+			'Adding success call from node-type: ',
+			ConnectionNodeType.CalledBy
+		);
+		newPassThroughCallable.addSuccessCall(
+			connectionOptions.target as DraggablePassThroughCallableEntityState,
+			changeSet,
+			true
+		);
+		(
+			connectionOptions.target as DraggablePassThroughCallableEntityState
+		).addSuccessCaller(newPassThroughCallable, changeSet, true);
+	}
+}
+
+export function resolveNewParentFromConnectionsScopeOwner(
+	project: ProjectState,
+	connectedSource?:
+		| CallerEntityState
+		| ArgumentDeclarationState
+		| OutputMapState
+		| ValueDescriptorState
+		| VariableState,
+	connectedTarget?:
+		| ExecutableEntityState
+		| InputMapState
+		| VariableState
+): EntityWithLogicScopeState | ProjectState | null {
+	if (!!connectedSource) {
+		return getScopeOwner(connectedSource, project);
+	} else if (!!connectedTarget) {
+		return getScopeOwner(connectedTarget, project);
+	} else {
+		return project;
+	}
+}
+
+export function findNextAvailableName(baseName: string, allEntitiesOfType: EntityWithNames[]): string {
+	let newName = baseName;
+
+	const nameAlreadyTaken = !!allEntitiesOfType.some(
+		(ent) => ent.name === newName
+	);
+
+	if (nameAlreadyTaken) {
+		const parts = baseName.split(' ');
+		const suffix = parts.pop();
+		const suffixAsNumber = parseInt(suffix);
+		const hasSuffixNumber = !isNaN(suffixAsNumber);
+
+		if (hasSuffixNumber) {
+			parts.push(`${suffixAsNumber + 1}`);
+		} else {
+			parts.push(suffix);
+			parts.push('1');
+		}
+
+		newName = parts.join(' ');
+
+		return findNextAvailableName(newName, allEntitiesOfType);
+	}
+
+	return newName;
+}

package/src/services/editor/create/variable-declaration.ts

@@ -0,0 +1,135 @@
+import { IConnectionDrawingOptions } from '..';
+import {
+	ChangeSet,
+	ChangeSetEntityChangeType,
+	createStateFromTypeAndSubscribe,
+	EntityType,
+	ENTRY_POINT_TYPES,
+	EntryPointEntityState,
+	findNextAvailableName,
+	getParentCallerEntity,
+	IVariableDeclarationTransfer,
+	PASS_THROUGH_CALLABLE_TYPES,
+	PassThroughCallableEntityState,
+	ProjectState,
+	resolveEntityName,
+	ValueWritingEntityState,
+	VariableDeclarationState,
+} from '@elyx-code/project-logic-tree';
+import { getScopeOwner } from '@elyx-code/project-logic-tree';
+
+export function createVariableDeclarationFromWritter(
+	from: ValueWritingEntityState,
+	_connectionOptions: IConnectionDrawingOptions,
+	project: ProjectState,
+	changeSet: ChangeSet
+): VariableDeclarationState {
+	const writterScopeOwner = getScopeOwner(from, project);
+
+	const writterCaller = getParentCallerEntity(from);
+
+	let altName: string | null = null;
+
+	if (
+		!!(
+			from.type === EntityType.Operation ||
+			from.type === EntityType.InternalCall
+		) &&
+		from.declaration?.type === EntityType.ActionDescriptor &&
+		!!from.declaration.outputName
+	) {
+		altName = from.declaration.outputName;
+	} else if (
+		from.type === EntityType.FunctionCall &&
+		from.declaration.implements?.type === EntityType.ActionDescriptor &&
+		!!from.declaration.implements.outputName
+	) {
+		altName = from.declaration.implements.outputName;
+	} else if (
+		from.type === EntityType.Operation ||
+		from.type === EntityType.InternalCall ||
+		from.type === EntityType.FunctionCall
+	) {
+		altName = 'Main output of ' + resolveEntityName(from, project);
+	}
+
+	const desiredName = altName || resolveEntityName(from, project);
+
+	// Ensure the name is unique in the scope of the writter
+	const name = findNextAvailableName(
+		desiredName,
+		project.getVariableDeclarations()
+	);
+
+	// Create a new variable instance of this variable declaration at this coordinates
+	const newVariableDeclarationTransfer: IVariableDeclarationTransfer =
+		VariableDeclarationState.new(changeSet);
+	newVariableDeclarationTransfer.name = name;
+	newVariableDeclarationTransfer.calledByEntry =
+		!!writterCaller && ENTRY_POINT_TYPES.includes(writterCaller.type)
+			? [(writterCaller as EntryPointEntityState).toJSON()]
+			: [];
+	newVariableDeclarationTransfer.calledBySuccess =
+		!!writterCaller && !ENTRY_POINT_TYPES.includes(writterCaller.type)
+			? [(writterCaller as PassThroughCallableEntityState).toJSON()]
+			: [];
+	newVariableDeclarationTransfer.parent = writterScopeOwner.toReference();
+	newVariableDeclarationTransfer.readsValue = from.toJSON();
+
+	const newVariableDeclarationInstance = createStateFromTypeAndSubscribe(
+		newVariableDeclarationTransfer,
+		project
+	) as VariableDeclarationState;
+
+	newVariableDeclarationInstance.hydrateAncestors();
+	newVariableDeclarationInstance.addSelfToProject(changeSet);
+	newVariableDeclarationInstance.initChildren(changeSet);
+
+	changeSet.add(
+		newVariableDeclarationInstance,
+		ChangeSetEntityChangeType.Added
+	);
+
+	// We connect the calls of the writter entity with the new variable declaration
+	if (!!writterCaller && ENTRY_POINT_TYPES.includes(writterCaller.type)) {
+		(writterCaller as EntryPointEntityState).addCall(
+			newVariableDeclarationInstance,
+			changeSet
+		);
+		changeSet.add(writterCaller, ChangeSetEntityChangeType.Affected);
+		newVariableDeclarationInstance.addEntryCaller(
+			writterCaller as EntryPointEntityState,
+			changeSet
+		);
+	} else if (
+		!!writterCaller &&
+		PASS_THROUGH_CALLABLE_TYPES.includes(writterCaller.type) &&
+		// Except if the variable will not be at the global level
+		writterScopeOwner.type !== EntityType.Project
+	) {
+		(writterCaller as PassThroughCallableEntityState).addSuccessCall(
+			newVariableDeclarationInstance,
+			changeSet
+		);
+		changeSet.add(writterCaller, ChangeSetEntityChangeType.Affected);
+		newVariableDeclarationInstance.addSuccessCaller(
+			writterCaller as PassThroughCallableEntityState,
+			changeSet
+		);
+	}
+
+	const newDataType = from
+		.getDataType(changeSet)
+		?.clone(changeSet, newVariableDeclarationInstance);
+
+	newDataType?.setParent(newVariableDeclarationInstance, changeSet);
+	newDataType?.initChildren(changeSet);
+
+	if (!!newDataType) {
+		changeSet.add(newDataType, ChangeSetEntityChangeType.Added);
+
+		newVariableDeclarationInstance.setDataType(newDataType, changeSet);
+	}
+
+	return newVariableDeclarationInstance;
+}

package/src/services/editor/create/variable-instance.ts

@@ -0,0 +1,100 @@
+import { ConnectionNodeType, IConnectionDrawingOptions } from '..';
+import {
+	ChangeSet,
+	ChangeSetEntityChangeType,
+	ENTRY_POINT_TYPES,
+	EntryPointEntityState,
+	getParentCallerEntity,
+	getScopeOwner,
+	PASS_THROUGH_CALLABLE_TYPES,
+	PassThroughCallableEntityState,
+	ProjectState,
+	VALUE_READING_TYPES,
+	VALUE_WRITING_TYPES,
+	ValueReadingEntityState,
+	ValueWritingEntityState,
+	VariableDeclarationState,
+	VariableInstanceState,
+} from '@elyx-code/project-logic-tree';
+import { connectPassthroughCallable } from './utils';
+
+export function createVariableInstanceFromDeclaration(
+	from: VariableDeclarationState,
+	connectionOptions: IConnectionDrawingOptions | null,
+	project: ProjectState,
+	changeSet: ChangeSet
+): VariableInstanceState {
+	// Create a new variable instance of this variable declaration at this coordinates
+	const newVariableInstance = from.createInstance(project, changeSet);
+
+	changeSet.add(newVariableInstance, ChangeSetEntityChangeType.Added);
+
+	// Add any related entity that is inferred from the connection data
+	connectPassthroughCallable(
+		newVariableInstance,
+		connectionOptions,
+		project,
+		changeSet
+	);
+
+	if (
+		connectionOptions?.nodeType === ConnectionNodeType.PropertyIn &&
+		!!connectionOptions.target
+	) {
+		const valueReader = connectionOptions.target as ValueReadingEntityState;
+
+		if (valueReader && VALUE_READING_TYPES.includes(valueReader.type)) {
+			newVariableInstance.addValueReader(valueReader, changeSet);
+			valueReader.setValueWriter(newVariableInstance, changeSet);
+		}
+	} else if (
+		connectionOptions?.nodeType === ConnectionNodeType.PropertyOut &&
+		!!connectionOptions.source
+	) {
+		const valueWritter = connectionOptions.source as ValueWritingEntityState;
+
+		if (valueWritter && VALUE_WRITING_TYPES.includes(valueWritter.type)) {
+			newVariableInstance.setValueWriter(valueWritter, changeSet);
+			valueWritter.addValueReader(newVariableInstance, changeSet);
+
+			const writterScopeOwner = getScopeOwner(valueWritter, project);
+
+			newVariableInstance.setParent(writterScopeOwner, changeSet);
+
+			const writterCaller = getParentCallerEntity(from);
+
+			if (!!writterCaller && ENTRY_POINT_TYPES.includes(writterCaller.type)) {
+				(writterCaller as EntryPointEntityState).addCall(
+					newVariableInstance
+				);
+				changeSet.add(
+					writterCaller,
+					ChangeSetEntityChangeType.Affected
+				);
+				newVariableInstance.addEntryCaller(
+					writterCaller as EntryPointEntityState,
+					changeSet
+				);
+			} else if (
+				!!writterCaller &&
+				PASS_THROUGH_CALLABLE_TYPES.includes(writterCaller.type)
+			) {
+				(writterCaller as PassThroughCallableEntityState).addSuccessCall(
+					newVariableInstance,
+					changeSet
+				);
+				newVariableInstance.addSuccessCaller(
+					writterCaller as PassThroughCallableEntityState,
+					changeSet
+				);
+
+				changeSet.add(
+					writterCaller,
+					ChangeSetEntityChangeType.Updated
+				);
+			}
+		}
+	}
+
+	return newVariableInstance;
+}

package/src/services/editor/editor-ui-extensions-context.ts

@@ -0,0 +1,43 @@
+import {
+	ExtensionContextBase,
+	ExtensionContextType,
+	ExtensionsRegistry,
+} from '@elyx-code/project-logic-tree';
+import { EditorService } from './EditorService';
+
+/*
+  Editor UI specific context exposed to extensions
+
+  The editor UI context is a reduced subset API of the Editor UI class which can be used by extensions
+  This is for security reasons.
+  We don't want the extensions to have direct access to the Editor UI class or access any API and internal state that they want.
+  Through this context, extensions can only access the project state in a controlled manner.
+
+  In the future, we can check against a whitelisted manifest of allowed methods and properties
+  for each extension that this context is passed to.
+*/
+export interface IEditorUIContext
+	extends ExtensionContextBase<ExtensionContextType.EditorGUI> {}
+
+export class EditorUIContext
+	extends ExtensionContextBase<ExtensionContextType.EditorGUI>
+	implements IEditorUIContext
+{
+	constructor(
+		extensionsRegistry: ExtensionsRegistry,
+		private readonly _editor: EditorService
+	) {
+		super(extensionsRegistry, ExtensionContextType.EditorGUI);
+	}
+}
+
+export function toEditorUIContext(
+	extensionsRegistry: ExtensionsRegistry,
+	editor: EditorService
+): EditorUIContext {
+	if (editor instanceof EditorUIContext) {
+		return editor;
+	}
+
+	return new EditorUIContext(extensionsRegistry, editor);
+}