@foblex/flow 18.4.0 → 18.5.0

package/esm2022/domain/f-connection/redraw-connections/worker/is-connection-worker-enabled/index.mjs

@@ -0,0 +1,3 @@
+export * from './is-connection-worker-enabled';
+export * from './is-connection-worker-enabled-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL2lzLWNvbm5lY3Rpb24td29ya2VyLWVuYWJsZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pcy1jb25uZWN0aW9uLXdvcmtlci1lbmFibGVkJztcblxuZXhwb3J0ICogZnJvbSAnLi9pcy1jb25uZWN0aW9uLXdvcmtlci1lbmFibGVkLXJlcXVlc3QnO1xuIl19

package/esm2022/domain/f-connection/redraw-connections/worker/is-connection-worker-enabled/is-connection-worker-enabled-request.mjs

@@ -0,0 +1,4 @@
+export class IsConnectionWorkerEnabledRequest {
+    static fToken = Symbol('IsConnectionWorkerEnabledRequest');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtY29ubmVjdGlvbi13b3JrZXItZW5hYmxlZC1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9mLWZsb3cvc3JjL2RvbWFpbi9mLWNvbm5lY3Rpb24vcmVkcmF3LWNvbm5lY3Rpb25zL3dvcmtlci9pcy1jb25uZWN0aW9uLXdvcmtlci1lbmFibGVkL2lzLWNvbm5lY3Rpb24td29ya2VyLWVuYWJsZWQtcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sZ0NBQWdDO0lBQzNDLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLGtDQUFrQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgSXNDb25uZWN0aW9uV29ya2VyRW5hYmxlZFJlcXVlc3Qge1xuICBzdGF0aWMgcmVhZG9ubHkgZlRva2VuID0gU3ltYm9sKCdJc0Nvbm5lY3Rpb25Xb3JrZXJFbmFibGVkUmVxdWVzdCcpO1xufVxuIl19

package/esm2022/domain/f-connection/redraw-connections/worker/is-connection-worker-enabled/is-connection-worker-enabled.mjs

@@ -0,0 +1,35 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { BrowserService } from '@foblex/platform';
+import { FExecutionRegister } from '@foblex/mediator';
+import { ConnectionWorkerState } from '../../models';
+import { IsConnectionWorkerEnabledRequest } from './is-connection-worker-enabled-request';
+import { isConnectionWorkerRuntimeSupported } from '../runtime/connection-worker-runtime';
+import * as i0 from "@angular/core";
+let IsConnectionWorkerEnabled = class IsConnectionWorkerEnabled {
+    _browser = inject(BrowserService);
+    _state = inject(ConnectionWorkerState);
+    handle(_) {
+        if (this._state.isDisabled) {
+            return false;
+        }
+        if (!this._isWorkerAvailable()) {
+            return false;
+        }
+        const windowRef = this._browser.document.defaultView;
+        return isConnectionWorkerRuntimeSupported(windowRef);
+    }
+    _isWorkerAvailable() {
+        return this._browser.isBrowser();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IsConnectionWorkerEnabled, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IsConnectionWorkerEnabled });
+};
+IsConnectionWorkerEnabled = __decorate([
+    FExecutionRegister(IsConnectionWorkerEnabledRequest)
+], IsConnectionWorkerEnabled);
+export { IsConnectionWorkerEnabled };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IsConnectionWorkerEnabled, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtY29ubmVjdGlvbi13b3JrZXItZW5hYmxlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZi1mbG93L3NyYy9kb21haW4vZi1jb25uZWN0aW9uL3JlZHJhdy1jb25uZWN0aW9ucy93b3JrZXIvaXMtY29ubmVjdGlvbi13b3JrZXItZW5hYmxlZC9pcy1jb25uZWN0aW9uLXdvcmtlci1lbmFibGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDbEQsT0FBTyxFQUFFLGtCQUFrQixFQUFjLE1BQU0sa0JBQWtCLENBQUM7QUFDbEUsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ3JELE9BQU8sRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQzFGLE9BQU8sRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLHNDQUFzQyxDQUFDOztBQUluRixJQUFNLHlCQUF5QixHQUEvQixNQUFNLHlCQUF5QjtJQUduQixRQUFRLEdBQUcsTUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQ2xDLE1BQU0sR0FBRyxNQUFNLENBQUMscUJBQXFCLENBQUMsQ0FBQztJQUVqRCxNQUFNLENBQUMsQ0FBbUM7UUFDL0MsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQzNCLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztRQUVELElBQUksQ0FBQyxJQUFJLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxDQUFDO1lBQy9CLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztRQUVELE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQztRQUVyRCxPQUFPLGtDQUFrQyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFFTyxrQkFBa0I7UUFDeEIsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ25DLENBQUM7d0dBdEJVLHlCQUF5Qjs0R0FBekIseUJBQXlCOztBQUF6Qix5QkFBeUI7SUFEckMsa0JBQWtCLENBQUMsZ0NBQWdDLENBQUM7R0FDeEMseUJBQXlCLENBdUJyQzs7NEZBdkJZLHlCQUF5QjtrQkFGckMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQnJvd3NlclNlcnZpY2UgfSBmcm9tICdAZm9ibGV4L3BsYXRmb3JtJztcbmltcG9ydCB7IEZFeGVjdXRpb25SZWdpc3RlciwgSUV4ZWN1dGlvbiB9IGZyb20gJ0Bmb2JsZXgvbWVkaWF0b3InO1xuaW1wb3J0IHsgQ29ubmVjdGlvbldvcmtlclN0YXRlIH0gZnJvbSAnLi4vLi4vbW9kZWxzJztcbmltcG9ydCB7IElzQ29ubmVjdGlvbldvcmtlckVuYWJsZWRSZXF1ZXN0IH0gZnJvbSAnLi9pcy1jb25uZWN0aW9uLXdvcmtlci1lbmFibGVkLXJlcXVlc3QnO1xuaW1wb3J0IHsgaXNDb25uZWN0aW9uV29ya2VyUnVudGltZVN1cHBvcnRlZCB9IGZyb20gJy4uL3J1bnRpbWUvY29ubmVjdGlvbi13b3JrZXItcnVudGltZSc7XG5cbkBJbmplY3RhYmxlKClcbkBGRXhlY3V0aW9uUmVnaXN0ZXIoSXNDb25uZWN0aW9uV29ya2VyRW5hYmxlZFJlcXVlc3QpXG5leHBvcnQgY2xhc3MgSXNDb25uZWN0aW9uV29ya2VyRW5hYmxlZFxuICBpbXBsZW1lbnRzIElFeGVjdXRpb248SXNDb25uZWN0aW9uV29ya2VyRW5hYmxlZFJlcXVlc3QsIGJvb2xlYW4+XG57XG4gIHByaXZhdGUgcmVhZG9ubHkgX2Jyb3dzZXIgPSBpbmplY3QoQnJvd3NlclNlcnZpY2UpO1xuICBwcml2YXRlIHJlYWRvbmx5IF9zdGF0ZSA9IGluamVjdChDb25uZWN0aW9uV29ya2VyU3RhdGUpO1xuXG4gIHB1YmxpYyBoYW5kbGUoXzogSXNDb25uZWN0aW9uV29ya2VyRW5hYmxlZFJlcXVlc3QpOiBib29sZWFuIHtcbiAgICBpZiAodGhpcy5fc3RhdGUuaXNEaXNhYmxlZCkge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cblxuICAgIGlmICghdGhpcy5faXNXb3JrZXJBdmFpbGFibGUoKSkge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cblxuICAgIGNvbnN0IHdpbmRvd1JlZiA9IHRoaXMuX2Jyb3dzZXIuZG9jdW1lbnQuZGVmYXVsdFZpZXc7XG5cbiAgICByZXR1cm4gaXNDb25uZWN0aW9uV29ya2VyUnVudGltZVN1cHBvcnRlZCh3aW5kb3dSZWYpO1xuICB9XG5cbiAgcHJpdmF0ZSBfaXNXb3JrZXJBdmFpbGFibGUoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuX2Jyb3dzZXIuaXNCcm93c2VyKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/domain/f-connection/redraw-connections/worker/reset-connection-worker-runtime/index.mjs

