@tft/interact 12.5.3 → 13.0.0

package/esm2020/lib/pipes/array-of-n.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ArrayOfNPipe {
+    /**
+     *
+     * @param n the number to make an array of
+     * @param max the max length of the array (useful for limiting rendering in ngFor loop)
+     */
+    transform(n, max) {
+        const length = ((max && max < n) || n === Infinity) ? max : n;
+        return new Array(length).fill(length).map((x, i) => i);
+    }
+}
+ArrayOfNPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ArrayOfNPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ArrayOfNPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ArrayOfNPipe, name: "arrayOfN" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ArrayOfNPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'arrayOfN'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktb2Ytbi5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvbGliL3BpcGVzL2FycmF5LW9mLW4ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFLcEQsTUFBTSxPQUFPLFlBQVk7SUFFdkI7Ozs7T0FJRztJQUNILFNBQVMsQ0FBQyxDQUFTLEVBQUUsR0FBVztRQUM5QixNQUFNLE1BQU0sR0FBRyxDQUFDLENBQUMsR0FBRyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzlELE9BQU8sSUFBSSxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBQyxDQUFDLEVBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7O3lHQVZVLFlBQVk7dUdBQVosWUFBWTsyRkFBWixZQUFZO2tCQUh4QixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxVQUFVO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe1xuICBuYW1lOiAnYXJyYXlPZk4nXG59KVxuZXhwb3J0IGNsYXNzIEFycmF5T2ZOUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gIC8qKlxuICAgKiBcbiAgICogQHBhcmFtIG4gdGhlIG51bWJlciB0byBtYWtlIGFuIGFycmF5IG9mIFxuICAgKiBAcGFyYW0gbWF4IHRoZSBtYXggbGVuZ3RoIG9mIHRoZSBhcnJheSAodXNlZnVsIGZvciBsaW1pdGluZyByZW5kZXJpbmcgaW4gbmdGb3IgbG9vcClcbiAgICovXG4gIHRyYW5zZm9ybShuOiBudW1iZXIsIG1heDogbnVtYmVyKTogYW55IHtcbiAgICBjb25zdCBsZW5ndGggPSAoKG1heCAmJiBtYXggPCBuKSB8fCBuID09PSBJbmZpbml0eSkgPyBtYXggOiBuO1xuICAgIHJldHVybiBuZXcgQXJyYXkobGVuZ3RoKS5maWxsKGxlbmd0aCkubWFwKCh4LGkpPT4gaSk7IFxuICB9XG5cbn1cbiJdfQ==

package/esm2020/lib/pipes/index.mjs

@@ -0,0 +1,2 @@
+export * from './array-of-n.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2ludGVyYWN0L3NyYy9saWIvcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXJyYXktb2Ytbi5waXBlJzsiXX0=

package/esm2020/lib/services/interact.service.mjs

