@foblex/flow 18.0.0 → 18.1.1

package/esm2022/testing/factories.mjs

@@ -0,0 +1,367 @@
+// eslint-disable-next-line max-classes-per-file
+import { PointExtensions, TransformModelExtensions } from '@foblex/2d';
+import { EFConnectableSide } from '../f-connection-v2';
+import { F_SELECTED_CLASS } from '../mixins';
+import { elementRef, inputSignal, outputEmitterStub, readonlySignal, unsafeCast } from './internal';
+function createSelectableBehavior(hostElement, isInitiallySelected, overrides) {
+    let selected = isInitiallySelected;
+    const syncClass = () => {
+        if (selected) {
+            hostElement.classList.add(F_SELECTED_CLASS);
+        }
+        else {
+            hostElement.classList.remove(F_SELECTED_CLASS);
+        }
+    };
+    syncClass();
+    return {
+        markAsSelected: overrides.markAsSelected ??
+            (() => {
+                selected = true;
+                syncClass();
+            }),
+        unmarkAsSelected: overrides.unmarkAsSelected ??
+            (() => {
+                selected = false;
+                syncClass();
+            }),
+        isSelected: overrides.isSelected ?? (() => selected),
+    };
+}
+class SelectableFactoryBuilder {
+    _id = 'selectable';
+    _selected = false;
+    _selectionDisabled = false;
+    _hostElement = document.createElement('div');
+    _overrides = {};
+    id(value) {
+        this._id = value;
+        return this;
+    }
+    selected(value) {
+        this._selected = value;
+        return this;
+    }
+    selectionDisabled(value) {
+        this._selectionDisabled = value;
+        return this;
+    }
+    host(element) {
+        this._hostElement = element;
+        return this;
+    }
+    className(value) {
+        this._hostElement.classList.add(value);
+        return this;
+    }
+    dataset(name, value) {
+        this._hostElement.dataset[name] = value;
+        return this;
+    }
+    elementId(value) {
+        this._hostElement.id = value;
+        return this;
+    }
+    onMarkAsSelected(handler) {
+        this._overrides.markAsSelected = handler;
+        return this;
+    }
+    onUnmarkAsSelected(handler) {
+        this._overrides.unmarkAsSelected = handler;
+        return this;
+    }
+    onIsSelected(handler) {
+        this._overrides.isSelected = handler;
+        return this;
+    }
+    build() {
+        const selectable = createSelectableBehavior(this._hostElement, this._selected, this._overrides);
+        return {
+            fId: readonlySignal(this._id),
+            fSelectionDisabled: readonlySignal(this._selectionDisabled),
+            hostElement: this._hostElement,
+            markAsSelected: selectable.markAsSelected,
+            unmarkAsSelected: selectable.unmarkAsSelected,
+            isSelected: selectable.isSelected,
+        };
+    }
+}
+class NodeFactoryBuilder {
+    _id = 'node';
+    _parentId = null;
+    _selected = false;
+    _selectionDisabled = false;
+    _hostElement = document.createElement('div');
+    _overrides = {};
+    id(value) {
+        this._id = value;
+        return this;
+    }
+    parent(value) {
+        this._parentId = value;
+        return this;
+    }
+    selected(value) {
+        this._selected = value;
+        return this;
+    }
+    selectionDisabled(value) {
+        this._selectionDisabled = value;
+        return this;
+    }
+    host(value) {
+        this._hostElement = value;
+        return this;
+    }
+    onMarkAsSelected(handler) {
+        this._overrides.markAsSelected = handler;
+        return this;
+    }
+    onUnmarkAsSelected(handler) {
+        this._overrides.unmarkAsSelected = handler;
+        return this;
+    }
+    onIsSelected(handler) {
+        this._overrides.isSelected = handler;
+        return this;
+    }
+    build() {
+        const selectable = createSelectableBehavior(this._hostElement, this._selected, this._overrides);
+        const node = {
+            fId: readonlySignal(this._id),
+            fParentId: readonlySignal(this._parentId),
+            fSelectionDisabled: readonlySignal(this._selectionDisabled),
+            hostElement: this._hostElement,
+            connectors: [],
+            markAsSelected: selectable.markAsSelected,
+            unmarkAsSelected: selectable.unmarkAsSelected,
+            isSelected: selectable.isSelected,
+            refresh() {
+                // No-op for tests.
+            },
+        };
+        return unsafeCast(node);
+    }
+}
+class ConnectionFactoryBuilder {
+    _id = 'connection';
+    _outputId = 'output';
+    _inputId = 'input';
+    _selected = false;
+    _selectionDisabled = false;
+    _hostElement = document.createElement('div');
+    _overrides = {};
+    id(value) {
+        this._id = value;
+        return this;
+    }
+    outputId(value) {
+        this._outputId = value;
+        return this;
+    }
+    inputId(value) {
+        this._inputId = value;
+        return this;
+    }
+    selected(value) {
+        this._selected = value;
+        return this;
+    }
+    selectionDisabled(value) {
+        this._selectionDisabled = value;
+        return this;
+    }
+    host(value) {
+        this._hostElement = value;
+        return this;
+    }
+    onMarkAsSelected(handler) {
+        this._overrides.markAsSelected = handler;
+        return this;
+    }
+    onUnmarkAsSelected(handler) {
+        this._overrides.unmarkAsSelected = handler;
+        return this;
+    }
+    onIsSelected(handler) {
+        this._overrides.isSelected = handler;
+        return this;
+    }
+    build() {
+        const selectable = createSelectableBehavior(this._hostElement, this._selected, this._overrides);
+        const connection = {
+            fId: readonlySignal(this._id),
+            fOutputId: readonlySignal(this._outputId),
+            fInputId: readonlySignal(this._inputId),
+            fSelectionDisabled: readonlySignal(this._selectionDisabled),
+            hostElement: this._hostElement,
+            markAsSelected: selectable.markAsSelected,
+            unmarkAsSelected: selectable.unmarkAsSelected,
+            isSelected: selectable.isSelected,
+        };
+        return unsafeCast(connection);
+    }
+}
+class CanvasFactoryBuilder {
+    _hostElement = document.createElement('div');
+    _groupsContainer = document.createElement('div');
+    _nodesContainer = document.createElement('div');
+    _connectionsContainer = document.createElement('div');
+    _debounce = 0;
+    host(value) {
+        this._hostElement = value;
+        return this;
+    }
+    groupsContainer(value) {
+        this._groupsContainer = value;
+        return this;
+    }
+    nodesContainer(value) {
+        this._nodesContainer = value;
+        return this;
+    }
+    connectionsContainer(value) {
+        this._connectionsContainer = value;
+        return this;
+    }
+    debounce(value) {
+        this._debounce = value;
+        return this;
+    }
+    build() {
+        const transform = TransformModelExtensions.default();
+        const canvas = {
+            hostElement: this._hostElement,
+            fCanvasChange: outputEmitterStub(),
+            fGroupsContainer: readonlySignal(elementRef(this._groupsContainer)),
+            fNodesContainer: readonlySignal(elementRef(this._nodesContainer)),
+            fConnectionsContainer: readonlySignal(elementRef(this._connectionsContainer)),
+            debounce: readonlySignal(this._debounce),
+            transform,
+            redraw() {
+                // No-op for tests.
+            },
+            redrawWithAnimation() {
+                // No-op for tests.
+            },
+            setScale(scale, toPosition) {
+                transform.scale = scale;
+                transform.scaledPosition = toPosition;
+            },
+            resetScale() {
+                transform.scale = 1;
+                transform.scaledPosition = PointExtensions.initialize();
+            },
+        };
+        return unsafeCast(canvas);
+    }
+}
+class FlowFactoryBuilder {
+    _id = 'flow';
+    _hostElement = document.createElement('div');
+    id(value) {
+        this._id = value;
+        return this;
+    }
+    host(value) {
+        this._hostElement = value;
+        return this;
+    }
+    build() {
+        const flow = {
+            fId: inputSignal(this._id),
+            hostElement: this._hostElement,
+            fLoaded: outputEmitterStub(),
+        };
+        return unsafeCast(flow);
+    }
+}
+class ConnectorFactoryBuilder {
+    _id = 'connector';
+    _kind = 'input';
+    _nodeId = 'node';
+    _nodeHost = document.createElement('div');
+    _hostElement = document.createElement('div');
+    _disabled = false;
+    _canBeConnected = true;
+    id(value) {
+        this._id = value;
+        return this;
+    }
+    kind(value) {
+        this._kind = value;
+        return this;
+    }
+    nodeId(value) {
+        this._nodeId = value;
+        return this;
+    }
+    nodeHost(value) {
+        this._nodeHost = value;
+        return this;
+    }
+    host(value) {
+        this._hostElement = value;
+        return this;
+    }
+    disabled(value) {
+        this._disabled = value;
+        return this;
+    }
+    canBeConnected(value) {
+        this._canBeConnected = value;
+        return this;
+    }
+    build() {
+        let isConnected = false;
+        const toConnector = [];
+        const hostElement = this._hostElement;
+        const connector = {
+            kind: this._kind,
+            fId: readonlySignal(this._id),
+            fNodeId: this._nodeId,
+            fNodeHost: this._nodeHost,
+            disabled: readonlySignal(this._disabled),
+            hostElement,
+            canBeConnected: this._canBeConnected,
+            toConnector,
+            isSelfConnectable: true,
+            fConnectableSide: EFConnectableSide.AUTO,
+            userFConnectableSide: EFConnectableSide.AUTO,
+            get isConnected() {
+                return isConnected;
+            },
+            isContains(element) {
+                return hostElement.contains(element);
+            },
+            setConnected(targetConnector) {
+                isConnected = true;
+                toConnector.push(targetConnector);
+            },
+            resetConnected() {
+                isConnected = false;
+                toConnector.length = 0;
+            },
+        };
+        return unsafeCast(connector);
+    }
+}
+export function selectableFactory() {
+    return new SelectableFactoryBuilder();
+}
+export function nodeFactory() {
+    return new NodeFactoryBuilder();
+}
+export function connectionFactory() {
+    return new ConnectionFactoryBuilder();
+}
+export function canvasFactory() {
+    return new CanvasFactoryBuilder();
+}
+export function flowFactory() {
+    return new FlowFactoryBuilder();
+}
+export function connectorFactory() {
+    return new ConnectorFactoryBuilder();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factories.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/testing/factories.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line max-classes-per-file\nimport { IPoint, PointExtensions, TransformModelExtensions } from '@foblex/2d';\nimport { EFConnectableSide, FConnectionBase } from '../f-connection-v2';\nimport { FConnectorBase, FConnectorKind } from '../f-connectors';\nimport { FCanvasBase } from '../f-canvas';\nimport { FNodeBase } from '../f-node';\nimport { FFlowBase } from '../f-flow';\nimport { ISelectable, F_SELECTED_CLASS } from '../mixins';\nimport { elementRef, inputSignal, outputEmitterStub, readonlySignal, unsafeCast } from './internal';\n\ninterface SelectableOverrides {\n  markAsSelected?: () => void;\n  unmarkAsSelected?: () => void;\n  isSelected?: () => boolean;\n}\n\nfunction createSelectableBehavior(\n  hostElement: HTMLElement | SVGElement,\n  isInitiallySelected: boolean,\n  overrides: SelectableOverrides,\n): { markAsSelected(): void; unmarkAsSelected(): void; isSelected(): boolean } {\n  let selected = isInitiallySelected;\n\n  const syncClass = () => {\n    if (selected) {\n      hostElement.classList.add(F_SELECTED_CLASS);\n    } else {\n      hostElement.classList.remove(F_SELECTED_CLASS);\n    }\n  };\n\n  syncClass();\n\n  return {\n    markAsSelected:\n      overrides.markAsSelected ??\n      (() => {\n        selected = true;\n        syncClass();\n      }),\n\n    unmarkAsSelected:\n      overrides.unmarkAsSelected ??\n      (() => {\n        selected = false;\n        syncClass();\n      }),\n\n    isSelected: overrides.isSelected ?? (() => selected),\n  };\n}\n\nclass SelectableFactoryBuilder {\n  private _id = 'selectable';\n  private _selected = false;\n  private _selectionDisabled = false;\n  private _hostElement: HTMLElement | SVGElement = document.createElement('div');\n  private _overrides: SelectableOverrides = {};\n\n  public id(value: string): this {\n    this._id = value;\n\n    return this;\n  }\n\n  public selected(value: boolean): this {\n    this._selected = value;\n\n    return this;\n  }\n\n  public selectionDisabled(value: boolean): this {\n    this._selectionDisabled = value;\n\n    return this;\n  }\n\n  public host(element: HTMLElement | SVGElement): this {\n    this._hostElement = element;\n\n    return this;\n  }\n\n  public className(value: string): this {\n    this._hostElement.classList.add(value);\n\n    return this;\n  }\n\n  public dataset(name: string, value: string): this {\n    this._hostElement.dataset[name] = value;\n\n    return this;\n  }\n\n  public elementId(value: string): this {\n    this._hostElement.id = value;\n\n    return this;\n  }\n\n  public onMarkAsSelected(handler: () => void): this {\n    this._overrides.markAsSelected = handler;\n\n    return this;\n  }\n\n  public onUnmarkAsSelected(handler: () => void): this {\n    this._overrides.unmarkAsSelected = handler;\n\n    return this;\n  }\n\n  public onIsSelected(handler: () => boolean): this {\n    this._overrides.isSelected = handler;\n\n    return this;\n  }\n\n  public build(): ISelectable {\n    const selectable = createSelectableBehavior(this._hostElement, this._selected, this._overrides);\n\n    return {\n      fId: readonlySignal(this._id),\n      fSelectionDisabled: readonlySignal(this._selectionDisabled),\n      hostElement: this._hostElement,\n      markAsSelected: selectable.markAsSelected,\n      unmarkAsSelected: selectable.unmarkAsSelected,\n      isSelected: selectable.isSelected,\n    };\n  }\n}\n\nclass NodeFactoryBuilder {\n  private _id = 'node';\n  private _parentId: string | null | undefined = null;\n  private _selected = false;\n  private _selectionDisabled = false;\n  private _hostElement: HTMLElement = document.createElement('div');\n  private _overrides: SelectableOverrides = {};\n\n  public id(value: string): this {\n    this._id = value;\n\n    return this;\n  }\n\n  public parent(value: string | null | undefined): this {\n    this._parentId = value;\n\n    return this;\n  }\n\n  public selected(value: boolean): this {\n    this._selected = value;\n\n    return this;\n  }\n\n  public selectionDisabled(value: boolean): this {\n    this._selectionDisabled = value;\n\n    return this;\n  }\n\n  public host(value: HTMLElement): this {\n    this._hostElement = value;\n\n    return this;\n  }\n\n  public onMarkAsSelected(handler: () => void): this {\n    this._overrides.markAsSelected = handler;\n\n    return this;\n  }\n\n  public onUnmarkAsSelected(handler: () => void): this {\n    this._overrides.unmarkAsSelected = handler;\n\n    return this;\n  }\n\n  public onIsSelected(handler: () => boolean): this {\n    this._overrides.isSelected = handler;\n\n    return this;\n  }\n\n  public build(): FNodeBase {\n    const selectable = createSelectableBehavior(this._hostElement, this._selected, this._overrides);\n\n    const node = {\n      fId: readonlySignal(this._id),\n      fParentId: readonlySignal(this._parentId),\n      fSelectionDisabled: readonlySignal(this._selectionDisabled),\n      hostElement: this._hostElement,\n      connectors: [] as FConnectorBase[],\n      markAsSelected: selectable.markAsSelected,\n      unmarkAsSelected: selectable.unmarkAsSelected,\n      isSelected: selectable.isSelected,\n      refresh(): void {\n        // No-op for tests.\n      },\n    };\n\n    return unsafeCast<FNodeBase>(node);\n  }\n}\n\nclass ConnectionFactoryBuilder {\n  private _id = 'connection';\n  private _outputId = 'output';\n  private _inputId = 'input';\n  private _selected = false;\n  private _selectionDisabled = false;\n  private _hostElement: HTMLElement = document.createElement('div');\n  private _overrides: SelectableOverrides = {};\n\n  public id(value: string): this {\n    this._id = value;\n\n    return this;\n  }\n\n  public outputId(value: string): this {\n    this._outputId = value;\n\n    return this;\n  }\n\n  public inputId(value: string): this {\n    this._inputId = value;\n\n    return this;\n  }\n\n  public selected(value: boolean): this {\n    this._selected = value;\n\n    return this;\n  }\n\n  public selectionDisabled(value: boolean): this {\n    this._selectionDisabled = value;\n\n    return this;\n  }\n\n  public host(value: HTMLElement): this {\n    this._hostElement = value;\n\n    return this;\n  }\n\n  public onMarkAsSelected(handler: () => void): this {\n    this._overrides.markAsSelected = handler;\n\n    return this;\n  }\n\n  public onUnmarkAsSelected(handler: () => void): this {\n    this._overrides.unmarkAsSelected = handler;\n\n    return this;\n  }\n\n  public onIsSelected(handler: () => boolean): this {\n    this._overrides.isSelected = handler;\n\n    return this;\n  }\n\n  public build(): FConnectionBase {\n    const selectable = createSelectableBehavior(this._hostElement, this._selected, this._overrides);\n\n    const connection = {\n      fId: readonlySignal(this._id),\n      fOutputId: readonlySignal(this._outputId),\n      fInputId: readonlySignal(this._inputId),\n      fSelectionDisabled: readonlySignal(this._selectionDisabled),\n      hostElement: this._hostElement,\n      markAsSelected: selectable.markAsSelected,\n      unmarkAsSelected: selectable.unmarkAsSelected,\n      isSelected: selectable.isSelected,\n    };\n\n    return unsafeCast<FConnectionBase>(connection);\n  }\n}\n\nclass CanvasFactoryBuilder {\n  private _hostElement: HTMLElement = document.createElement('div');\n  private _groupsContainer: HTMLElement = document.createElement('div');\n  private _nodesContainer: HTMLElement = document.createElement('div');\n  private _connectionsContainer: HTMLElement = document.createElement('div');\n  private _debounce = 0;\n\n  public host(value: HTMLElement): this {\n    this._hostElement = value;\n\n    return this;\n  }\n\n  public groupsContainer(value: HTMLElement): this {\n    this._groupsContainer = value;\n\n    return this;\n  }\n\n  public nodesContainer(value: HTMLElement): this {\n    this._nodesContainer = value;\n\n    return this;\n  }\n\n  public connectionsContainer(value: HTMLElement): this {\n    this._connectionsContainer = value;\n\n    return this;\n  }\n\n  public debounce(value: number): this {\n    this._debounce = value;\n\n    return this;\n  }\n\n  public build(): FCanvasBase {\n    const transform = TransformModelExtensions.default();\n\n    const canvas = {\n      hostElement: this._hostElement,\n      fCanvasChange: outputEmitterStub(),\n      fGroupsContainer: readonlySignal(elementRef(this._groupsContainer)),\n      fNodesContainer: readonlySignal(elementRef(this._nodesContainer)),\n      fConnectionsContainer: readonlySignal(elementRef(this._connectionsContainer)),\n      debounce: readonlySignal(this._debounce),\n      transform,\n      redraw(): void {\n        // No-op for tests.\n      },\n      redrawWithAnimation(): void {\n        // No-op for tests.\n      },\n      setScale(scale: number, toPosition: IPoint): void {\n        transform.scale = scale;\n        transform.scaledPosition = toPosition;\n      },\n      resetScale(): void {\n        transform.scale = 1;\n        transform.scaledPosition = PointExtensions.initialize();\n      },\n    };\n\n    return unsafeCast<FCanvasBase>(canvas);\n  }\n}\n\nclass FlowFactoryBuilder {\n  private _id = 'flow';\n  private _hostElement: HTMLElement = document.createElement('div');\n\n  public id(value: string): this {\n    this._id = value;\n\n    return this;\n  }\n\n  public host(value: HTMLElement): this {\n    this._hostElement = value;\n\n    return this;\n  }\n\n  public build(): FFlowBase {\n    const flow = {\n      fId: inputSignal(this._id),\n      hostElement: this._hostElement,\n      fLoaded: outputEmitterStub<string>(),\n    };\n\n    return unsafeCast<FFlowBase>(flow);\n  }\n}\n\nclass ConnectorFactoryBuilder {\n  private _id = 'connector';\n  private _kind: FConnectorKind = 'input';\n  private _nodeId = 'node';\n  private _nodeHost: HTMLElement | SVGElement = document.createElement('div');\n  private _hostElement: HTMLElement | SVGElement = document.createElement('div');\n  private _disabled = false;\n  private _canBeConnected = true;\n\n  public id(value: string): this {\n    this._id = value;\n\n    return this;\n  }\n\n  public kind(value: FConnectorKind): this {\n    this._kind = value;\n\n    return this;\n  }\n\n  public nodeId(value: string): this {\n    this._nodeId = value;\n\n    return this;\n  }\n\n  public nodeHost(value: HTMLElement | SVGElement): this {\n    this._nodeHost = value;\n\n    return this;\n  }\n\n  public host(value: HTMLElement | SVGElement): this {\n    this._hostElement = value;\n\n    return this;\n  }\n\n  public disabled(value: boolean): this {\n    this._disabled = value;\n\n    return this;\n  }\n\n  public canBeConnected(value: boolean): this {\n    this._canBeConnected = value;\n\n    return this;\n  }\n\n  public build(): FConnectorBase {\n    let isConnected = false;\n    const toConnector: FConnectorBase[] = [];\n    const hostElement = this._hostElement;\n\n    const connector = {\n      kind: this._kind,\n      fId: readonlySignal(this._id),\n      fNodeId: this._nodeId,\n      fNodeHost: this._nodeHost,\n      disabled: readonlySignal(this._disabled),\n      hostElement,\n      canBeConnected: this._canBeConnected,\n      toConnector,\n      isSelfConnectable: true,\n      fConnectableSide: EFConnectableSide.AUTO,\n      userFConnectableSide: EFConnectableSide.AUTO,\n      get isConnected(): boolean {\n        return isConnected;\n      },\n      isContains(element: HTMLElement | SVGElement): boolean {\n        return hostElement.contains(element);\n      },\n      setConnected(targetConnector: FConnectorBase): void {\n        isConnected = true;\n        toConnector.push(targetConnector);\n      },\n      resetConnected(): void {\n        isConnected = false;\n        toConnector.length = 0;\n      },\n    };\n\n    return unsafeCast<FConnectorBase>(connector);\n  }\n}\n\nexport function selectableFactory(): SelectableFactoryBuilder {\n  return new SelectableFactoryBuilder();\n}\n\nexport function nodeFactory(): NodeFactoryBuilder {\n  return new NodeFactoryBuilder();\n}\n\nexport function connectionFactory(): ConnectionFactoryBuilder {\n  return new ConnectionFactoryBuilder();\n}\n\nexport function canvasFactory(): CanvasFactoryBuilder {\n  return new CanvasFactoryBuilder();\n}\n\nexport function flowFactory(): FlowFactoryBuilder {\n  return new FlowFactoryBuilder();\n}\n\nexport function connectorFactory(): ConnectorFactoryBuilder {\n  return new ConnectorFactoryBuilder();\n}\n"]}

package/esm2022/testing/index.mjs

@@ -0,0 +1,8 @@
+export * from './pure-harness';
+export * from './di-harness';
+export * from './component-harness';
+export * from './mediator-harness';
+export * from './registry-harness';
+export * from './factories';
+export * from './jasmine';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL3Rlc3RpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVyZS1oYXJuZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vZGktaGFybmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC1oYXJuZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vbWVkaWF0b3ItaGFybmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL3JlZ2lzdHJ5LWhhcm5lc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9mYWN0b3JpZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9qYXNtaW5lJztcbiJdfQ==

package/esm2022/testing/internal/index.mjs

@@ -0,0 +1,2 @@
+export * from './type-helpers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL3Rlc3RpbmcvaW50ZXJuYWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHlwZS1oZWxwZXJzJztcbiJdfQ==

package/esm2022/testing/internal/type-helpers.mjs

@@ -0,0 +1,28 @@
+import { ElementRef, signal } from '@angular/core';
+/**
+ * Internal escape hatch for abstract Angular classes used as test doubles.
+ *
+ * Classes such as FNodeBase/FConnectionBase/FCanvasBase rely on Angular DI internals,
+ * so they cannot be directly instantiated in pure tests. Keep casts isolated here.
+ */
+export function unsafeCast(value) {
+    return value;
+}
+export function readonlySignal(value) {
+    return signal(value).asReadonly();
+}
+export function inputSignal(value) {
+    return unsafeCast(readonlySignal(value));
+}
+export function outputEmitterStub(onEmit) {
+    const emitter = {
+        emit(value) {
+            onEmit?.(value);
+        },
+    };
+    return unsafeCast(emitter);
+}
+export function elementRef(nativeElement) {
+    return new ElementRef(nativeElement);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/jasmine/index.mjs

@@ -0,0 +1,2 @@
+export * from './spy-helpers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL3Rlc3RpbmcvamFzbWluZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3B5LWhlbHBlcnMnO1xuIl19

package/esm2022/testing/jasmine/spy-helpers.mjs

@@ -0,0 +1,14 @@
+function getJasmineRuntime() {
+    const runtime = globalThis.jasmine;
+    if (!runtime) {
+        throw new Error('Jasmine runtime is not available.');
+    }
+    return runtime;
+}
+export function createSpy(name) {
+    return getJasmineRuntime().createSpy(name);
+}
+export function createSpyObj(baseName, methodNames) {
+    return getJasmineRuntime().createSpyObj(baseName, methodNames);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/mediator-harness.mjs

@@ -0,0 +1,14 @@
+import { FMediator } from '@foblex/mediator';
+import { injectFromDi } from './di-harness';
+export function createMediatorHarness(mediator = injectFromDi(FMediator)) {
+    return {
+        mediator,
+        execute(request) {
+            return mediator.execute(request);
+        },
+    };
+}
+export function executeRequest(request, mediator = injectFromDi(FMediator)) {
+    return mediator.execute(request);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaWF0b3ItaGFybmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvdGVzdGluZy9tZWRpYXRvci1oYXJuZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBTzVDLE1BQU0sVUFBVSxxQkFBcUIsQ0FDbkMsV0FBc0IsWUFBWSxDQUFDLFNBQVMsQ0FBQztJQUU3QyxPQUFPO1FBQ0wsUUFBUTtRQUNSLE9BQU8sQ0FBWSxPQUFnQjtZQUNqQyxPQUFPLFFBQVEsQ0FBQyxPQUFPLENBQVksT0FBTyxDQUFDLENBQUM7UUFDOUMsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLGNBQWMsQ0FDNUIsT0FBZ0IsRUFDaEIsV0FBc0IsWUFBWSxDQUFDLFNBQVMsQ0FBQztJQUU3QyxPQUFPLFFBQVEsQ0FBQyxPQUFPLENBQVksT0FBTyxDQUFDLENBQUM7QUFDOUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZNZWRpYXRvciB9IGZyb20gJ0Bmb2JsZXgvbWVkaWF0b3InO1xuaW1wb3J0IHsgaW5qZWN0RnJvbURpIH0gZnJvbSAnLi9kaS1oYXJuZXNzJztcblxuZXhwb3J0IGludGVyZmFjZSBNZWRpYXRvckhhcm5lc3Mge1xuICBtZWRpYXRvcjogRk1lZGlhdG9yO1xuICBleGVjdXRlPFRSZXNwb25zZT4ocmVxdWVzdDogdW5rbm93bik6IFRSZXNwb25zZTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU1lZGlhdG9ySGFybmVzcyhcbiAgbWVkaWF0b3I6IEZNZWRpYXRvciA9IGluamVjdEZyb21EaShGTWVkaWF0b3IpLFxuKTogTWVkaWF0b3JIYXJuZXNzIHtcbiAgcmV0dXJuIHtcbiAgICBtZWRpYXRvcixcbiAgICBleGVjdXRlPFRSZXNwb25zZT4ocmVxdWVzdDogdW5rbm93bik6IFRSZXNwb25zZSB7XG4gICAgICByZXR1cm4gbWVkaWF0b3IuZXhlY3V0ZTxUUmVzcG9uc2U+KHJlcXVlc3QpO1xuICAgIH0sXG4gIH07XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBleGVjdXRlUmVxdWVzdDxUUmVzcG9uc2U+KFxuICByZXF1ZXN0OiB1bmtub3duLFxuICBtZWRpYXRvcjogRk1lZGlhdG9yID0gaW5qZWN0RnJvbURpKEZNZWRpYXRvciksXG4pOiBUUmVzcG9uc2Uge1xuICByZXR1cm4gbWVkaWF0b3IuZXhlY3V0ZTxUUmVzcG9uc2U+KHJlcXVlc3QpO1xufVxuIl19

package/esm2022/testing/pure-harness.mjs

@@ -0,0 +1,25 @@
+function applyElementOptions(element, options = {}) {
+    if (options.id) {
+        element.id = options.id;
+    }
+    options.classes?.forEach((className) => element.classList.add(className));
+    Object.entries(options.dataset ?? {}).forEach(([key, value]) => {
+        element.dataset[key] = value;
+    });
+    return element;
+}
+export function createPureHarness() {
+    return {
+        point(x, y) {
+            return { x, y };
+        },
+        element(tag = 'div', options) {
+            return applyElementOptions(document.createElement(tag), options);
+        },
+        svg(tag = 'g', options) {
+            const element = document.createElementNS('http://www.w3.org/2000/svg', tag);
+            return applyElementOptions(element, options);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/registry-harness.mjs

@@ -0,0 +1,23 @@
+export function registryAdd(registry, instance) {
+    registry.add(instance);
+    return instance;
+}
+export function registryAddMany(registry, instances) {
+    registry.addMany(instances);
+    return instances;
+}
+export function registryGet(registry, id) {
+    return registry.get(id);
+}
+export function registryRequire(registry, id) {
+    return registry.require(id);
+}
+export function assertRegistryIds(registry, expectedIds) {
+    const actualIds = registry.getAll().map((item) => item.fId());
+    const matches = actualIds.length === expectedIds.length &&
+        actualIds.every((id, index) => id === expectedIds[index]);
+    if (!matches) {
+        throw new Error(`Registry ids mismatch. Expected: [${expectedIds.join(', ')}], actual: [${actualIds.join(', ')}].`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/f-backgroud/f-background-base.d.ts

@@ -4,7 +4,7 @@ import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_BACKGROUND: InjectionToken<FBackgroundBase>;
 export declare abstract class FBackgroundBase implements IHasHostElement {
-    abstract hostElement: HTMLElement;
+    readonly hostElement: any;
     abstract setTransform(transform: ITransformModel): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FBackgroundBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FBackgroundBase, never, never, {}, {}, never, never, false, never>;

package/f-backgroud/f-background.component.d.ts

@@ -1,12 +1,10 @@
-import { AfterContentInit, OnDestroy, OnInit } from "@angular/core";
+import { AfterContentInit, OnDestroy, OnInit } from '@angular/core';
 import { FBackgroundBase } from './f-background-base';
 import { ITransformModel } from '@foblex/2d';
 import * as i0 from "@angular/core";
 export declare class FBackgroundComponent extends FBackgroundBase implements OnInit, AfterContentInit, OnDestroy {
-    private readonly _fMediator;
-    private readonly _elementReference;
-    get hostElement(): HTMLElement;
-    protected fBackgroundPattern: import("@angular/core").Signal<import("./domain").IFBackgroundPattern | undefined>;
+    private readonly _mediator;
+    protected readonly fBackgroundPattern: import("@angular/core").Signal<import("./domain").IFBackgroundPattern | undefined>;
     ngOnInit(): void;
     ngAfterContentInit(): void;
     setTransform(transform: ITransformModel): void;

package/f-backgroud/f-rect-pattern/f-rect-pattern.component.d.ts

@@ -1,4 +1,4 @@
-import { OnChanges, OnInit, SimpleChanges } from "@angular/core";
+import { OnChanges, OnInit, SimpleChanges } from '@angular/core';
 import { ITransformModel } from '@foblex/2d';
 import { IFBackgroundPattern } from '../domain';
 import * as i0 from "@angular/core";
@@ -27,7 +27,7 @@ export declare class FRectPatternComponent implements OnInit, OnChanges, IFBackg
     private _redraw;
     private _calculatePattern;
     private _redrawPattern;
-    private redrawLine;
+    private _redrawLine;
     setTransform(transform: ITransformModel): void;
     private _refresh;
     static ɵfac: i0.ɵɵFactoryDeclaration<FRectPatternComponent, never>;

package/f-connection-v2/components/connection-marker/models/f-connection-marker-base.d.ts

@@ -1,6 +1,7 @@
 import { InjectionToken } from '@angular/core';
 export declare const F_CONNECTION_MARKER: InjectionToken<unknown>;
 export declare abstract class FConnectionMarkerBase {
+    readonly fId: import("@angular/core").WritableSignal<string>;
     readonly hostElement: any;
     abstract width: number;
     abstract height: number;

package/f-connection-v2/models/index.d.ts

@@ -1,2 +1 @@
 export * from './f-connection-components-parent';
-export * from './f-connection-waypoints-changed-event';

package/f-connectors/f-connector-base.d.ts

@@ -1,7 +1,9 @@
 import { IHasHostElement } from '../i-has-host-element';
 import { Signal } from '@angular/core';
 import { EFConnectableSide } from '../f-connection-v2/enums/e-f-connectable-side';
+export type FConnectorKind = 'input' | 'output' | 'outlet';
 export declare abstract class FConnectorBase implements IHasHostElement {
+    abstract readonly kind: FConnectorKind;
     abstract fId: Signal<string>;
     abstract fNodeId: string;
     abstract fNodeHost: HTMLElement | SVGElement;

package/f-connectors/f-node-input/f-node-input-base.d.ts

@@ -1,8 +1,9 @@
 import { InjectionToken, Signal } from '@angular/core';
-import { FConnectorBase } from '../f-connector-base';
+import { FConnectorBase, FConnectorKind } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_INPUT: InjectionToken<FNodeInputBase>;
 export declare abstract class FNodeInputBase extends FConnectorBase {
+    kind: FConnectorKind;
     abstract category: Signal<string | undefined>;
     abstract multiple: Signal<boolean>;
     get canBeConnected(): boolean;