@@ -0,0 +1,3 @@
+export * from './reset-connection-worker-runtime';
+export * from './reset-connection-worker-runtime-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3Jlc2V0LWNvbm5lY3Rpb24td29ya2VyLXJ1bnRpbWUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQztBQUVsRCxjQUFjLDJDQUEyQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yZXNldC1jb25uZWN0aW9uLXdvcmtlci1ydW50aW1lJztcblxuZXhwb3J0ICogZnJvbSAnLi9yZXNldC1jb25uZWN0aW9uLXdvcmtlci1ydW50aW1lLXJlcXVlc3QnO1xuIl19

package/esm2022/domain/f-connection/redraw-connections/worker/reset-connection-worker-runtime/reset-connection-worker-runtime-request.mjs

@@ -0,0 +1,8 @@
+export class ResetConnectionWorkerRuntimeRequest {
+    error;
+    static fToken = Symbol('ResetConnectionWorkerRuntimeRequest');
+    constructor(error) {
+        this.error = error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzZXQtY29ubmVjdGlvbi13b3JrZXItcnVudGltZS1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9mLWZsb3cvc3JjL2RvbWFpbi9mLWNvbm5lY3Rpb24vcmVkcmF3LWNvbm5lY3Rpb25zL3dvcmtlci9yZXNldC1jb25uZWN0aW9uLXdvcmtlci1ydW50aW1lL3Jlc2V0LWNvbm5lY3Rpb24td29ya2VyLXJ1bnRpbWUtcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sbUNBQW1DO0lBRzNCO0lBRm5CLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLHFDQUFxQyxDQUFDLENBQUM7SUFFdkUsWUFBbUIsS0FBWTtRQUFaLFVBQUssR0FBTCxLQUFLLENBQU87SUFBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFJlc2V0Q29ubmVjdGlvbldvcmtlclJ1bnRpbWVSZXF1ZXN0IHtcbiAgc3RhdGljIHJlYWRvbmx5IGZUb2tlbiA9IFN5bWJvbCgnUmVzZXRDb25uZWN0aW9uV29ya2VyUnVudGltZVJlcXVlc3QnKTtcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgZXJyb3I6IEVycm9yKSB7fVxufVxuIl19

package/esm2022/domain/f-connection/redraw-connections/worker/reset-connection-worker-runtime/reset-connection-worker-runtime.mjs

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { FExecutionRegister } from '@foblex/mediator';
+import { ConnectionWorkerState } from '../../models';
+import { ResetConnectionWorkerRuntimeRequest } from './reset-connection-worker-runtime-request';
+import * as i0 from "@angular/core";
+let ResetConnectionWorkerRuntime = class ResetConnectionWorkerRuntime {
+    _state = inject(ConnectionWorkerState);
+    handle({ error }) {
+        this._state.resetRuntime(error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResetConnectionWorkerRuntime, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResetConnectionWorkerRuntime });
+};
+ResetConnectionWorkerRuntime = __decorate([
+    FExecutionRegister(ResetConnectionWorkerRuntimeRequest)
+], ResetConnectionWorkerRuntime);
+export { ResetConnectionWorkerRuntime };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResetConnectionWorkerRuntime, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzZXQtY29ubmVjdGlvbi13b3JrZXItcnVudGltZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZi1mbG93L3NyYy9kb21haW4vZi1jb25uZWN0aW9uL3JlZHJhdy1jb25uZWN0aW9ucy93b3JrZXIvcmVzZXQtY29ubmVjdGlvbi13b3JrZXItcnVudGltZS9yZXNldC1jb25uZWN0aW9uLXdvcmtlci1ydW50aW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsa0JBQWtCLEVBQWMsTUFBTSxrQkFBa0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDckQsT0FBTyxFQUFFLG1DQUFtQyxFQUFFLE1BQU0sMkNBQTJDLENBQUM7O0FBSXpGLElBQU0sNEJBQTRCLEdBQWxDLE1BQU0sNEJBQTRCO0lBR3RCLE1BQU0sR0FBRyxNQUFNLENBQUMscUJBQXFCLENBQUMsQ0FBQztJQUVqRCxNQUFNLENBQUMsRUFBRSxLQUFLLEVBQXVDO1FBQzFELElBQUksQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2xDLENBQUM7d0dBUFUsNEJBQTRCOzRHQUE1Qiw0QkFBNEI7O0FBQTVCLDRCQUE0QjtJQUR4QyxrQkFBa0IsQ0FBQyxtQ0FBbUMsQ0FBQztHQUMzQyw0QkFBNEIsQ0FReEM7OzRGQVJZLDRCQUE0QjtrQkFGeEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRkV4ZWN1dGlvblJlZ2lzdGVyLCBJRXhlY3V0aW9uIH0gZnJvbSAnQGZvYmxleC9tZWRpYXRvcic7XG5pbXBvcnQgeyBDb25uZWN0aW9uV29ya2VyU3RhdGUgfSBmcm9tICcuLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgUmVzZXRDb25uZWN0aW9uV29ya2VyUnVudGltZVJlcXVlc3QgfSBmcm9tICcuL3Jlc2V0LWNvbm5lY3Rpb24td29ya2VyLXJ1bnRpbWUtcmVxdWVzdCc7XG5cbkBJbmplY3RhYmxlKClcbkBGRXhlY3V0aW9uUmVnaXN0ZXIoUmVzZXRDb25uZWN0aW9uV29ya2VyUnVudGltZVJlcXVlc3QpXG5leHBvcnQgY2xhc3MgUmVzZXRDb25uZWN0aW9uV29ya2VyUnVudGltZVxuICBpbXBsZW1lbnRzIElFeGVjdXRpb248UmVzZXRDb25uZWN0aW9uV29ya2VyUnVudGltZVJlcXVlc3QsIHZvaWQ+XG57XG4gIHByaXZhdGUgcmVhZG9ubHkgX3N0YXRlID0gaW5qZWN0KENvbm5lY3Rpb25Xb3JrZXJTdGF0ZSk7XG5cbiAgcHVibGljIGhhbmRsZSh7IGVycm9yIH06IFJlc2V0Q29ubmVjdGlvbldvcmtlclJ1bnRpbWVSZXF1ZXN0KTogdm9pZCB7XG4gICAgdGhpcy5fc3RhdGUucmVzZXRSdW50aW1lKGVycm9yKTtcbiAgfVxufVxuIl19

package/esm2022/domain/f-connection/redraw-connections/worker/run-connection-worker/index.mjs

@@ -0,0 +1,3 @@
+export * from './run-connection-worker';
+export * from './run-connection-worker-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3J1bi1jb25uZWN0aW9uLXdvcmtlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3J1bi1jb25uZWN0aW9uLXdvcmtlcic7XG5leHBvcnQgKiBmcm9tICcuL3J1bi1jb25uZWN0aW9uLXdvcmtlci1yZXF1ZXN0JztcbiJdfQ==

package/esm2022/domain/f-connection/redraw-connections/worker/run-connection-worker/run-connection-worker-request.mjs

@@ -0,0 +1,8 @@
+export class RunConnectionWorkerRequest {
+    payload;
+    static fToken = Symbol('RunConnectionWorkerRequest');
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLWNvbm5lY3Rpb24td29ya2VyLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3J1bi1jb25uZWN0aW9uLXdvcmtlci9ydW4tY29ubmVjdGlvbi13b3JrZXItcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sMEJBQTBCO0lBR2xCO0lBRm5CLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLDRCQUE0QixDQUFDLENBQUM7SUFFOUQsWUFBbUIsT0FBdUM7UUFBdkMsWUFBTyxHQUFQLE9BQU8sQ0FBZ0M7SUFBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUNvbm5lY3Rpb25Xb3JrZXJQYXlsb2FkSXRlbSB9IGZyb20gJy4uLy4uL21vZGVscyc7XG5cbmV4cG9ydCBjbGFzcyBSdW5Db25uZWN0aW9uV29ya2VyUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ1J1bkNvbm5lY3Rpb25Xb3JrZXJSZXF1ZXN0Jyk7XG5cbiAgY29uc3RydWN0b3IocHVibGljIHBheWxvYWQ6IElDb25uZWN0aW9uV29ya2VyUGF5bG9hZEl0ZW1bXSkge31cbn1cbiJdfQ==

package/esm2022/domain/f-connection/redraw-connections/worker/run-connection-worker/run-connection-worker.mjs

@@ -0,0 +1,59 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { ConnectionWorkerState } from '../../models';
+import { EnsureConnectionWorkerRequest } from '../ensure-connection-worker';
+import { IsConnectionWorkerEnabledRequest } from '../is-connection-worker-enabled';
+import { RunConnectionWorkerRequest } from './run-connection-worker-request';
+import * as i0 from "@angular/core";
+let RunConnectionWorker = class RunConnectionWorker {
+    _state = inject(ConnectionWorkerState);
+    _mediator = inject(FMediator);
+    handle({ payload }) {
+        if (!payload.length) {
+            return Promise.resolve([]);
+        }
+        if (!this._mediator.execute(new IsConnectionWorkerEnabledRequest())) {
+            return Promise.reject(new Error('Connection worker is disabled.'));
+        }
+        this._interruptPendingRequests();
+        const worker = this._mediator.execute(new EnsureConnectionWorkerRequest());
+        if (!worker) {
+            return Promise.reject(new Error('Unable to initialize connection worker.'));
+        }
+        const requestId = ++this._state.nextRequestId;
+        return new Promise((resolve, reject) => {
+            this._state.pending.set(requestId, { resolve, reject });
+            try {
+                worker.postMessage({
+                    requestId,
+                    items: payload,
+                });
+            }
+            catch (error) {
+                this._state.pending.delete(requestId);
+                reject(error instanceof Error
+                    ? error
+                    : new Error('Unknown error while posting message to connection worker.'));
+            }
+        });
+    }
+    _interruptPendingRequests() {
+        if (!this._state.pending.size) {
+            return;
+        }
+        const error = new Error('Connection worker request was superseded by a newer redraw.');
+        this._state.pending.forEach((request) => request.reject(error));
+        this._state.pending.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RunConnectionWorker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RunConnectionWorker });
+};
+RunConnectionWorker = __decorate([
+    FExecutionRegister(RunConnectionWorkerRequest)
+], RunConnectionWorker);
+export { RunConnectionWorker };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RunConnectionWorker, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/f-connection/redraw-connections/worker/run-connection-worker-batch/index.mjs

@@ -0,0 +1,3 @@
+export * from './run-connection-worker-batch';
+export * from './run-connection-worker-batch-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3J1bi1jb25uZWN0aW9uLXdvcmtlci1iYXRjaC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3J1bi1jb25uZWN0aW9uLXdvcmtlci1iYXRjaCc7XG5leHBvcnQgKiBmcm9tICcuL3J1bi1jb25uZWN0aW9uLXdvcmtlci1iYXRjaC1yZXF1ZXN0JztcbiJdfQ==

package/esm2022/domain/f-connection/redraw-connections/worker/run-connection-worker-batch/run-connection-worker-batch-request.mjs

@@ -0,0 +1,8 @@
+export class RunConnectionWorkerBatchRequest {
+    batch;
+    static fToken = Symbol('RunConnectionWorkerBatchRequest');
+    constructor(batch) {
+        this.batch = batch;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLWNvbm5lY3Rpb24td29ya2VyLWJhdGNoLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3J1bi1jb25uZWN0aW9uLXdvcmtlci1iYXRjaC9ydW4tY29ubmVjdGlvbi13b3JrZXItYmF0Y2gtcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sK0JBQStCO0lBR3ZCO0lBRm5CLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLGlDQUFpQyxDQUFDLENBQUM7SUFFbkUsWUFBbUIsS0FBNkI7UUFBN0IsVUFBSyxHQUFMLEtBQUssQ0FBd0I7SUFBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUNvbm5lY3Rpb25Xb3JrZXJCYXRjaCB9IGZyb20gJy4uLy4uL21vZGVscyc7XG5cbmV4cG9ydCBjbGFzcyBSdW5Db25uZWN0aW9uV29ya2VyQmF0Y2hSZXF1ZXN0IHtcbiAgc3RhdGljIHJlYWRvbmx5IGZUb2tlbiA9IFN5bWJvbCgnUnVuQ29ubmVjdGlvbldvcmtlckJhdGNoUmVxdWVzdCcpO1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBiYXRjaDogSUNvbm5lY3Rpb25Xb3JrZXJCYXRjaCkge31cbn1cbiJdfQ==

package/esm2022/domain/f-connection/redraw-connections/worker/run-connection-worker-batch/run-connection-worker-batch.mjs

@@ -0,0 +1,25 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { RunConnectionWorkerRequest } from '../run-connection-worker';
+import { RunConnectionWorkerBatchRequest } from './run-connection-worker-batch-request';
+import * as i0 from "@angular/core";
+let RunConnectionWorkerBatch = class RunConnectionWorkerBatch {
+    _mediator = inject(FMediator);
+    handle({ batch, }) {
+        if (!batch.payload.length) {
+            return Promise.resolve([]);
+        }
+        return this._mediator.execute(new RunConnectionWorkerRequest(batch.payload));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RunConnectionWorkerBatch, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RunConnectionWorkerBatch });
+};
+RunConnectionWorkerBatch = __decorate([
+    FExecutionRegister(RunConnectionWorkerBatchRequest)
+], RunConnectionWorkerBatch);
+export { RunConnectionWorkerBatch };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RunConnectionWorkerBatch, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/f-connection/redraw-connections/worker/runtime/connection-worker-runtime.mjs

@@ -0,0 +1,247 @@
+const F_CONNECTION_WORKER_SOURCE = String.raw `
+const EPSILON = 0.5;
+
+addEventListener('message', (event) => {
+  const data = event?.data;
+  const requestId = data?.requestId;
+  const items = Array.isArray(data?.items) ? data.items : [];
+
+  try {
+    const results = items.map((item) => calculateItem(item));
+    postMessage({ requestId, results });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Connection worker failed.';
+    postMessage({ requestId, error: message });
+  }
+});
+
+function calculateItem(item) {
+  const sourceCenterX = item.sourceRect.x + item.sourceRect.width / 2;
+  const sourceCenterY = item.sourceRect.y + item.sourceRect.height / 2;
+  const targetCenterX = item.targetRect.x + item.targetRect.width / 2;
+  const targetCenterY = item.targetRect.y + item.targetRect.height / 2;
+
+  const sourceSide = resolveConnectableSide(
+    item.outputSide,
+    targetCenterX - sourceCenterX,
+    targetCenterY - sourceCenterY,
+    item.sourceConnectableSide,
+  );
+
+  const targetSide = resolveConnectableSide(
+    item.inputSide,
+    sourceCenterX - targetCenterX,
+    sourceCenterY - targetCenterY,
+    item.targetConnectableSide,
+  );
+
+  if (item.behavior === 'fixed_center') {
+    return {
+      originalIndex: item.originalIndex,
+      supported: true,
+      sourceSide,
+      targetSide,
+      line: {
+        point1: { x: sourceCenterX, y: sourceCenterY },
+        point2: { x: targetCenterX, y: targetCenterY },
+      },
+    };
+  }
+
+  if (item.sourceRotation || item.targetRotation) {
+    return { originalIndex: item.originalIndex, supported: false };
+  }
+
+  if (item.behavior !== 'fixed') {
+    if (item.behavior !== 'floating') {
+      return { originalIndex: item.originalIndex, supported: false };
+    }
+
+    if (hasRoundedCorners(item.sourceRect) || hasRoundedCorners(item.targetRect)) {
+      return { originalIndex: item.originalIndex, supported: false };
+    }
+
+    return {
+      originalIndex: item.originalIndex,
+      supported: true,
+      sourceSide,
+      targetSide,
+      line: buildFloatingLine(item.sourceRect, item.targetRect),
+    };
+  }
+
+  const line = buildFixedLine(item.sourceRect, item.targetRect, sourceSide, targetSide);
+  if (!line) {
+    return { originalIndex: item.originalIndex, supported: false };
+  }
+
+  return {
+    originalIndex: item.originalIndex,
+    supported: true,
+    sourceSide,
+    targetSide,
+    line,
+  };
+}
+
+function resolveConnectableSide(requestedSide, deltaX, deltaY, fallbackSide) {
+  if (requestedSide === 'default') {
+    return fallbackSide;
+  }
+
+  const absX = Math.abs(deltaX);
+  const absY = Math.abs(deltaY);
+  const nearZero = absX < EPSILON && absY < EPSILON;
+
+  if (nearZero) {
+    return fallbackSide;
+  }
+
+  const horizontalDominant = absX >= absY;
+
+  switch (requestedSide) {
+    case 'calculate':
+      return horizontalDominant ? (deltaX >= 0 ? 'right' : 'left') : deltaY >= 0 ? 'bottom' : 'top';
+
+    case 'calculate_horizontal':
+      if (absX < EPSILON) {
+        return fallbackSide;
+      }
+
+      return deltaX >= 0 ? 'right' : 'left';
+
+    case 'calculate_vertical':
+      if (absY < EPSILON) {
+        return fallbackSide;
+      }
+
+      return deltaY >= 0 ? 'bottom' : 'top';
+
+    case 'top':
+    case 'bottom':
+    case 'left':
+    case 'right':
+      return requestedSide;
+
+    default:
+      return fallbackSide;
+  }
+}
+
+function buildFixedLine(sourceRect, targetRect, sourceSide, targetSide) {
+  const sourceAnchor = sourceSide === 'auto' ? 'bottom' : sourceSide;
+  const targetAnchor = targetSide === 'auto' ? 'top' : targetSide;
+
+  const point1 = getSidePoint(sourceRect, sourceAnchor);
+  const point2 = getSidePoint(targetRect, targetAnchor);
+
+  if (!point1 || !point2) {
+    return null;
+  }
+
+  return { point1, point2 };
+}
+
+function buildFloatingLine(sourceRect, targetRect) {
+  const sourceCenter = getRectCenter(sourceRect);
+  const targetCenter = getRectCenter(targetRect);
+
+  return {
+    point1: getRectBorderIntersection(sourceRect, sourceCenter, targetCenter),
+    point2: getRectBorderIntersection(targetRect, targetCenter, sourceCenter),
+  };
+}
+
+function hasRoundedCorners(rect) {
+  return !!(rect.radius1 || rect.radius2 || rect.radius3 || rect.radius4);
+}
+
+function getRectCenter(rect) {
+  return {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2,
+  };
+}
+
+function getRectBorderIntersection(rect, from, to) {
+  const halfWidth = rect.width / 2;
+  const halfHeight = rect.height / 2;
+  const center = getRectCenter(rect);
+
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+
+  if (Math.abs(dx) < EPSILON && Math.abs(dy) < EPSILON) {
+    return center;
+  }
+
+  const scaleX = Math.abs(dx) < EPSILON ? Number.POSITIVE_INFINITY : halfWidth / Math.abs(dx);
+  const scaleY = Math.abs(dy) < EPSILON ? Number.POSITIVE_INFINITY : halfHeight / Math.abs(dy);
+  const scale = Math.min(scaleX, scaleY);
+
+  return {
+    x: center.x + dx * scale,
+    y: center.y + dy * scale,
+  };
+}
+
+function getSidePoint(rect, side) {
+  const centerX = rect.x + rect.width / 2;
+  const centerY = rect.y + rect.height / 2;
+
+  switch (side) {
+    case 'top':
+      return { x: centerX, y: rect.y };
+
+    case 'right':
+      return { x: rect.x + rect.width, y: centerY };
+
+    case 'bottom':
+      return { x: centerX, y: rect.y + rect.height };
+
+    case 'left':
+      return { x: rect.x, y: centerY };
+
+    default:
+      return null;
+  }
+}
+`.trim();
+export function isConnectionWorkerRuntimeSupported(windowRef) {
+    return !!resolveConnectionWorkerRuntime(windowRef);
+}
+export function resolveConnectionWorkerRuntime(windowRef) {
+    const runtimeWindow = windowRef;
+    const blobCtor = runtimeWindow?.Blob;
+    const workerCtor = runtimeWindow?.Worker;
+    const urlApi = runtimeWindow?.URL;
+    if (!blobCtor || !workerCtor) {
+        return null;
+    }
+    if (typeof urlApi?.createObjectURL !== 'function' ||
+        typeof urlApi.revokeObjectURL !== 'function') {
+        return null;
+    }
+    return {
+        blobCtor,
+        workerCtor,
+        urlApi,
+    };
+}
+export function createConnectionWorkerUrl(runtime) {
+    const blob = new runtime.blobCtor([F_CONNECTION_WORKER_SOURCE], {
+        type: 'text/javascript',
+    });
+    return runtime.urlApi.createObjectURL(blob);
+}
+export function revokeConnectionWorkerUrl(workerUrl, urlApi) {
+    if (!workerUrl) {
+        return;
+    }
+    const resolvedUrlApi = urlApi ?? (typeof URL === 'undefined' ? null : URL);
+    if (typeof resolvedUrlApi?.revokeObjectURL !== 'function') {
+        return;
+    }
+    resolvedUrlApi.revokeObjectURL(workerUrl);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection-worker-runtime.js","sourceRoot":"","sources":["../../../../../../../../libs/f-flow/src/domain/f-connection/redraw-connections/worker/runtime/connection-worker-runtime.ts"],"names":[],"mappings":"AAQA,MAAM,0BAA0B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgN5C,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,UAAU,kCAAkC,CAAC,SAAoC;IACrF,OAAO,CAAC,CAAC,8BAA8B,CAAC,SAAS,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,8BAA8B,CAC5C,SAAoC;IAEpC,MAAM,aAAa,GAAG,SAAmE,CAAC;IAC1F,MAAM,QAAQ,GAAG,aAAa,EAAE,IAAI,CAAC;IACrC,MAAM,UAAU,GAAG,aAAa,EAAE,MAAM,CAAC;IACzC,MAAM,MAAM,GAAG,aAAa,EAAE,GAAG,CAAC;IAClC,IAAI,CAAC,QAAQ,IAAI,CAAC,UAAU,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IACE,OAAO,MAAM,EAAE,eAAe,KAAK,UAAU;QAC7C,OAAO,MAAM,CAAC,eAAe,KAAK,UAAU,EAC5C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,QAAQ;QACR,UAAU;QACV,MAAM;KACP,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,OAAiC;IACzE,MAAM,IAAI,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC,0BAA0B,CAAC,EAAE;QAC9D,IAAI,EAAE,iBAAiB;KACxB,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,SAAoC,EACpC,MAAmD;IAEnD,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO;IACT,CAAC;IAED,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,OAAO,GAAG,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC3E,IAAI,OAAO,cAAc,EAAE,eAAe,KAAK,UAAU,EAAE,CAAC;QAC1D,OAAO;IACT,CAAC;IAED,cAAc,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;AAC5C,CAAC","sourcesContent":["type TConnectionWorkerUrlApi = Pick<typeof URL, 'createObjectURL' | 'revokeObjectURL'>;\n\ntype TConnectionWorkerRuntime = {\n  blobCtor: typeof Blob;\n  workerCtor: typeof Worker;\n  urlApi: TConnectionWorkerUrlApi;\n};\n\nconst F_CONNECTION_WORKER_SOURCE = String.raw`\nconst EPSILON = 0.5;\n\naddEventListener('message', (event) => {\n  const data = event?.data;\n  const requestId = data?.requestId;\n  const items = Array.isArray(data?.items) ? data.items : [];\n\n  try {\n    const results = items.map((item) => calculateItem(item));\n    postMessage({ requestId, results });\n  } catch (error) {\n    const message = error instanceof Error ? error.message : 'Connection worker failed.';\n    postMessage({ requestId, error: message });\n  }\n});\n\nfunction calculateItem(item) {\n  const sourceCenterX = item.sourceRect.x + item.sourceRect.width / 2;\n  const sourceCenterY = item.sourceRect.y + item.sourceRect.height / 2;\n  const targetCenterX = item.targetRect.x + item.targetRect.width / 2;\n  const targetCenterY = item.targetRect.y + item.targetRect.height / 2;\n\n  const sourceSide = resolveConnectableSide(\n    item.outputSide,\n    targetCenterX - sourceCenterX,\n    targetCenterY - sourceCenterY,\n    item.sourceConnectableSide,\n  );\n\n  const targetSide = resolveConnectableSide(\n    item.inputSide,\n    sourceCenterX - targetCenterX,\n    sourceCenterY - targetCenterY,\n    item.targetConnectableSide,\n  );\n\n  if (item.behavior === 'fixed_center') {\n    return {\n      originalIndex: item.originalIndex,\n      supported: true,\n      sourceSide,\n      targetSide,\n      line: {\n        point1: { x: sourceCenterX, y: sourceCenterY },\n        point2: { x: targetCenterX, y: targetCenterY },\n      },\n    };\n  }\n\n  if (item.sourceRotation || item.targetRotation) {\n    return { originalIndex: item.originalIndex, supported: false };\n  }\n\n  if (item.behavior !== 'fixed') {\n    if (item.behavior !== 'floating') {\n      return { originalIndex: item.originalIndex, supported: false };\n    }\n\n    if (hasRoundedCorners(item.sourceRect) || hasRoundedCorners(item.targetRect)) {\n      return { originalIndex: item.originalIndex, supported: false };\n    }\n\n    return {\n      originalIndex: item.originalIndex,\n      supported: true,\n      sourceSide,\n      targetSide,\n      line: buildFloatingLine(item.sourceRect, item.targetRect),\n    };\n  }\n\n  const line = buildFixedLine(item.sourceRect, item.targetRect, sourceSide, targetSide);\n  if (!line) {\n    return { originalIndex: item.originalIndex, supported: false };\n  }\n\n  return {\n    originalIndex: item.originalIndex,\n    supported: true,\n    sourceSide,\n    targetSide,\n    line,\n  };\n}\n\nfunction resolveConnectableSide(requestedSide, deltaX, deltaY, fallbackSide) {\n  if (requestedSide === 'default') {\n    return fallbackSide;\n  }\n\n  const absX = Math.abs(deltaX);\n  const absY = Math.abs(deltaY);\n  const nearZero = absX < EPSILON && absY < EPSILON;\n\n  if (nearZero) {\n    return fallbackSide;\n  }\n\n  const horizontalDominant = absX >= absY;\n\n  switch (requestedSide) {\n    case 'calculate':\n      return horizontalDominant ? (deltaX >= 0 ? 'right' : 'left') : deltaY >= 0 ? 'bottom' : 'top';\n\n    case 'calculate_horizontal':\n      if (absX < EPSILON) {\n        return fallbackSide;\n      }\n\n      return deltaX >= 0 ? 'right' : 'left';\n\n    case 'calculate_vertical':\n      if (absY < EPSILON) {\n        return fallbackSide;\n      }\n\n      return deltaY >= 0 ? 'bottom' : 'top';\n\n    case 'top':\n    case 'bottom':\n    case 'left':\n    case 'right':\n      return requestedSide;\n\n    default:\n      return fallbackSide;\n  }\n}\n\nfunction buildFixedLine(sourceRect, targetRect, sourceSide, targetSide) {\n  const sourceAnchor = sourceSide === 'auto' ? 'bottom' : sourceSide;\n  const targetAnchor = targetSide === 'auto' ? 'top' : targetSide;\n\n  const point1 = getSidePoint(sourceRect, sourceAnchor);\n  const point2 = getSidePoint(targetRect, targetAnchor);\n\n  if (!point1 || !point2) {\n    return null;\n  }\n\n  return { point1, point2 };\n}\n\nfunction buildFloatingLine(sourceRect, targetRect) {\n  const sourceCenter = getRectCenter(sourceRect);\n  const targetCenter = getRectCenter(targetRect);\n\n  return {\n    point1: getRectBorderIntersection(sourceRect, sourceCenter, targetCenter),\n    point2: getRectBorderIntersection(targetRect, targetCenter, sourceCenter),\n  };\n}\n\nfunction hasRoundedCorners(rect) {\n  return !!(rect.radius1 || rect.radius2 || rect.radius3 || rect.radius4);\n}\n\nfunction getRectCenter(rect) {\n  return {\n    x: rect.x + rect.width / 2,\n    y: rect.y + rect.height / 2,\n  };\n}\n\nfunction getRectBorderIntersection(rect, from, to) {\n  const halfWidth = rect.width / 2;\n  const halfHeight = rect.height / 2;\n  const center = getRectCenter(rect);\n\n  const dx = to.x - from.x;\n  const dy = to.y - from.y;\n\n  if (Math.abs(dx) < EPSILON && Math.abs(dy) < EPSILON) {\n    return center;\n  }\n\n  const scaleX = Math.abs(dx) < EPSILON ? Number.POSITIVE_INFINITY : halfWidth / Math.abs(dx);\n  const scaleY = Math.abs(dy) < EPSILON ? Number.POSITIVE_INFINITY : halfHeight / Math.abs(dy);\n  const scale = Math.min(scaleX, scaleY);\n\n  return {\n    x: center.x + dx * scale,\n    y: center.y + dy * scale,\n  };\n}\n\nfunction getSidePoint(rect, side) {\n  const centerX = rect.x + rect.width / 2;\n  const centerY = rect.y + rect.height / 2;\n\n  switch (side) {\n    case 'top':\n      return { x: centerX, y: rect.y };\n\n    case 'right':\n      return { x: rect.x + rect.width, y: centerY };\n\n    case 'bottom':\n      return { x: centerX, y: rect.y + rect.height };\n\n    case 'left':\n      return { x: rect.x, y: centerY };\n\n    default:\n      return null;\n  }\n}\n`.trim();\n\nexport function isConnectionWorkerRuntimeSupported(windowRef: Window | null | undefined): boolean {\n  return !!resolveConnectionWorkerRuntime(windowRef);\n}\n\nexport function resolveConnectionWorkerRuntime(\n  windowRef: Window | null | undefined,\n): TConnectionWorkerRuntime | null {\n  const runtimeWindow = windowRef as Partial<Window & typeof globalThis> | null | undefined;\n  const blobCtor = runtimeWindow?.Blob;\n  const workerCtor = runtimeWindow?.Worker;\n  const urlApi = runtimeWindow?.URL;\n  if (!blobCtor || !workerCtor) {\n    return null;\n  }\n\n  if (\n    typeof urlApi?.createObjectURL !== 'function' ||\n    typeof urlApi.revokeObjectURL !== 'function'\n  ) {\n    return null;\n  }\n\n  return {\n    blobCtor,\n    workerCtor,\n    urlApi,\n  };\n}\n\nexport function createConnectionWorkerUrl(runtime: TConnectionWorkerRuntime): string {\n  const blob = new runtime.blobCtor([F_CONNECTION_WORKER_SOURCE], {\n    type: 'text/javascript',\n  });\n\n  return runtime.urlApi.createObjectURL(blob);\n}\n\nexport function revokeConnectionWorkerUrl(\n  workerUrl: string | null | undefined,\n  urlApi?: Pick<typeof URL, 'revokeObjectURL'> | null,\n): void {\n  if (!workerUrl) {\n    return;\n  }\n\n  const resolvedUrlApi = urlApi ?? (typeof URL === 'undefined' ? null : URL);\n  if (typeof resolvedUrlApi?.revokeObjectURL !== 'function') {\n    return;\n  }\n\n  resolvedUrlApi.revokeObjectURL(workerUrl);\n}\n"]}

package/esm2022/domain/f-connection/redraw-connections/worker/runtime/index.mjs

@@ -0,0 +1,2 @@
+export * from './connection-worker-runtime';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3J1bnRpbWUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29ubmVjdGlvbi13b3JrZXItcnVudGltZSc7XG4iXX0=

package/esm2022/domain/f-connection/redraw-connections/worker/should-use-connection-worker/index.mjs

@@ -0,0 +1,3 @@
+export * from './should-use-connection-worker';
+export * from './should-use-connection-worker-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3Nob3VsZC11c2UtY29ubmVjdGlvbi13b3JrZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zaG91bGQtdXNlLWNvbm5lY3Rpb24td29ya2VyJztcblxuZXhwb3J0ICogZnJvbSAnLi9zaG91bGQtdXNlLWNvbm5lY3Rpb24td29ya2VyLXJlcXVlc3QnO1xuIl19

package/esm2022/domain/f-connection/redraw-connections/worker/should-use-connection-worker/should-use-connection-worker-request.mjs

@@ -0,0 +1,8 @@
+export class ShouldUseConnectionWorkerRequest {
+    connectionCount;
+    static fToken = Symbol('ShouldUseConnectionWorkerRequest');
+    constructor(connectionCount) {
+        this.connectionCount = connectionCount;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvdWxkLXVzZS1jb25uZWN0aW9uLXdvcmtlci1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9mLWZsb3cvc3JjL2RvbWFpbi9mLWNvbm5lY3Rpb24vcmVkcmF3LWNvbm5lY3Rpb25zL3dvcmtlci9zaG91bGQtdXNlLWNvbm5lY3Rpb24td29ya2VyL3Nob3VsZC11c2UtY29ubmVjdGlvbi13b3JrZXItcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sZ0NBQWdDO0lBR3hCO0lBRm5CLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLGtDQUFrQyxDQUFDLENBQUM7SUFFcEUsWUFBbUIsZUFBdUI7UUFBdkIsb0JBQWUsR0FBZixlQUFlLENBQVE7SUFBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFNob3VsZFVzZUNvbm5lY3Rpb25Xb3JrZXJSZXF1ZXN0IHtcbiAgc3RhdGljIHJlYWRvbmx5IGZUb2tlbiA9IFN5bWJvbCgnU2hvdWxkVXNlQ29ubmVjdGlvbldvcmtlclJlcXVlc3QnKTtcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgY29ubmVjdGlvbkNvdW50OiBudW1iZXIpIHt9XG59XG4iXX0=

package/esm2022/domain/f-connection/redraw-connections/worker/should-use-connection-worker/should-use-connection-worker.mjs

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { ShouldUseConnectionWorkerRequest } from './should-use-connection-worker-request';
+import { IsConnectionWorkerEnabledRequest } from '../is-connection-worker-enabled';
+import * as i0 from "@angular/core";
+let ShouldUseConnectionWorker = class ShouldUseConnectionWorker {
+    _mediator = inject(FMediator);
+    handle({ connectionCount }) {
+        return (connectionCount > 0 && this._mediator.execute(new IsConnectionWorkerEnabledRequest()));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ShouldUseConnectionWorker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ShouldUseConnectionWorker });
+};
+ShouldUseConnectionWorker = __decorate([
+    FExecutionRegister(ShouldUseConnectionWorkerRequest)
+], ShouldUseConnectionWorker);
+export { ShouldUseConnectionWorker };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ShouldUseConnectionWorker, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/f-connection/redraw-connections/worker/start-connection-worker-redraw/index.mjs

@@ -0,0 +1,3 @@
+export * from './start-connection-worker-redraw';
+export * from './start-connection-worker-redraw-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3N0YXJ0LWNvbm5lY3Rpb24td29ya2VyLXJlZHJhdy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBRWpELGNBQWMsMENBQTBDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3N0YXJ0LWNvbm5lY3Rpb24td29ya2VyLXJlZHJhdyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc3RhcnQtY29ubmVjdGlvbi13b3JrZXItcmVkcmF3LXJlcXVlc3QnO1xuIl19

package/esm2022/domain/f-connection/redraw-connections/worker/start-connection-worker-redraw/start-connection-worker-redraw-request.mjs

@@ -0,0 +1,12 @@
+export class StartConnectionWorkerRedrawRequest {
+    connections;
+    cache;
+    session;
+    static fToken = Symbol('StartConnectionWorkerRedrawRequest');
+    constructor(connections, cache, session) {
+        this.connections = connections;
+        this.cache = cache;
+        this.session = session;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnQtY29ubmVjdGlvbi13b3JrZXItcmVkcmF3LXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdGlvbi9yZWRyYXctY29ubmVjdGlvbnMvd29ya2VyL3N0YXJ0LWNvbm5lY3Rpb24td29ya2VyLXJlZHJhdy9zdGFydC1jb25uZWN0aW9uLXdvcmtlci1yZWRyYXctcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sa0NBQWtDO0lBSXBDO0lBQ0E7SUFDQTtJQUxULE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLG9DQUFvQyxDQUFDLENBQUM7SUFFdEUsWUFDUyxXQUE4QixFQUM5QixLQUFnQyxFQUNoQyxPQUFpQztRQUZqQyxnQkFBVyxHQUFYLFdBQVcsQ0FBbUI7UUFDOUIsVUFBSyxHQUFMLEtBQUssQ0FBMkI7UUFDaEMsWUFBTyxHQUFQLE9BQU8sQ0FBMEI7SUFDdkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElSb3VuZGVkUmVjdCB9IGZyb20gJ0Bmb2JsZXgvMmQnO1xuaW1wb3J0IHsgRkNvbm5lY3Rpb25CYXNlIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vZi1jb25uZWN0aW9uLXYyJztcbmltcG9ydCB7IElDb25uZWN0aW9uUmVkcmF3U2Vzc2lvbiB9IGZyb20gJy4uLy4uL21vZGVscyc7XG5cbmV4cG9ydCBjbGFzcyBTdGFydENvbm5lY3Rpb25Xb3JrZXJSZWRyYXdSZXF1ZXN0IHtcbiAgc3RhdGljIHJlYWRvbmx5IGZUb2tlbiA9IFN5bWJvbCgnU3RhcnRDb25uZWN0aW9uV29ya2VyUmVkcmF3UmVxdWVzdCcpO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBjb25uZWN0aW9uczogRkNvbm5lY3Rpb25CYXNlW10sXG4gICAgcHVibGljIGNhY2hlOiBNYXA8c3RyaW5nLCBJUm91bmRlZFJlY3Q+LFxuICAgIHB1YmxpYyBzZXNzaW9uOiBJQ29ubmVjdGlvblJlZHJhd1Nlc3Npb24sXG4gICkge31cbn1cbiJdfQ==