@@ -0,0 +1,197 @@
+import { Injectable, RendererFactory2, NgZone, Inject, Optional } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { tap, map, shareReplay } from 'rxjs/operators';
+import { defaultPosition, defaultSize, defaultDelta, DEFAULT_REGISTRY_ID, INTERACT_ROOT_CONFIG } from '../models';
+import * as i0 from "@angular/core";
+export class InteractService {
+    constructor(rendererFactory, ngZone, rootConfig) {
+        this.rendererFactory = rendererFactory;
+        this.ngZone = ngZone;
+        this.rootConfig = rootConfig;
+        this._interactableIndex = 0;
+        this._dropzoneIndex = 0;
+        // TODO: consider using Map here
+        this.dragRegistrySystem = {};
+        this.cssUnit = 'px';
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+        this.cssUnit = rootConfig?.cssDimensionUnit || 'px';
+    }
+    addDeltaToPosition(delta, position) {
+        return {
+            x: delta.deltaX + position.x,
+            y: delta.deltaY + position.y,
+            targetElement: position.targetElement || delta.targetElement
+        };
+    }
+    addRegistryToSystem(customRegistryId = null) {
+        const registryId = customRegistryId || this.createDropzoneId(this._dropzoneIndex++);
+        this.dragRegistrySystem[registryId] = {};
+        return registryId;
+    }
+    addDraggableToRegistry(customRegistryId = null, interactableId = null) {
+        const registryId = customRegistryId || DEFAULT_REGISTRY_ID;
+        // if we pass an id to createInteractableId then it is used when creating the interactable
+        // and returned, otherwise a new id is created for the draggable.
+        const key = this.createInteractableId(interactableId);
+        if (!Object.prototype.hasOwnProperty.call(this.dragRegistrySystem, registryId)) {
+            this.dragRegistrySystem[registryId] = {};
+        }
+        this.dragRegistrySystem[registryId][key] = this.createInteractableState(defaultPosition, defaultSize, defaultDelta);
+        return key;
+    }
+    destroyInteractable(interactableId, registryId = DEFAULT_REGISTRY_ID) {
+        const interactableSystem = this.dragRegistrySystem[registryId][interactableId];
+        if (interactableSystem) {
+            // unsubscribe from all the subscriptions if they're subscriptions
+            for (const propName in interactableSystem) {
+                const prop = interactableSystem[propName];
+                if (prop.unsubscribe && typeof prop.unsubscribe === 'function') {
+                    prop.unsubscribe();
+                }
+                ;
+            }
+            delete this.dragRegistrySystem[registryId][interactableId];
+        }
+    }
+    subscribeToInteractable(interactableId, registryId = DEFAULT_REGISTRY_ID) {
+        return this.dragRegistrySystem[registryId][interactableId];
+    }
+    createInteractableState(initialPosition, initialSize, initialDelta) {
+        const deltas$ = new BehaviorSubject(initialDelta);
+        // tracks the size of the element
+        const size$ = new BehaviorSubject({ ...initialSize, ...initialDelta });
+        // Stream of positions as they change
+        const position$ = new BehaviorSubject(initialPosition);
+        // All draggable data mapped together
+        const interactable$ = combineLatest([
+            size$.pipe(
+            // startWith({...initialSize, ...initialDelta}),
+            shareReplay(1), 
+            // filter(resizeEvent => !!resizeEvent.targetElement),
+            tap(({ deltaX, deltaY, width, height, targetElement }) => {
+                this.ngZone.runOutsideAngular(() => {
+                    this.setElementSize(width, height, targetElement);
+                });
+                // only reposition if necessary i.e when resizing left or up
+                if (deltaX || deltaY) {
+                    deltas$.next({ deltaX, deltaY, targetElement });
+                }
+            })),
+            deltas$.pipe(shareReplay(1), tap((delta) => {
+                const position = position$.value;
+                const newPosition = this.addDeltaToPosition(delta, position);
+                position$.next(newPosition);
+            })),
+            position$.pipe(shareReplay(1), tap(position => {
+                this.ngZone.runOutsideAngular(() => {
+                    this.setElementTransform(position.x, position.y, position);
+                });
+            }))
+        ]).pipe(shareReplay(1), map(([size, deltas, position]) => {
+            return {
+                x: position.x,
+                y: position.y,
+                deltaX: deltas.deltaX,
+                deltaY: deltas.deltaY,
+                width: size.width,
+                height: size.height,
+                targetElement: size.targetElement || position.targetElement || deltas.targetElement
+            };
+        }));
+        // TODO: update system to handle only returning interactable$
+        return {
+            deltas$,
+            position$,
+            size$,
+            interactable$
+        };
+    }
+    createInteractableId(customInteractableId = null) {
+        return customInteractableId || `interactable${this._interactableIndex++}`;
+    }
+    createDropzoneId(index) {
+        return `dropzone${index}`;
+    }
+    getInteractableState(interactableId, registryId = DEFAULT_REGISTRY_ID) {
+        return this.dragRegistrySystem[registryId][interactableId].interactable$;
+    }
+    updateDeltas(interactId, registryId, { deltaX, deltaY }, targetElement) {
+        if (!this.interactableExistOnRegistry(interactId, registryId))
+            return;
+        this.dragRegistrySystem[registryId][interactId].deltas$.next({ deltaX, deltaY, targetElement });
+    }
+    updatePosition(interactId, registryId, { x, y }, targetElement) {
+        if (!this.interactableExistOnRegistry(interactId, registryId))
+            return;
+        this.dragRegistrySystem[registryId][interactId].position$.next({ x, y, targetElement });
+    }
+    updateSize(interactId, registryId, { deltaX, deltaY, width, height }, targetElement) {
+        if (!this.interactableExistOnRegistry(interactId, registryId))
+            return;
+        this.dragRegistrySystem[registryId][interactId].size$.next({ deltaX, deltaY, width, height, targetElement });
+    }
+    interactableExistOnRegistry(interactId, registryId = DEFAULT_REGISTRY_ID) {
+        // eslint-disable-next-line no-prototype-builtins
+        return this.dragRegistrySystem.hasOwnProperty(registryId) && this.dragRegistrySystem[registryId].hasOwnProperty(interactId);
+    }
+    /**
+     * Uses renderer to set width and height of angular component
+     * @param width the desired width of component
+     * @param height the desired height of component
+     * @param target the element to transform
+     */
+    setElementSize(width, height, target) {
+        if (!target)
+            return;
+        this.renderer.setStyle(target, 'width', `${width}${this.cssUnit}`);
+        this.renderer.setStyle(target, 'height', `${height}${this.cssUnit}`);
+    }
+    /**
+     * Uses renderer to set position of angular component
+     * @param x position on x axis
+     * @param y position on y axis
+     * @param target the element to transform
+     */
+    setElementTransform(x, y, position) {
+        if (!position?.targetElement)
+            return;
+        this.renderer.setStyle(position.targetElement, 'left', `${x}${this.cssUnit}`);
+        this.renderer.setStyle(position.targetElement, 'top', `${y}${this.cssUnit}`);
+    }
+    /**
+     * Generates a translate string for the x and y arguments passed to
+     * be passed to css transform
+     * @param x the position along the x axis
+     * @param y the position along the y axis
+     */
+    createTransformString(x, y) {
+        return `translate3d(${x}${this.cssUnit}, ${y}${this.cssUnit}, 0)`;
+    }
+    calculatePositionInElement(zoneElement, dragElement, scale) {
+        // TODO: this calculation may not cover a lot of scenarios, keep an eye out for possible improvements
+        const zoneRect = zoneElement.getBoundingClientRect();
+        const dragRect = dragElement.getBoundingClientRect();
+        const position = scale
+            ? {
+                x: (dragRect.left - zoneRect.left) / scale || 1,
+                y: (dragRect.top - zoneRect.top) / scale || 1
+            } : {
+            x: dragRect.left - zoneRect.left,
+            y: dragRect.top - zoneRect.top
+        };
+        // console.log({ y:position.y, drt:dragRect.top, zrt: zoneRect.top})
+        return position;
+    }
+}
+InteractService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: InteractService, deps: [{ token: i0.RendererFactory2 }, { token: i0.NgZone }, { token: INTERACT_ROOT_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+InteractService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: InteractService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: InteractService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INTERACT_ROOT_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interact.service.js","sourceRoot":"","sources":["../../../../../../libs/interact/src/lib/services/interact.service.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { Injectable, Renderer2, RendererFactory2, NgZone, Inject, Optional } from '@angular/core';\nimport { BehaviorSubject, Observable, combineLatest } from 'rxjs';\nimport { tap, map, shareReplay } from 'rxjs/operators';\nimport {\n  TftCoords, Delta, Size, Position, InteractableRegistry,\n  defaultPosition, defaultSize, defaultDelta, DEFAULT_REGISTRY_ID, TftDragElement, TftResizeElement, INTERACT_ROOT_CONFIG, InteractRootConfig\n} from '../models';\n\n\n\n@Injectable({providedIn: 'root'})\nexport class InteractService {\n\n  private _interactableIndex = 0;\n  private _dropzoneIndex = 0;\n  private renderer: Renderer2;\n\n  // TODO: consider using Map here\n  readonly dragRegistrySystem: { [key: string]: InteractableRegistry } = { };\n  private cssUnit = 'px'\n  constructor(\n    private rendererFactory: RendererFactory2,\n    private ngZone: NgZone,\n    @Optional() @Inject(INTERACT_ROOT_CONFIG) public rootConfig\n  ) {\n    this.renderer = this.rendererFactory.createRenderer(null, null);\n    this.cssUnit = rootConfig?.cssDimensionUnit || 'px';\n  }\n\n  addDeltaToPosition(delta: Delta, position: Position) {\n    return {\n      x: delta.deltaX + position.x,\n      y: delta.deltaY + position.y,\n      targetElement: position.targetElement || delta.targetElement\n    }\n  }\n\n  addRegistryToSystem(customRegistryId: string | null = null) {\n    const registryId = customRegistryId || this.createDropzoneId(this._dropzoneIndex++);\n    this.dragRegistrySystem[registryId] = {};\n    return registryId;\n  }\n\n  addDraggableToRegistry(customRegistryId = null, interactableId: string | null = null ) {\n    const registryId = customRegistryId || DEFAULT_REGISTRY_ID;\n    // if we pass an id to createInteractableId then it is used when creating the interactable\n    // and returned, otherwise a new id is created for the draggable.\n    const key = this.createInteractableId(interactableId );\n    if (!Object.prototype.hasOwnProperty.call(this.dragRegistrySystem, registryId)) {\n      this.dragRegistrySystem[registryId] = {};\n    }\n    this.dragRegistrySystem[registryId][key] = this.createInteractableState(defaultPosition, defaultSize, defaultDelta);\n    return key\n  }\n\n  destroyInteractable(interactableId: string, registryId = DEFAULT_REGISTRY_ID) {\n    const interactableSystem =this.dragRegistrySystem[registryId][interactableId];\n    if(interactableSystem) {\n      // unsubscribe from all the subscriptions if they're subscriptions\n      for (const propName in interactableSystem)  {\n        const prop = interactableSystem[propName];\n        if (prop.unsubscribe && typeof prop.unsubscribe === 'function' ) {\n          prop.unsubscribe();\n        };\n      }\n      delete this.dragRegistrySystem[registryId][interactableId];\n    }\n  }\n\n  subscribeToInteractable(interactableId: string, registryId = DEFAULT_REGISTRY_ID) {\n    return this.dragRegistrySystem[registryId][interactableId];\n  }\n\n  createInteractableState(initialPosition: Position, initialSize: Size, initialDelta: Delta ) {\n\n    const deltas$ = new BehaviorSubject(initialDelta);\n    // tracks the size of the element\n    const size$ = new BehaviorSubject({...initialSize, ...initialDelta});\n    // Stream of positions as they change\n    const position$ = new BehaviorSubject(initialPosition);\n\n    // All draggable data mapped together\n    const interactable$: Observable<TftCoords> = combineLatest([\n      size$.pipe(\n        // startWith({...initialSize, ...initialDelta}),\n        shareReplay(1),\n        // filter(resizeEvent => !!resizeEvent.targetElement),\n        tap(({deltaX, deltaY, width, height, targetElement}) => {\n          this.ngZone.runOutsideAngular(() => {\n            this.setElementSize(width, height, targetElement);\n          });\n          // only reposition if necessary i.e when resizing left or up\n          if(deltaX || deltaY) {\n            deltas$.next({deltaX, deltaY, targetElement});\n          }\n        })\n      ),\n      deltas$.pipe(\n        shareReplay(1),\n        tap((delta) => {\n          const position = position$.value;\n          const newPosition = this.addDeltaToPosition(delta, position);\n          position$.next(newPosition);\n        })\n      ),\n      position$.pipe(\n        shareReplay(1),\n        tap( position => {\n          this.ngZone.runOutsideAngular(() => {\n            this.setElementTransform(position.x, position.y, position);\n          })\n        })\n      )\n      ]).pipe(\n      shareReplay(1),\n      map( ([size, deltas, position]): TftCoords=> {\n        return {\n          x: position.x,\n          y: position.y,\n          deltaX: deltas.deltaX,\n          deltaY: deltas.deltaY,\n          width: size.width,\n          height: size.height,\n          targetElement: size.targetElement || position.targetElement || deltas.targetElement\n        }\n      }),\n    )\n    // TODO: update system to handle only returning interactable$\n    return {\n      deltas$,\n      position$,\n      size$,\n      interactable$\n    }\n  }\n\n  createInteractableId(customInteractableId: string | null = null) {\n    return customInteractableId || `interactable${this._interactableIndex++}`\n  }\n\n  createDropzoneId(index: number) {\n    return `dropzone${index}`\n  }\n\n  getInteractableState( interactableId: string, registryId = DEFAULT_REGISTRY_ID) {\n    return this.dragRegistrySystem[registryId][interactableId].interactable$;\n  }\n\n  updateDeltas(interactId: string, registryId: string, { deltaX, deltaY }, targetElement) {\n    if (!this.interactableExistOnRegistry(interactId, registryId)) return;\n    this.dragRegistrySystem[registryId][interactId].deltas$.next({ deltaX, deltaY, targetElement })\n  }\n\n  updatePosition(interactId: string, registryId: string, { x, y }: {x: number; y: number;}, targetElement) {\n    if (!this.interactableExistOnRegistry(interactId, registryId)) return;\n    this.dragRegistrySystem[registryId][interactId].position$.next({ x, y, targetElement })\n  }\n\n  updateSize(interactId: string, registryId: string, { deltaX, deltaY, width, height }, targetElement) {\n    if (!this.interactableExistOnRegistry(interactId, registryId)) return\n    this.dragRegistrySystem[registryId][interactId].size$.next({deltaX, deltaY, width, height, targetElement});\n  }\n\n  interactableExistOnRegistry(interactId: string, registryId = DEFAULT_REGISTRY_ID) {\n    // eslint-disable-next-line no-prototype-builtins\n    return this.dragRegistrySystem.hasOwnProperty(registryId) && this.dragRegistrySystem[registryId].hasOwnProperty(interactId);\n  }\n  /**\n   * Uses renderer to set width and height of angular component\n   * @param width the desired width of component\n   * @param height the desired height of component\n   * @param target the element to transform\n   */\n  setElementSize(width: number, height: number, target: TftResizeElement) {\n    if(!target) return;\n    this.renderer.setStyle(target, 'width', `${width}${this.cssUnit}`);\n    this.renderer.setStyle(target, 'height', `${height}${this.cssUnit}`);\n  }\n  /**\n   * Uses renderer to set position of angular component\n   * @param x position on x axis\n   * @param y position on y axis\n   * @param target the element to transform\n   */\n  setElementTransform(x: number, y: number, position: Position ) {\n    if(!position?.targetElement) return;\n    this.renderer.setStyle(position.targetElement, 'left', `${x}${this.cssUnit}`);\n    this.renderer.setStyle(position.targetElement, 'top', `${y}${this.cssUnit}`);\n  }\n  /**\n   * Generates a translate string for the x and y arguments passed to\n   * be passed to css transform\n   * @param x the position along the x axis\n   * @param y the position along the y axis\n   */\n  createTransformString(x: number, y: number) {\n    return `translate3d(${x}${this.cssUnit}, ${y}${this.cssUnit}, 0)`\n  }\n\n  calculatePositionInElement(zoneElement: Interact.Element, dragElement: TftDragElement, scale?: number) {\n    // TODO: this calculation may not cover a lot of scenarios, keep an eye out for possible improvements\n    const zoneRect = zoneElement.getBoundingClientRect();\n    const dragRect = dragElement.getBoundingClientRect();\n    const position = scale\n      ? {\n      x: (dragRect.left - zoneRect.left) / scale  || 1,\n      y: (dragRect.top - zoneRect.top) / scale || 1\n      } : {\n        x: dragRect.left - zoneRect.left,\n        y: dragRect.top - zoneRect.top\n    };\n    // console.log({ y:position.y, drt:dragRect.top, zrt: zoneRect.top})\n    return position;\n  }\n}\n"]}

package/esm2020/lib/utils/helpers.mjs

@@ -0,0 +1,35 @@
+/** Gets the closest ancestor of an element that matches a selector. */
+export function getClosestMatchingAncestor(element, selector) {
+    let currentElement = element.parentElement;
+    while (currentElement) {
+        // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.
+        if (currentElement.matches ? currentElement.matches(selector) :
+            currentElement.msMatchesSelector(selector)) {
+            return currentElement;
+        }
+        currentElement = currentElement.parentElement;
+    }
+    return null;
+}
+/**
+ * Create a copy of the HTML Element
+ */
+export function cloneElement(element) {
+    const clone = element.cloneNode(true);
+    clone.removeAttribute('id');
+    return clone;
+}
+/**
+ * Gets the root HTML element of an embedded view.
+ * If the root is not an HTML element it gets wrapped in one.
+ */
+export function getRootNode(viewRef, _document) {
+    const rootNodes = viewRef.rootNodes;
+    if (rootNodes.length === 1 && rootNodes[0].nodeType === _document.ELEMENT_NODE) {
+        return rootNodes[0];
+    }
+    const wrapper = _document.createElement('div');
+    rootNodes.forEach(node => wrapper.appendChild(node));
+    return wrapper;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvaW50ZXJhY3Qvc3JjL2xpYi91dGlscy9oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLHVFQUF1RTtBQUN2RSxNQUFNLFVBQVUsMEJBQTBCLENBQUMsT0FBb0IsRUFBRSxRQUFnQjtJQUMvRSxJQUFJLGNBQWMsR0FBRyxPQUFPLENBQUMsYUFBbUMsQ0FBQztJQUVqRSxPQUFPLGNBQWMsRUFBRTtRQUNyQiwrRUFBK0U7UUFDL0UsSUFBSSxjQUFjLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDMUQsY0FBNEIsQ0FBQyxpQkFBaUIsQ0FBQyxRQUFRLENBQUMsRUFBRTtZQUM3RCxPQUFPLGNBQWMsQ0FBQztTQUN2QjtRQUVELGNBQWMsR0FBRyxjQUFjLENBQUMsYUFBYSxDQUFDO0tBQy9DO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBR0Q7O0dBRUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFDLE9BQW9CO0lBRS9DLE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFnQixDQUFDO0lBQ3JELEtBQUssQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUIsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FBQyxPQUE2QixFQUFFLFNBQW1CO0lBQzVFLE1BQU0sU0FBUyxHQUFXLE9BQU8sQ0FBQyxTQUFTLENBQUM7SUFFNUMsSUFBSSxTQUFTLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsUUFBUSxLQUFLLFNBQVMsQ0FBQyxZQUFZLEVBQUU7UUFDOUUsT0FBTyxTQUFTLENBQUMsQ0FBQyxDQUFnQixDQUFDO0tBQ3BDO0lBRUQsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMvQyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ3JELE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbWJlZGRlZFZpZXdSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW50ZXJmYWNlIElFRWxlbWVudCBleHRlbmRzIEhUTUxFbGVtZW50IHtcbiAgbXNNYXRjaGVzU2VsZWN0b3I6IChzZWxlY3Rvcjogc3RyaW5nKSA9PiBib29sZWFuOyAvL1xufVxuXG4vKiogR2V0cyB0aGUgY2xvc2VzdCBhbmNlc3RvciBvZiBhbiBlbGVtZW50IHRoYXQgbWF0Y2hlcyBhIHNlbGVjdG9yLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldENsb3Nlc3RNYXRjaGluZ0FuY2VzdG9yKGVsZW1lbnQ6IEhUTUxFbGVtZW50LCBzZWxlY3Rvcjogc3RyaW5nKSB7XG4gIGxldCBjdXJyZW50RWxlbWVudCA9IGVsZW1lbnQucGFyZW50RWxlbWVudCBhcyBIVE1MRWxlbWVudCB8IG51bGw7XG5cbiAgd2hpbGUgKGN1cnJlbnRFbGVtZW50KSB7XG4gICAgLy8gSUUgZG9lc24ndCBzdXBwb3J0IGBtYXRjaGVzYCBzbyB3ZSBoYXZlIHRvIGZhbGwgYmFjayB0byBgbXNNYXRjaGVzU2VsZWN0b3JgLlxuICAgIGlmIChjdXJyZW50RWxlbWVudC5tYXRjaGVzID8gY3VycmVudEVsZW1lbnQubWF0Y2hlcyhzZWxlY3RvcikgOlxuICAgICAgICAoY3VycmVudEVsZW1lbnQgYXMgSUVFbGVtZW50KS5tc01hdGNoZXNTZWxlY3RvcihzZWxlY3RvcikpIHtcbiAgICAgIHJldHVybiBjdXJyZW50RWxlbWVudDtcbiAgICB9XG5cbiAgICBjdXJyZW50RWxlbWVudCA9IGN1cnJlbnRFbGVtZW50LnBhcmVudEVsZW1lbnQ7XG4gIH1cblxuICByZXR1cm4gbnVsbDtcbn1cblxuXG4vKipcbiAqIENyZWF0ZSBhIGNvcHkgb2YgdGhlIEhUTUwgRWxlbWVudFxuICovXG5leHBvcnQgZnVuY3Rpb24gY2xvbmVFbGVtZW50KGVsZW1lbnQ6IEhUTUxFbGVtZW50KSB7XG5cbiAgY29uc3QgY2xvbmUgPSBlbGVtZW50LmNsb25lTm9kZSh0cnVlKSBhcyBIVE1MRWxlbWVudDtcbiAgY2xvbmUucmVtb3ZlQXR0cmlidXRlKCdpZCcpO1xuICByZXR1cm4gY2xvbmU7XG59XG5cbi8qKlxuICogR2V0cyB0aGUgcm9vdCBIVE1MIGVsZW1lbnQgb2YgYW4gZW1iZWRkZWQgdmlldy5cbiAqIElmIHRoZSByb290IGlzIG5vdCBhbiBIVE1MIGVsZW1lbnQgaXQgZ2V0cyB3cmFwcGVkIGluIG9uZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFJvb3ROb2RlKHZpZXdSZWY6IEVtYmVkZGVkVmlld1JlZjxhbnk+LCBfZG9jdW1lbnQ6IERvY3VtZW50KTogSFRNTEVsZW1lbnQge1xuICBjb25zdCByb290Tm9kZXM6IE5vZGVbXSA9IHZpZXdSZWYucm9vdE5vZGVzO1xuXG4gIGlmIChyb290Tm9kZXMubGVuZ3RoID09PSAxICYmIHJvb3ROb2Rlc1swXS5ub2RlVHlwZSA9PT0gX2RvY3VtZW50LkVMRU1FTlRfTk9ERSkge1xuICAgIHJldHVybiByb290Tm9kZXNbMF0gYXMgSFRNTEVsZW1lbnQ7XG4gIH1cblxuICBjb25zdCB3cmFwcGVyID0gX2RvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpO1xuICByb290Tm9kZXMuZm9yRWFjaChub2RlID0+IHdyYXBwZXIuYXBwZW5kQ2hpbGQobm9kZSkpO1xuICByZXR1cm4gd3JhcHBlcjtcbn1cbiJdfQ==

package/esm2020/lib/utils/index.mjs

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

package/esm2020/tft-interact.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGZ0LWludGVyYWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicy9pbnRlcmFjdC9zcmMvdGZ0LWludGVyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19