@hellpig/anarchy-engine 21.3.1 → 22.0.0

package/dist/Intersections/Watchers/IntersectionsCameraWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntersectionsCameraWatcher.js","sources":["../../../src/Intersections/Watchers/IntersectionsCameraWatcher.ts"],"sourcesContent":["import type { TAnyCameraWrapper } from '@Anarchy/Engine/Camera';\nimport type {\n  TAbstractIntersectionsWatcher,\n  TIntersectionEvent,\n  TIntersectionsCameraWatcher,\n  TIntersectionsCameraWatcherParams,\n  TIntersectionsWatcherPerformanceOptions\n} from '@Anarchy/Engine/Intersections/Models';\nimport { getChangedPosition } from '@Anarchy/Engine/Intersections/Utils';\nimport { AbstractIntersectionsWatcher } from '@Anarchy/Engine/Intersections/Watchers/AbstractIntersectionsWatcher';\nimport type { TMilliseconds } from '@Anarchy/Engine/Math';\nimport type { TSceneObject } from '@Anarchy/Engine/Scene';\nimport type { TReadonlyVector2 } from '@Anarchy/Engine/ThreeLib';\nimport type { TWriteable } from '@Anarchy/Shared/Utils';\nimport { isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\nimport type { Observable, Subscription } from 'rxjs';\nimport { distinctUntilChanged, EMPTY, filter, map, switchMap } from 'rxjs';\nimport type { Vector2Like } from 'three';\nimport { Vector2 } from 'three';\n\nexport function IntersectionsCameraWatcher(params: TIntersectionsCameraWatcherParams): TIntersectionsCameraWatcher {\n  const { position$, performance, intersectionsLoop } = params;\n  const abstractIntersectionsWatcher: TAbstractIntersectionsWatcher = AbstractIntersectionsWatcher(params);\n  let camera: Readonly<TAnyCameraWrapper> | undefined;\n\n  const setCamera = (c: TAnyCameraWrapper): void => void (camera = c);\n  const findCamera = (): TAnyCameraWrapper | undefined => camera;\n  const getCamera = (): TAnyCameraWrapper | never => {\n    if (isNotDefined(camera)) throw new Error('[IntersectionsWatcher]: Cannot get camera: not defined');\n    return camera;\n  };\n\n  let position: TReadonlyVector2 = new Vector2();\n  const positionSub$: Subscription = position$.subscribe((value: Vector2Like): Vector2 => (position = new Vector2().copy(value)));\n\n  const threshold: number = performance?.noiseThreshold ?? 0.001;\n  // shouldReactOnlyOnChange might improve performance, however, won't fire an event if the mouse (position$) is not moving (and actor or scene is moving)\n  const shouldReactOnlyOnChange: boolean = performance?.shouldReactOnlyOnChange ?? false;\n\n  const tmpPosition = new Float32Array(2);\n  const prevPosition = new Float32Array(2);\n  let isPrevValueUndefined: boolean = true;\n\n  const enabledSub$: Subscription = abstractIntersectionsWatcher.enabled$\n    .pipe(\n      distinctUntilChanged(),\n      switchMap((isEnabled: boolean): Observable<TMilliseconds | never> => (isEnabled ? intersectionsLoop.tick$ : EMPTY)),\n      map(\n        ():\n          | Readonly<{\n              position: TReadonlyVector2;\n            }>\n          | undefined => (shouldReactOnlyOnChange ? getChangedPosition(tmpPosition, prevPosition, position, threshold) : { position })\n      ),\n      filter(isDefined)\n    )\n    .subscribe(({ position }: Readonly<{ position: TReadonlyVector2 }>): void => {\n      if (isNotDefined(camera)) {\n        enabledSub$.unsubscribe();\n        throw new Error('[IntersectionsWatcher]: Cannot start: camera is not defined');\n      }\n\n      const intersection: TIntersectionEvent | undefined = getIntersection(position as Vector2, camera, abstractIntersectionsWatcher.getModelsFromActors());\n      if (isDefined(intersection)) {\n        if (!params.isDistinct || (params.isDistinct && isPrevValueUndefined)) {\n          abstractIntersectionsWatcher.value$.next(intersection);\n          isPrevValueUndefined = false;\n        }\n      } else if (params.triggerNoIntersections) {\n        if (!params.isDistinct || (params.isDistinct && !isPrevValueUndefined)) {\n          abstractIntersectionsWatcher.value$.next(undefined);\n          isPrevValueUndefined = true;\n        }\n      }\n    });\n\n  function getIntersection(coords: Vector2, cameraWrapper: Readonly<TAnyCameraWrapper>, list: Array<TSceneObject>): TIntersectionEvent | undefined | never {\n    if (isNotDefined(abstractIntersectionsWatcher.raycaster)) throw new Error('[IntersectionsWatcher]: Cannot get intersection: raycaster is not defined');\n    abstractIntersectionsWatcher.raycaster.setFromCamera(coords, cameraWrapper.entity);\n    return abstractIntersectionsWatcher.raycaster.intersectObjects(list)[0];\n  }\n\n  const destroySub$: Subscription = abstractIntersectionsWatcher.destroy$.subscribe((): void => {\n    positionSub$?.unsubscribe();\n    enabledSub$.unsubscribe();\n    destroySub$.unsubscribe();\n  });\n\n  // eslint-disable-next-line functional/immutable-data\n  const result: TWriteable<TIntersectionsCameraWatcher> = Object.assign(abstractIntersectionsWatcher, {\n    findCamera,\n    getCamera,\n    setCamera,\n    getPerformanceSettings: (): TIntersectionsWatcherPerformanceOptions => ({\n      noiseThreshold: threshold,\n      shouldReactOnlyOnChange\n    })\n  });\n\n  setCamera(params.camera);\n\n  return result;\n}\n"],"names":["IntersectionsCameraWatcher","params","position$","performance","intersectionsLoop","abstractIntersectionsWatcher","AbstractIntersectionsWatcher","camera","setCamera","c","position","Vector2","positionSub$","subscribe","value","copy","threshold","noiseThreshold","shouldReactOnlyOnChange","tmpPosition","Float32Array","prevPosition","isPrevValueUndefined","enabledSub$","enabled$","pipe","distinctUntilChanged","switchMap","isEnabled","tick$","EMPTY","map","getChangedPosition","filter","isDefined","isNotDefined","unsubscribe","Error","intersection","coords","cameraWrapper","list","raycaster","setFromCamera","entity","intersectObjects","getIntersection","getModelsFromActors","isDistinct","value$","next","triggerNoIntersections","destroySub$","destroy$","result","Object","assign","findCamera","getCamera","getPerformanceSettings"],"mappings":"isBAoBO,SAASA,2BAA2BC,QACzC,MAAMC,UAAEA,UAAAC,YAAWA,YAAAC,kBAAaA,mBAAsBH,OAChDI,6BAA8DC,6BAA6BL,QACjG,IAAIM,OAEJ,MAAMC,UAAaC,IAAqCF,OAASE,GAOjE,IAAIC,SAA6B,IAAIC,QACrC,MAAMC,aAA6BV,UAAUW,UAAWC,OAAiCJ,UAAW,IAAIC,SAAUI,KAAKD,QAEjHE,UAAoBb,aAAac,gBAAkB,KAEnDC,wBAAmCf,aAAae,0BAA2B,EAE3EC,YAAc,IAAIC,aAAa,GAC/BC,aAAe,IAAID,aAAa,GACtC,IAAIE,sBAAgC,EAEpC,MAAMC,YAA4BlB,6BAA6BmB,SAC5DC,KACCC,uBACAC,UAAWC,WAA2DA,UAAYxB,kBAAkByB,MAAQC,OAC5GC,IACE,IAIkBb,wBAA0Bc,mBAAmBb,YAAaE,aAAcX,SAAUM,WAAa,CAAEN,oBAErHuB,OAAOC,YAERrB,UAAU,EAAGH,SAAAA,cACZ,GAAIyB,aAAa5B,QAEf,MADAgB,YAAYa,cACN,IAAIC,MAAM,+DAGlB,MAAMC,aAcV,SAAyBC,OAAiBC,cAA4CC,MACpF,GAAIN,aAAa9B,6BAA6BqC,WAAY,MAAM,IAAIL,MAAM,6EAE1E,OADAhC,6BAA6BqC,UAAUC,cAAcJ,OAAQC,cAAcI,QACpEvC,6BAA6BqC,UAAUG,iBAAiBJ,MAAM,EACvE,CAlByDK,CAAgBpC,UAAqBH,OAAQF,6BAA6B0C,uBAC3Hb,UAAUI,gBACPrC,OAAO+C,YAAe/C,OAAO+C,YAAc1B,wBAC9CjB,6BAA6B4C,OAAOC,KAAKZ,cACzChB,sBAAuB,GAEhBrB,OAAOkD,0BACXlD,OAAO+C,YAAe/C,OAAO+C,aAAe1B,wBAC/CjB,6BAA6B4C,OAAOC,aACpC5B,sBAAuB,KAWzB8B,YAA4B/C,6BAA6BgD,SAASxC,UAAU,KAChFD,cAAcwB,cACdb,YAAYa,cACZgB,YAAYhB,gBAIRkB,OAAkDC,OAAOC,OAAOnD,6BAA8B,CAClGoD,WAhEiB,IAAqClD,OAiEtDmD,UAhEgB,KAChB,GAAIvB,aAAa5B,QAAS,MAAM,IAAI8B,MAAM,0DAC1C,OAAO9B,QA+DPC,oBACAmD,uBAAwB,KAAA,CACtB1C,eAAgBD,UAChBE,oDAMJ,OAFAV,UAAUP,OAAOM,QAEV+C,MACT"}

package/dist/Intersections/Watchers/IntersectionsDirectionWatcher.js

@@ -0,0 +1,2 @@
+import{AbstractIntersectionsWatcher}from"./AbstractIntersectionsWatcher.js";import{isDefined,isNotDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{Vector3}from"three";import{Line2}from"three/examples/jsm/lines/Line2";import{LineGeometry}from"three/examples/jsm/lines/LineGeometry";import{LineMaterial}from"three/examples/jsm/lines/LineMaterial";import{BehaviorSubject}from"../../node_modules/rxjs/dist/esm5/internal/BehaviorSubject.js";import{distinctUntilChanged}from"../../node_modules/rxjs/dist/esm5/internal/operators/distinctUntilChanged.js";import{switchMap}from"../../node_modules/rxjs/dist/esm5/internal/operators/switchMap.js";import{map}from"../../node_modules/rxjs/dist/esm5/internal/operators/map.js";import{filter}from"../../node_modules/rxjs/dist/esm5/internal/operators/filter.js";import{EMPTY}from"../../node_modules/rxjs/dist/esm5/internal/observable/empty.js";import{getChangedOriginAndDirection}from"../Utils/IntersectionsWatcherUtils.js";function IntersectionsDirectionWatcher(params){const{performance:performance,intersectionsLoop:intersectionsLoop}=params,abstractIntersectionsWatcher=AbstractIntersectionsWatcher(params),origin$=new BehaviorSubject((new Vector3).copy(params.origin)),direction$=new BehaviorSubject((new Vector3).copy(params.direction)),threshold=performance?.noiseThreshold??.001,shouldReactOnlyOnChange=performance?.shouldReactOnlyOnChange??!1,tmpOrigin=new Float32Array(3),prevOrigin=new Float32Array(3),tmpDirection=new Float32Array(3),prevDirection=new Float32Array(3),enabledSub$=abstractIntersectionsWatcher.enabled$.pipe(distinctUntilChanged(),switchMap(isEnabled=>isEnabled?intersectionsLoop.tick$:EMPTY),map(()=>shouldReactOnlyOnChange?getChangedOriginAndDirection(tmpOrigin,tmpDirection,prevOrigin,prevDirection,origin$.value.clone(),direction$.value.clone(),threshold):{origin:origin$.value.clone(),direction:direction$.value.clone()}),filter(isDefined)).subscribe(({origin:origin,direction:direction})=>{const intersection=function(origin,direction,list){if(isNotDefined(abstractIntersectionsWatcher.raycaster))throw new Error("[IntersectionsDirectionWatcher]: Cannot get intersection: raycaster is not defined");return abstractIntersectionsWatcher.raycaster.set(origin,direction.normalize()),abstractIntersectionsWatcher.raycaster.intersectObjects(list)[0]}(origin,direction,abstractIntersectionsWatcher.getModelsFromActors());isDefined(intersection)&&abstractIntersectionsWatcher.value$.next(intersection)}),destroySub$=abstractIntersectionsWatcher.destroy$.subscribe(()=>{enabledSub$.unsubscribe(),destroySub$.unsubscribe()});return Object.assign(abstractIntersectionsWatcher,{origin$:origin$,direction$:direction$,targetPointToDirection:function(origin,target){return new Vector3(target.x-origin.x,target.y-origin.y,target.z-origin.z).normalize()},getDistanceToTargetPoint:function(origin,target){return new Vector3(target.x-origin.x,target.y-origin.y,target.z-origin.z).length()},getPerformanceSettings:()=>({noiseThreshold:threshold,shouldReactOnlyOnChange:shouldReactOnlyOnChange}),_debugGetRayVisualizationLine:function(container,length=100,color=16711680,lineWidth=1){const points=[origin$.value.x,origin$.value.y,origin$.value.z,origin$.value.x+direction$.value.x*length,origin$.value.y+direction$.value.y*length,origin$.value.z+direction$.value.z*length],geometry=new LineGeometry;geometry.setPositions(points);const material=new LineMaterial({color:color,linewidth:lineWidth,dashed:!1,transparent:!0});material.resolution.set(container.getWidth(),container.getHeight());const line=new Line2(geometry,material);return line.computeLineDistances(),line.name="RayDebugLine2",line}})}export{IntersectionsDirectionWatcher};
+//# sourceMappingURL=IntersectionsDirectionWatcher.js.map

package/dist/Intersections/Watchers/IntersectionsDirectionWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntersectionsDirectionWatcher.js","sources":["../../../src/Intersections/Watchers/IntersectionsDirectionWatcher.ts"],"sourcesContent":["import type { TContainerDecorator } from '@Anarchy/Engine/Global';\nimport type {\n  TAbstractIntersectionsWatcher,\n  TIntersectionEvent,\n  TIntersectionsDirectionWatcher,\n  TIntersectionsDirectionWatcherParams,\n  TIntersectionsWatcherPerformanceOptions\n} from '@Anarchy/Engine/Intersections/Models';\nimport { getChangedOriginAndDirection } from '@Anarchy/Engine/Intersections/Utils';\nimport { AbstractIntersectionsWatcher } from '@Anarchy/Engine/Intersections/Watchers/AbstractIntersectionsWatcher';\nimport type { TMilliseconds } from '@Anarchy/Engine/Math';\nimport type { TSceneObject } from '@Anarchy/Engine/Scene';\nimport type { TReadonlyVector3 } from '@Anarchy/Engine/ThreeLib';\nimport { isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\nimport type { Observable, Subscription } from 'rxjs';\nimport { BehaviorSubject, distinctUntilChanged, EMPTY, filter, map, switchMap } from 'rxjs';\nimport type { ColorRepresentation, Vector3Like } from 'three';\nimport { Vector3 } from 'three';\nimport { Line2 } from 'three/examples/jsm/lines/Line2';\nimport { LineGeometry } from 'three/examples/jsm/lines/LineGeometry';\nimport { LineMaterial } from 'three/examples/jsm/lines/LineMaterial';\n\nexport function IntersectionsDirectionWatcher(params: TIntersectionsDirectionWatcherParams): TIntersectionsDirectionWatcher {\n  const { performance, intersectionsLoop } = params;\n  const abstractIntersectionsWatcher: TAbstractIntersectionsWatcher = AbstractIntersectionsWatcher(params);\n\n  const origin$: BehaviorSubject<TReadonlyVector3> = new BehaviorSubject<TReadonlyVector3>(new Vector3().copy(params.origin));\n  const direction$: BehaviorSubject<TReadonlyVector3> = new BehaviorSubject<TReadonlyVector3>(new Vector3().copy(params.direction));\n\n  const threshold: number = performance?.noiseThreshold ?? 0.001;\n  // shouldReactOnlyOnChange might improve performance, however, won't fire an event if the mouse (position$) is not moving (and actor or scene is moving)\n  const shouldReactOnlyOnChange: boolean = performance?.shouldReactOnlyOnChange ?? false;\n\n  const tmpOrigin = new Float32Array(3);\n  const prevOrigin = new Float32Array(3);\n  const tmpDirection = new Float32Array(3);\n  const prevDirection = new Float32Array(3);\n\n  const enabledSub$: Subscription = abstractIntersectionsWatcher.enabled$\n    .pipe(\n      distinctUntilChanged(),\n      switchMap((isEnabled: boolean): Observable<TMilliseconds | never> => (isEnabled ? intersectionsLoop.tick$ : EMPTY)),\n      map((): Readonly<{ origin: TReadonlyVector3; direction: TReadonlyVector3 }> | undefined =>\n        shouldReactOnlyOnChange\n          ? getChangedOriginAndDirection(tmpOrigin, tmpDirection, prevOrigin, prevDirection, origin$.value.clone(), direction$.value.clone(), threshold)\n          : { origin: origin$.value.clone(), direction: direction$.value.clone() }\n      ),\n      filter(isDefined)\n    )\n    .subscribe(({ origin, direction }: Readonly<{ origin: TReadonlyVector3; direction: TReadonlyVector3 }>): void => {\n      const intersection: TIntersectionEvent | undefined = getIntersection(origin as Vector3, direction as Vector3, abstractIntersectionsWatcher.getModelsFromActors());\n      if (isDefined(intersection)) abstractIntersectionsWatcher.value$.next(intersection);\n    });\n\n  function getIntersection(origin: Vector3, direction: Vector3, list: Array<TSceneObject>): TIntersectionEvent | undefined | never {\n    if (isNotDefined(abstractIntersectionsWatcher.raycaster)) throw new Error('[IntersectionsDirectionWatcher]: Cannot get intersection: raycaster is not defined');\n    abstractIntersectionsWatcher.raycaster.set(origin, direction.normalize());\n    return abstractIntersectionsWatcher.raycaster.intersectObjects(list)[0];\n  }\n\n  function getDistanceToTargetPoint(origin: Vector3Like, target: Vector3Like): number {\n    return new Vector3(target.x - origin.x, target.y - origin.y, target.z - origin.z).length();\n  }\n\n  function targetPointToDirection(origin: Vector3Like, target: Vector3Like): TReadonlyVector3 {\n    return new Vector3(target.x - origin.x, target.y - origin.y, target.z - origin.z).normalize();\n  }\n\n  function _debugGetRayVisualizationLine(container: TContainerDecorator, length: number = 100, color: ColorRepresentation = 0xff0000, lineWidth: number = 1): Line2 {\n    const points: Array<number> = [\n      origin$.value.x,\n      origin$.value.y,\n      origin$.value.z,\n      origin$.value.x + direction$.value.x * length,\n      origin$.value.y + direction$.value.y * length,\n      origin$.value.z + direction$.value.z * length\n    ];\n\n    const geometry = new LineGeometry();\n    geometry.setPositions(points);\n\n    const material = new LineMaterial({\n      color,\n      linewidth: lineWidth,\n      dashed: false,\n      transparent: true\n    });\n\n    material.resolution.set(container.getWidth(), container.getHeight());\n\n    const line = new Line2(geometry, material);\n    line.computeLineDistances();\n    // eslint-disable-next-line functional/immutable-data\n    line.name = 'RayDebugLine2';\n\n    return line;\n  }\n\n  const destroySub$: Subscription = abstractIntersectionsWatcher.destroy$.subscribe((): void => {\n    enabledSub$.unsubscribe();\n    destroySub$.unsubscribe();\n  });\n\n  // eslint-disable-next-line functional/immutable-data\n  return Object.assign(abstractIntersectionsWatcher, {\n    origin$,\n    direction$,\n    targetPointToDirection,\n    getDistanceToTargetPoint,\n    getPerformanceSettings: (): TIntersectionsWatcherPerformanceOptions => ({\n      noiseThreshold: threshold,\n      shouldReactOnlyOnChange\n    }),\n    _debugGetRayVisualizationLine\n  });\n}\n"],"names":["IntersectionsDirectionWatcher","params","performance","intersectionsLoop","abstractIntersectionsWatcher","AbstractIntersectionsWatcher","origin$","BehaviorSubject","Vector3","copy","origin","direction$","direction","threshold","noiseThreshold","shouldReactOnlyOnChange","tmpOrigin","Float32Array","prevOrigin","tmpDirection","prevDirection","enabledSub$","enabled$","pipe","distinctUntilChanged","switchMap","isEnabled","tick$","EMPTY","map","getChangedOriginAndDirection","value","clone","filter","isDefined","subscribe","intersection","list","isNotDefined","raycaster","Error","set","normalize","intersectObjects","getIntersection","getModelsFromActors","value$","next","destroySub$","destroy$","unsubscribe","Object","assign","targetPointToDirection","target","x","y","z","getDistanceToTargetPoint","length","getPerformanceSettings","_debugGetRayVisualizationLine","container","color","lineWidth","points","geometry","LineGeometry","setPositions","material","LineMaterial","linewidth","dashed","transparent","resolution","getWidth","getHeight","line","Line2","computeLineDistances","name"],"mappings":"w9BAsBO,SAASA,8BAA8BC,QAC5C,MAAMC,YAAEA,YAAAC,kBAAaA,mBAAsBF,OACrCG,6BAA8DC,6BAA6BJ,QAE3FK,QAA6C,IAAIC,iBAAkC,IAAIC,SAAUC,KAAKR,OAAOS,SAC7GC,WAAgD,IAAIJ,iBAAkC,IAAIC,SAAUC,KAAKR,OAAOW,YAEhHC,UAAoBX,aAAaY,gBAAkB,KAEnDC,wBAAmCb,aAAaa,0BAA2B,EAE3EC,UAAY,IAAIC,aAAa,GAC7BC,WAAa,IAAID,aAAa,GAC9BE,aAAe,IAAIF,aAAa,GAChCG,cAAgB,IAAIH,aAAa,GAEjCI,YAA4BjB,6BAA6BkB,SAC5DC,KACCC,uBACAC,UAAWC,WAA2DA,UAAYvB,kBAAkBwB,MAAQC,OAC5GC,IAAI,IACFd,wBACIe,6BAA6Bd,UAAWG,aAAcD,WAAYE,cAAed,QAAQyB,MAAMC,QAASrB,WAAWoB,MAAMC,QAASnB,WAClI,CAAEH,OAAQJ,QAAQyB,MAAMC,QAASpB,UAAWD,WAAWoB,MAAMC,UAEnEC,OAAOC,YAERC,UAAU,EAAGzB,cAAQE,wBACpB,MAAMwB,aAIV,SAAyB1B,OAAiBE,UAAoByB,MAC5D,GAAIC,aAAalC,6BAA6BmC,WAAY,MAAM,IAAIC,MAAM,sFAE1E,OADApC,6BAA6BmC,UAAUE,IAAI/B,OAAQE,UAAU8B,aACtDtC,6BAA6BmC,UAAUI,iBAAiBN,MAAM,EACvE,CARyDO,CAAgBlC,OAAmBE,UAAsBR,6BAA6ByC,uBACvIX,UAAUE,eAAehC,6BAA6B0C,OAAOC,KAAKX,gBA+CpEY,YAA4B5C,6BAA6B6C,SAASd,UAAU,KAChFd,YAAY6B,cACZF,YAAYE,gBAId,OAAOC,OAAOC,OAAOhD,6BAA8B,CACjDE,gBACAK,sBACA0C,uBA3CF,SAAgC3C,OAAqB4C,QACnD,OAAO,IAAI9C,QAAQ8C,OAAOC,EAAI7C,OAAO6C,EAAGD,OAAOE,EAAI9C,OAAO8C,EAAGF,OAAOG,EAAI/C,OAAO+C,GAAGf,WACpF,EA0CEgB,yBAhDF,SAAkChD,OAAqB4C,QACrD,OAAO,IAAI9C,QAAQ8C,OAAOC,EAAI7C,OAAO6C,EAAGD,OAAOE,EAAI9C,OAAO8C,EAAGF,OAAOG,EAAI/C,OAAO+C,GAAGE,QACpF,EA+CEC,uBAAwB,KAAA,CACtB9C,eAAgBD,UAChBE,kDAEF8C,8BA7CF,SAAuCC,UAAgCH,OAAiB,IAAKI,MAA6B,SAAUC,UAAoB,GACtJ,MAAMC,OAAwB,CAC5B3D,QAAQyB,MAAMwB,EACdjD,QAAQyB,MAAMyB,EACdlD,QAAQyB,MAAM0B,EACdnD,QAAQyB,MAAMwB,EAAI5C,WAAWoB,MAAMwB,EAAII,OACvCrD,QAAQyB,MAAMyB,EAAI7C,WAAWoB,MAAMyB,EAAIG,OACvCrD,QAAQyB,MAAM0B,EAAI9C,WAAWoB,MAAM0B,EAAIE,QAGnCO,SAAW,IAAIC,aACrBD,SAASE,aAAaH,QAEtB,MAAMI,SAAW,IAAIC,aAAa,CAChCP,YACAQ,UAAWP,UACXQ,QAAQ,EACRC,aAAa,IAGfJ,SAASK,WAAWjC,IAAIqB,UAAUa,WAAYb,UAAUc,aAExD,MAAMC,KAAO,IAAIC,MAAMZ,SAAUG,UAKjC,OAJAQ,KAAKE,uBAELF,KAAKG,KAAO,gBAELH,IACT,GAmBF"}

package/dist/Keyboard/Constants/KeyCode.js

@@ -0,0 +1,2 @@
+var KeyCode=(KeyCode2=>(KeyCode2.A="KeyA",KeyCode2.AltLeft="AltLeft",KeyCode2.AltRight="AltRight",KeyCode2.ArrowDown="ArrowDown",KeyCode2.ArrowLeft="ArrowLeft",KeyCode2.ArrowRight="ArrowRight",KeyCode2.ArrowUp="ArrowUp",KeyCode2.B="KeyB",KeyCode2.Backquote="Backquote",KeyCode2.Backslash="Backslash",KeyCode2.Backspace="Backspace",KeyCode2.BracketLeft="BracketLeft",KeyCode2.BracketRight="BracketRight",KeyCode2.C="KeyC",KeyCode2.CapsLock="CapsLock",KeyCode2.Comma="Comma",KeyCode2.ControlLeft="ControlLeft",KeyCode2.ControlRight="ControlRight",KeyCode2.D="KeyD",KeyCode2.Delete="Delete",KeyCode2.E="KeyE",KeyCode2.Eight="Digit8",KeyCode2.End="End",KeyCode2.Enter="Enter",KeyCode2.Equal="Equal",KeyCode2.Escape="Escape",KeyCode2.F="KeyF",KeyCode2.F1="F1",KeyCode2.F10="F10",KeyCode2.F11="F11",KeyCode2.F12="F12",KeyCode2.F2="F2",KeyCode2.F3="F3",KeyCode2.F4="F4",KeyCode2.F5="F5",KeyCode2.F6="F6",KeyCode2.F7="F7",KeyCode2.F8="F8",KeyCode2.F9="F9",KeyCode2.Five="Digit5",KeyCode2.Four="Digit4",KeyCode2.G="KeyG",KeyCode2.H="KeyH",KeyCode2.Home="Home",KeyCode2.I="KeyI",KeyCode2.Insert="Insert",KeyCode2.IntlBackslash="IntlBackslash",KeyCode2.J="KeyJ",KeyCode2.K="KeyK",KeyCode2.L="KeyL",KeyCode2.M="KeyM",KeyCode2.MetaLeft="MetaLeft",KeyCode2.MetaRight="MetaRight",KeyCode2.Minus="Minus",KeyCode2.N="KeyN",KeyCode2.Nine="Digit9",KeyCode2.NumLock="NumLock",KeyCode2.Numpad0="Numpad0",KeyCode2.Numpad1="Numpad1",KeyCode2.Numpad2="Numpad2",KeyCode2.Numpad3="Numpad3",KeyCode2.Numpad4="Numpad4",KeyCode2.Numpad5="Numpad5",KeyCode2.Numpad6="Numpad6",KeyCode2.Numpad7="Numpad7",KeyCode2.Numpad8="Numpad8",KeyCode2.Numpad9="Numpad9",KeyCode2.NumpadAdd="NumpadAdd",KeyCode2.NumpadComma="NumpadComma",KeyCode2.NumpadDecimal="NumpadDecimal",KeyCode2.NumpadDivide="NumpadDivide",KeyCode2.NumpadEnter="NumpadEnter",KeyCode2.NumpadEqual="NumpadEqual",KeyCode2.NumpadMultiply="NumpadMultiply",KeyCode2.NumpadSubtract="NumpadSubtract",KeyCode2.O="KeyO",KeyCode2.One="Digit1",KeyCode2.P="KeyP",KeyCode2.PageDown="PageDown",KeyCode2.PageUp="PageUp",KeyCode2.PauseBreak="PauseBreak",KeyCode2.Period="Period",KeyCode2.Q="KeyQ",KeyCode2.Quote="Quote",KeyCode2.R="KeyR",KeyCode2.S="KeyS",KeyCode2.ScrollLock="ScrollLock",KeyCode2.SemiColon="SemiColon",KeyCode2.Semicolon="Semicolon",KeyCode2.Seven="Digit7",KeyCode2.ShiftLeft="ShiftLeft",KeyCode2.ShiftRight="ShiftRight",KeyCode2.Six="Digit6",KeyCode2.Slash="Slash",KeyCode2.Space="Space",KeyCode2.T="KeyT",KeyCode2.TAB="Tab",KeyCode2.Three="Digit3",KeyCode2.Two="Digit2",KeyCode2.U="KeyU",KeyCode2.V="KeyV",KeyCode2.W="KeyW",KeyCode2.X="KeyX",KeyCode2.Y="KeyY",KeyCode2.Z="KeyZ",KeyCode2.Zero="Digit0",KeyCode2))(KeyCode||{});export{KeyCode};
+//# sourceMappingURL=KeyCode.js.map

package/dist/Keyboard/Constants/KeyCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyCode.js","sources":["../../../src/Keyboard/Constants/KeyCode.ts"],"sourcesContent":["export enum KeyCode {\n  A = 'KeyA',\n  AltLeft = 'AltLeft',\n  AltRight = 'AltRight',\n  ArrowDown = 'ArrowDown',\n  ArrowLeft = 'ArrowLeft',\n  ArrowRight = 'ArrowRight',\n  ArrowUp = 'ArrowUp',\n  B = 'KeyB',\n  Backquote = 'Backquote',\n  Backslash = 'Backslash',\n  Backspace = 'Backspace',\n  BracketLeft = 'BracketLeft',\n  BracketRight = 'BracketRight',\n  C = 'KeyC',\n  CapsLock = 'CapsLock',\n  Comma = 'Comma',\n  ControlLeft = 'ControlLeft',\n  ControlRight = 'ControlRight',\n  D = 'KeyD',\n  Delete = 'Delete',\n  E = 'KeyE',\n  Eight = 'Digit8',\n  End = 'End',\n  Enter = 'Enter',\n  Equal = 'Equal',\n  Escape = 'Escape',\n  F = 'KeyF',\n  F1 = 'F1',\n  F10 = 'F10',\n  F11 = 'F11',\n  F12 = 'F12',\n  F2 = 'F2',\n  F3 = 'F3',\n  F4 = 'F4',\n  F5 = 'F5',\n  F6 = 'F6',\n  F7 = 'F7',\n  F8 = 'F8',\n  F9 = 'F9',\n  Five = 'Digit5',\n  Four = 'Digit4',\n  G = 'KeyG',\n  H = 'KeyH',\n  Home = 'Home',\n  I = 'KeyI',\n  Insert = 'Insert',\n  IntlBackslash = 'IntlBackslash',\n  J = 'KeyJ',\n  K = 'KeyK',\n  L = 'KeyL',\n  M = 'KeyM',\n  MetaLeft = 'MetaLeft',\n  MetaRight = 'MetaRight',\n  Minus = 'Minus',\n  N = 'KeyN',\n  Nine = 'Digit9',\n  NumLock = 'NumLock',\n  Numpad0 = 'Numpad0',\n  Numpad1 = 'Numpad1',\n  Numpad2 = 'Numpad2',\n  Numpad3 = 'Numpad3',\n  Numpad4 = 'Numpad4',\n  Numpad5 = 'Numpad5',\n  Numpad6 = 'Numpad6',\n  Numpad7 = 'Numpad7',\n  Numpad8 = 'Numpad8',\n  Numpad9 = 'Numpad9',\n  NumpadAdd = 'NumpadAdd',\n  NumpadComma = 'NumpadComma',\n  NumpadDecimal = 'NumpadDecimal',\n  NumpadDivide = 'NumpadDivide',\n  NumpadEnter = 'NumpadEnter',\n  NumpadEqual = 'NumpadEqual',\n  NumpadMultiply = 'NumpadMultiply',\n  NumpadSubtract = 'NumpadSubtract',\n  O = 'KeyO',\n  One = 'Digit1',\n  P = 'KeyP',\n  PageDown = 'PageDown',\n  PageUp = 'PageUp',\n  PauseBreak = 'PauseBreak',\n  Period = 'Period',\n  Q = 'KeyQ',\n  Quote = 'Quote',\n  R = 'KeyR',\n  S = 'KeyS',\n  ScrollLock = 'ScrollLock',\n  SemiColon = 'SemiColon',\n  Semicolon = 'Semicolon',\n  Seven = 'Digit7',\n  ShiftLeft = 'ShiftLeft',\n  ShiftRight = 'ShiftRight',\n  Six = 'Digit6',\n  Slash = 'Slash',\n  Space = 'Space',\n  T = 'KeyT',\n  TAB = 'Tab',\n  Three = 'Digit3',\n  Two = 'Digit2',\n  U = 'KeyU',\n  V = 'KeyV',\n  W = 'KeyW',\n  X = 'KeyX',\n  Y = 'KeyY',\n  Z = 'KeyZ',\n  Zero = 'Digit0'\n}\n"],"names":["KeyCode"],"mappings":"AAAO,IAAKA,SAAAA,WACVA,SAAA,EAAI,OACJA,SAAA,QAAU,UACVA,SAAA,SAAW,WACXA,SAAA,UAAY,YACZA,SAAA,UAAY,YACZA,SAAA,WAAa,aACbA,SAAA,QAAU,UACVA,SAAA,EAAI,OACJA,SAAA,UAAY,YACZA,SAAA,UAAY,YACZA,SAAA,UAAY,YACZA,SAAA,YAAc,cACdA,SAAA,aAAe,eACfA,SAAA,EAAI,OACJA,SAAA,SAAW,WACXA,SAAA,MAAQ,QACRA,SAAA,YAAc,cACdA,SAAA,aAAe,eACfA,SAAA,EAAI,OACJA,SAAA,OAAS,SACTA,SAAA,EAAI,OACJA,SAAA,MAAQ,SACRA,SAAA,IAAM,MACNA,SAAA,MAAQ,QACRA,SAAA,MAAQ,QACRA,SAAA,OAAS,SACTA,SAAA,EAAI,OACJA,SAAA,GAAK,KACLA,SAAA,IAAM,MACNA,SAAA,IAAM,MACNA,SAAA,IAAM,MACNA,SAAA,GAAK,KACLA,SAAA,GAAK,KACLA,SAAA,GAAK,KACLA,SAAA,GAAK,KACLA,SAAA,GAAK,KACLA,SAAA,GAAK,KACLA,SAAA,GAAK,KACLA,SAAA,GAAK,KACLA,SAAA,KAAO,SACPA,SAAA,KAAO,SACPA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,KAAO,OACPA,SAAA,EAAI,OACJA,SAAA,OAAS,SACTA,SAAA,cAAgB,gBAChBA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,SAAW,WACXA,SAAA,UAAY,YACZA,SAAA,MAAQ,QACRA,SAAA,EAAI,OACJA,SAAA,KAAO,SACPA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,QAAU,UACVA,SAAA,UAAY,YACZA,SAAA,YAAc,cACdA,SAAA,cAAgB,gBAChBA,SAAA,aAAe,eACfA,SAAA,YAAc,cACdA,SAAA,YAAc,cACdA,SAAA,eAAiB,iBACjBA,SAAA,eAAiB,iBACjBA,SAAA,EAAI,OACJA,SAAA,IAAM,SACNA,SAAA,EAAI,OACJA,SAAA,SAAW,WACXA,SAAA,OAAS,SACTA,SAAA,WAAa,aACbA,SAAA,OAAS,SACTA,SAAA,EAAI,OACJA,SAAA,MAAQ,QACRA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,WAAa,aACbA,SAAA,UAAY,YACZA,SAAA,UAAY,YACZA,SAAA,MAAQ,SACRA,SAAA,UAAY,YACZA,SAAA,WAAa,aACbA,SAAA,IAAM,SACNA,SAAA,MAAQ,QACRA,SAAA,MAAQ,QACRA,SAAA,EAAI,OACJA,SAAA,IAAM,MACNA,SAAA,MAAQ,SACRA,SAAA,IAAM,SACNA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,EAAI,OACJA,SAAA,KAAO,SA1GGA,WAAAA,SAAA,CAAA"}

package/dist/Keyboard/Constants/KeyWatcherType.js

@@ -0,0 +1,2 @@
+var KeyWatcherType=(KeyWatcherType2=>(KeyWatcherType2.Combo="combo",KeyWatcherType2.Press="press",KeyWatcherType2.Release="release",KeyWatcherType2))(KeyWatcherType||{});export{KeyWatcherType};
+//# sourceMappingURL=KeyWatcherType.js.map

package/dist/Keyboard/Constants/KeyWatcherType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyWatcherType.js","sources":["../../../src/Keyboard/Constants/KeyWatcherType.ts"],"sourcesContent":["export enum KeyWatcherType {\n  Combo = 'combo',\n  Press = 'press',\n  Release = 'release'\n}\n"],"names":["KeyWatcherType"],"mappings":"AAAO,IAAKA,gBAAAA,kBACVA,gBAAA,MAAQ,QACRA,gBAAA,MAAQ,QACRA,gBAAA,QAAU,UAHAA,kBAAAA,gBAAA,CAAA"}

package/dist/Keyboard/Constants/KeyboardEventType.js

@@ -0,0 +1,2 @@
+var KeyboardEventType=(KeyboardEventType2=>(KeyboardEventType2.KeyDown="keydown",KeyboardEventType2.KeyUp="keyup",KeyboardEventType2))(KeyboardEventType||{});export{KeyboardEventType};
+//# sourceMappingURL=KeyboardEventType.js.map

package/dist/Keyboard/Constants/KeyboardEventType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardEventType.js","sources":["../../../src/Keyboard/Constants/KeyboardEventType.ts"],"sourcesContent":["export enum KeyboardEventType {\n  KeyDown = 'keydown',\n  KeyUp = 'keyup'\n}\n"],"names":["KeyboardEventType"],"mappings":"AAAO,IAAKA,mBAAAA,qBACVA,mBAAA,QAAU,UACVA,mBAAA,MAAQ,QAFEA,qBAAAA,mBAAA,CAAA"}

package/dist/Keyboard/Factories/KeyWatcherFactory.js

@@ -0,0 +1,2 @@
+import{KeyComboWatcher}from"../Watchers/KeyComboWatcher.js";import{KeyWatcherType}from"../Constants/KeyWatcherType.js";import{KeyPressWatcher}from"../Watchers/KeyPressWatcher.js";import{KeyReleaseWatcher}from"../Watchers/KeyReleaseWatcher.js";import{ReactiveFactory}from"../../Abstract/Factories/ReactiveFactory.js";import{FactoryType}from"../../Abstract/Constants/FactoryType.js";function create(params,deps){if(params.type===KeyWatcherType.Press)return KeyPressWatcher(params);if(params.type===KeyWatcherType.Release)return KeyReleaseWatcher(params);if(params.type===KeyWatcherType.Combo)return KeyComboWatcher(params,deps);throw new Error(`[KeyWatcherFactory]: Cannot create key watcher from params: unknown watcher type "${params.type}"`)}const KeyWatcherFactory=()=>ReactiveFactory(FactoryType.KeyWatcher,create);export{KeyWatcherFactory};
+//# sourceMappingURL=KeyWatcherFactory.js.map

package/dist/Keyboard/Factories/KeyWatcherFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyWatcherFactory.js","sources":["../../../src/Keyboard/Factories/KeyWatcherFactory.ts"],"sourcesContent":["import { FactoryType, ReactiveFactory } from '@Anarchy/Engine/Abstract';\nimport { KeyWatcherType } from '@Anarchy/Engine/Keyboard/Constants';\nimport type { TKeyComboWatcher, TKeyComboWatcherDependencies, TKeyComboWatcherParams, TKeyWatcher, TKeyWatcherFactory, TKeyWatcherParams } from '@Anarchy/Engine/Keyboard/Models';\nimport { KeyPressWatcher, KeyReleaseWatcher } from '@Anarchy/Engine/Keyboard/Watchers';\nimport { KeyComboWatcher } from '@Anarchy/Engine/Keyboard/Watchers/KeyComboWatcher';\n\nfunction create(params: TKeyWatcherParams | TKeyComboWatcherParams, deps?: TKeyComboWatcherDependencies): TKeyWatcher | TKeyComboWatcher | never {\n  if (params.type === KeyWatcherType.Press) return KeyPressWatcher(params as TKeyWatcherParams);\n  if (params.type === KeyWatcherType.Release) return KeyReleaseWatcher(params as TKeyWatcherParams);\n  if (params.type === KeyWatcherType.Combo) return KeyComboWatcher(params as TKeyComboWatcherParams, deps as TKeyComboWatcherDependencies);\n  else throw new Error(`[KeyWatcherFactory]: Cannot create key watcher from params: unknown watcher type \"${(params as any).type}\"`);\n}\n\nexport const KeyWatcherFactory = (): TKeyWatcherFactory => ReactiveFactory(FactoryType.KeyWatcher, create);\n"],"names":["create","params","deps","type","KeyWatcherType","Press","KeyPressWatcher","Release","KeyReleaseWatcher","Combo","KeyComboWatcher","Error","KeyWatcherFactory","ReactiveFactory","FactoryType","KeyWatcher"],"mappings":"6XAMA,SAASA,OAAOC,OAAoDC,MAClE,GAAID,OAAOE,OAASC,eAAeC,MAAO,OAAOC,gBAAgBL,QACjE,GAAIA,OAAOE,OAASC,eAAeG,QAAS,OAAOC,kBAAkBP,QACrE,GAAIA,OAAOE,OAASC,eAAeK,MAAO,OAAOC,gBAAgBT,OAAkCC,YACxF,IAAIS,MAAM,qFAAsFV,OAAeE,QAC5H,CAEO,MAAMS,kBAAoB,IAA0BC,gBAAgBC,YAAYC,WAAYf"}

package/dist/Keyboard/Registries/KeyWatcherRegistry.js

@@ -0,0 +1,2 @@
+import{AbstractWatcherRegistry}from"../../Abstract/Registries/AbstractWatcherRegistry.js";import{RegistryType}from"../../Abstract/Constants/RegistryType.js";function KeyWatcherRegistry(){return AbstractWatcherRegistry(RegistryType.KeyWatcher)}export{KeyWatcherRegistry};
+//# sourceMappingURL=KeyWatcherRegistry.js.map

package/dist/Keyboard/Registries/KeyWatcherRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyWatcherRegistry.js","sources":["../../../src/Keyboard/Registries/KeyWatcherRegistry.ts"],"sourcesContent":["import { RegistryType } from '@Anarchy/Engine/Abstract/Constants';\nimport { AbstractWatcherRegistry } from '@Anarchy/Engine/Abstract/Registries';\nimport type { TKeyComboWatcher, TKeyWatcher, TKeyWatcherRegistry } from '@Anarchy/Engine/Keyboard/Models';\n\nexport function KeyWatcherRegistry(): TKeyWatcherRegistry {\n  return AbstractWatcherRegistry<TKeyWatcher | TKeyComboWatcher>(RegistryType.KeyWatcher);\n}\n"],"names":["KeyWatcherRegistry","AbstractWatcherRegistry","RegistryType","KeyWatcher"],"mappings":"6JAIO,SAASA,qBACd,OAAOC,wBAAwDC,aAAaC,WAC9E"}

package/dist/Keyboard/Services/KeyboardService.js

@@ -0,0 +1,2 @@
+import{isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{WatcherTag}from"../../Abstract/Constants/WatcherTag.js";import{KeyWatcherType}from"../Constants/KeyWatcherType.js";import{AbstractService}from"../../Abstract/Services/AbstractService.js";function KeyboardService(container,keyWatcherFactory,keyWatcherRegistry){keyWatcherFactory.entityCreated$.subscribe(watcher=>keyWatcherRegistry.add(watcher));const element=container.getElement();isDefined(element?.tabIndex)&&element?.tabIndex<0&&(element.tabIndex=0);const tags=[WatcherTag.Initial,WatcherTag.Global],keyPressWatcher=keyWatcherFactory.create({type:KeyWatcherType.Press,container:container,tags:tags},void 0),keyReleaseWatcher=keyWatcherFactory.create({type:KeyWatcherType.Release,container:container,tags:tags},void 0),keyComboWatcher=keyWatcherFactory.create({type:KeyWatcherType.Combo,container:container,tags:tags},{keyPressWatcher:keyPressWatcher,keyReleaseWatcher:keyReleaseWatcher});keyComboWatcher.enabled$.next(!0),keyReleaseWatcher.enabled$.next(!0),keyPressWatcher.enabled$.next(!0);const abstractService=AbstractService([keyWatcherFactory,keyWatcherRegistry]),destroySub$=abstractService.destroy$.subscribe(()=>{destroySub$.unsubscribe(),keyWatcherRegistry.destroy$.next()});return Object.assign(abstractService,{keys$:keyComboWatcher.value$.asObservable(),currentKeys:keyComboWatcher.value$.value.keys,pressed$:keyPressWatcher.value$.asObservable(),released$:keyReleaseWatcher.value$.asObservable()})}export{KeyboardService};
+//# sourceMappingURL=KeyboardService.js.map

package/dist/Keyboard/Services/KeyboardService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardService.js","sources":["../../../src/Keyboard/Services/KeyboardService.ts"],"sourcesContent":["import type { TAbstractService } from '@Anarchy/Engine/Abstract';\nimport { AbstractService, WatcherTag } from '@Anarchy/Engine/Abstract';\nimport type { TContainerDecorator } from '@Anarchy/Engine/Global';\nimport { KeyWatcherType } from '@Anarchy/Engine/Keyboard/Constants';\nimport type { TKeyboardService, TKeyComboWatcher, TKeyWatcher, TKeyWatcherFactory, TKeyWatcherRegistry } from '@Anarchy/Engine/Keyboard/Models';\nimport { isDefined } from '@Anarchy/Shared/Utils';\nimport type { Subscription } from 'rxjs';\n\nexport function KeyboardService(container: TContainerDecorator, keyWatcherFactory: TKeyWatcherFactory, keyWatcherRegistry: TKeyWatcherRegistry): TKeyboardService {\n  keyWatcherFactory.entityCreated$.subscribe((watcher: TKeyWatcher | TKeyComboWatcher): void => keyWatcherRegistry.add(watcher));\n\n  // Only focusable elements can receive keyboard events\n  const element: HTMLElement = container.getElement() as HTMLElement;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(element?.tabIndex) && element?.tabIndex < 0) element.tabIndex = 0;\n\n  const tags: ReadonlyArray<WatcherTag | string> = [WatcherTag.Initial, WatcherTag.Global];\n  const keyPressWatcher: TKeyWatcher = keyWatcherFactory.create({ type: KeyWatcherType.Press, container, tags }, undefined) as TKeyWatcher;\n  const keyReleaseWatcher: TKeyWatcher = keyWatcherFactory.create({ type: KeyWatcherType.Release, container, tags }, undefined) as TKeyWatcher;\n  const keyComboWatcher: TKeyComboWatcher = keyWatcherFactory.create({ type: KeyWatcherType.Combo, container, tags }, { keyPressWatcher, keyReleaseWatcher }) as TKeyComboWatcher;\n\n  keyComboWatcher.enabled$.next(true);\n  keyReleaseWatcher.enabled$.next(true);\n  keyPressWatcher.enabled$.next(true);\n\n  const abstractService: TAbstractService = AbstractService([keyWatcherFactory, keyWatcherRegistry]);\n\n  const destroySub$: Subscription = abstractService.destroy$.subscribe((): void => {\n    destroySub$.unsubscribe();\n\n    keyWatcherRegistry.destroy$.next();\n  });\n\n  // eslint-disable-next-line functional/immutable-data\n  return Object.assign(abstractService, {\n    keys$: keyComboWatcher.value$.asObservable(),\n    currentKeys: keyComboWatcher.value$.value.keys,\n    pressed$: keyPressWatcher.value$.asObservable(),\n    released$: keyReleaseWatcher.value$.asObservable()\n  });\n}\n"],"names":["KeyboardService","container","keyWatcherFactory","keyWatcherRegistry","entityCreated$","subscribe","watcher","add","element","getElement","isDefined","tabIndex","tags","WatcherTag","Initial","Global","keyPressWatcher","create","type","KeyWatcherType","Press","keyReleaseWatcher","Release","keyComboWatcher","Combo","enabled$","next","abstractService","AbstractService","destroySub$","destroy$","unsubscribe","Object","assign","keys$","value$","asObservable","currentKeys","value","keys","pressed$","released$"],"mappings":"+QAQO,SAASA,gBAAgBC,UAAgCC,kBAAuCC,oBACrGD,kBAAkBE,eAAeC,UAAWC,SAAkDH,mBAAmBI,IAAID,UAGrH,MAAME,QAAuBP,UAAUQ,aAEnCC,UAAUF,SAASG,WAAaH,SAASG,SAAW,YAAWA,SAAW,GAE9E,MAAMC,KAA2C,CAACC,WAAWC,QAASD,WAAWE,QAC3EC,gBAA+Bd,kBAAkBe,OAAO,CAAEC,KAAMC,eAAeC,MAAOnB,oBAAWW,mBACjGS,kBAAiCnB,kBAAkBe,OAAO,CAAEC,KAAMC,eAAeG,QAASrB,oBAAWW,mBACrGW,gBAAoCrB,kBAAkBe,OAAO,CAAEC,KAAMC,eAAeK,MAAOvB,oBAAWW,WAAQ,CAAEI,gCAAiBK,sCAEvIE,gBAAgBE,SAASC,MAAK,GAC9BL,kBAAkBI,SAASC,MAAK,GAChCV,gBAAgBS,SAASC,MAAK,GAE9B,MAAMC,gBAAoCC,gBAAgB,CAAC1B,kBAAmBC,qBAExE0B,YAA4BF,gBAAgBG,SAASzB,UAAU,KACnEwB,YAAYE,cAEZ5B,mBAAmB2B,SAASJ,SAI9B,OAAOM,OAAOC,OAAON,gBAAiB,CACpCO,MAAOX,gBAAgBY,OAAOC,eAC9BC,YAAad,gBAAgBY,OAAOG,MAAMC,KAC1CC,SAAUxB,gBAAgBmB,OAAOC,eACjCK,UAAWpB,kBAAkBc,OAAOC,gBAExC"}

package/dist/Keyboard/Utils/KeysRxJsUtils.js

@@ -0,0 +1,2 @@
+import{hasKeys,hasKey,isKeyInEvent}from"./KeysUtils.js";import{filter}from"../../node_modules/rxjs/dist/esm5/internal/operators/filter.js";const onKeysCombo=keys=>source=>source.pipe(filter(keyEvent=>hasKeys(keys,keyEvent.keys))),onKey=key=>source=>source.pipe(filter(keyEvent=>hasKey(key,keyEvent.keys))),onKeyReleased=key=>source=>source.pipe(filter(keyEvent=>isKeyInEvent(key,keyEvent)&&keyEvent.released===key));export{onKey,onKeyReleased,onKeysCombo};
+//# sourceMappingURL=KeysRxJsUtils.js.map

package/dist/Keyboard/Utils/KeysRxJsUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeysRxJsUtils.js","sources":["../../../src/Keyboard/Utils/KeysRxJsUtils.ts"],"sourcesContent":["import type { TGameKey, TKeyEvent } from '@Anarchy/Engine/Keyboard/Models';\nimport { hasKey, hasKeys } from '@Anarchy/Engine/Keyboard/Utils/KeysUtils';\nimport type { Observable, OperatorFunction } from 'rxjs';\nimport { filter } from 'rxjs';\n\nimport { isKeyInEvent } from './KeysUtils';\n\nexport const onKeysCombo = (keys: ReadonlyArray<TGameKey>): OperatorFunction<TKeyEvent, TKeyEvent> => {\n  return (source: Observable<TKeyEvent>): Observable<TKeyEvent> => source.pipe(filter((keyEvent: TKeyEvent): boolean => hasKeys(keys, keyEvent.keys)));\n};\n\nexport const onKey = (key: TGameKey): OperatorFunction<TKeyEvent, TKeyEvent> => {\n  return (source: Observable<TKeyEvent>): Observable<TKeyEvent> => source.pipe(filter((keyEvent: TKeyEvent): boolean => hasKey(key, keyEvent.keys)));\n};\n\nexport const onKeyReleased = (key: TGameKey): OperatorFunction<TKeyEvent, TKeyEvent> => {\n  return (source: Observable<TKeyEvent>): Observable<TKeyEvent> => source.pipe(filter((keyEvent: TKeyEvent): boolean => isKeyInEvent(key, keyEvent) && keyEvent.released === key));\n};\n"],"names":["onKeysCombo","keys","source","pipe","filter","keyEvent","hasKeys","onKey","key","hasKey","onKeyReleased","isKeyInEvent","released"],"mappings":"2IAOO,MAAMA,YAAeC,MAClBC,QAAyDA,OAAOC,KAAKC,OAAQC,UAAiCC,QAAQL,KAAMI,SAASJ,QAGlIM,MAASC,KACZN,QAAyDA,OAAOC,KAAKC,OAAQC,UAAiCI,OAAOD,IAAKH,SAASJ,QAGhIS,cAAiBF,KACpBN,QAAyDA,OAAOC,KAAKC,OAAQC,UAAiCM,aAAaH,IAAKH,WAAaA,SAASO,WAAaJ"}

package/dist/Keyboard/Utils/KeysUtils.js

@@ -0,0 +1,2 @@
+import{isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";const hasKey=(key,keys)=>keys.has(key),hasNoKey=(key,keys)=>!hasKey(key,keys),isKeyInEvent=(key,keyEvent)=>Boolean(keyEvent&&keyEvent.event?.code===key),isPressEvent=keyEvent=>isDefined(keyEvent.pressed),isReleaseEvent=keyEvent=>isDefined(keyEvent.released);function hasKeys(keys,pressedKeys){for(const key of keys)if(!hasKey(key,pressedKeys))return!1;return!0}export{hasKey,hasKeys,hasNoKey,isKeyInEvent,isPressEvent,isReleaseEvent};
+//# sourceMappingURL=KeysUtils.js.map

package/dist/Keyboard/Utils/KeysUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeysUtils.js","sources":["../../../src/Keyboard/Utils/KeysUtils.ts"],"sourcesContent":["import type { TGameKey, TKeyEvent, TKeysCombo } from '@Anarchy/Engine/Keyboard/Models';\nimport { isDefined } from '@Anarchy/Shared/Utils';\n\nexport const hasKey = (key: TGameKey, keys: TKeysCombo): boolean => keys.has(key);\nexport const hasNoKey = (key: TGameKey, keys: TKeysCombo): boolean => !hasKey(key, keys);\nexport const isKeyInEvent = (key: TGameKey, keyEvent: TKeyEvent | undefined): boolean => Boolean(keyEvent && keyEvent.event?.code === key);\nexport const isPressEvent = (keyEvent: TKeyEvent): boolean => isDefined(keyEvent.pressed);\nexport const isReleaseEvent = (keyEvent: TKeyEvent): boolean => isDefined(keyEvent.released);\n\nexport function hasKeys(keys: ReadonlyArray<TGameKey>, pressedKeys: TKeysCombo): boolean {\n  // eslint-disable-next-line functional/no-loop-statements\n  for (const key of keys) {\n    if (!hasKey(key, pressedKeys)) return false;\n  }\n  return true;\n}\n"],"names":["hasKey","key","keys","has","hasNoKey","isKeyInEvent","keyEvent","Boolean","event","code","isPressEvent","isDefined","pressed","isReleaseEvent","released","hasKeys","pressedKeys"],"mappings":"6EAGO,MAAMA,OAAS,CAACC,IAAeC,OAA8BA,KAAKC,IAAIF,KAChEG,SAAW,CAACH,IAAeC,QAA+BF,OAAOC,IAAKC,MACtEG,aAAe,CAACJ,IAAeK,WAA6CC,QAAQD,UAAYA,SAASE,OAAOC,OAASR,KACzHS,aAAgBJ,UAAiCK,UAAUL,SAASM,SACpEC,eAAkBP,UAAiCK,UAAUL,SAASQ,UAE5E,SAASC,QAAQb,KAA+Bc,aAErD,IAAA,MAAWf,OAAOC,KAChB,IAAKF,OAAOC,IAAKe,aAAc,OAAO,EAExC,OAAO,CACT"}

package/dist/Keyboard/Watchers/KeyComboWatcher.js

@@ -0,0 +1,2 @@
+import{AbstractWatcherWithState}from"../../Abstract/Watchers/AbstractWatcherWithState.js";import{distinctUntilChanged}from"../../node_modules/rxjs/dist/esm5/internal/operators/distinctUntilChanged.js";import{takeUntil}from"../../node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js";import{WatcherType}from"../../Abstract/Constants/WatcherType.js";import{ContainerEvents}from"../../Global/Constants/ContainerEvents.js";function KeyComboWatcher({container:container,tags:tags},{keyPressWatcher:keyPressWatcher,keyReleaseWatcher:keyReleaseWatcher}){const keys=new Set,watcher=AbstractWatcherWithState(WatcherType.KeyPressWatcher,"key_combo_watcher",{keys:keys},tags);function onPress(event){keys.has(event.code)||(keys.add(event.code),watcher.value$.next({keys:keys,pressed:event.code,event:event}))}function onRelease(event){keys.has(event.code)&&(keys.delete(event.code),watcher.value$.next({keys:keys,released:event.code,event:event}))}const releaseAllKeys=()=>watcher.value$.value.keys.forEach(key=>onRelease({code:key}));let pressSub$,releaseSub$;container.startWatch(ContainerEvents.Blur,releaseAllKeys),watcher.enabled$.pipe(distinctUntilChanged(),takeUntil(watcher.destroy$)).subscribe(value=>{value?container.startWatch(ContainerEvents.Blur,releaseAllKeys):container.stopWatch(ContainerEvents.Blur,releaseAllKeys)}),watcher.enabled$.pipe(distinctUntilChanged(),takeUntil(watcher.destroy$)).subscribe(value=>{value?(pressSub$=keyPressWatcher.value$.subscribe(onPress),releaseSub$=keyReleaseWatcher.value$.subscribe(onRelease)):(pressSub$?.unsubscribe(),releaseSub$?.unsubscribe())});const destroySub$=watcher.destroy$.subscribe(()=>{keys.clear(),destroySub$.unsubscribe()});return watcher}export{KeyComboWatcher};
+//# sourceMappingURL=KeyComboWatcher.js.map

package/dist/Keyboard/Watchers/KeyComboWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyComboWatcher.js","sources":["../../../src/Keyboard/Watchers/KeyComboWatcher.ts"],"sourcesContent":["import type { TAbstractWatcherWithState } from '@Anarchy/Engine/Abstract';\nimport { AbstractWatcherWithState, WatcherType } from '@Anarchy/Engine/Abstract';\nimport { ContainerEvents } from '@Anarchy/Engine/Global';\nimport type { TGameKey, TKeyComboWatcher, TKeyComboWatcherDependencies, TKeyComboWatcherParams, TKeyEvent, TKeysCombo } from '@Anarchy/Engine/Keyboard/Models';\nimport type { Subscription } from 'rxjs';\nimport { distinctUntilChanged, takeUntil } from 'rxjs';\n\nexport function KeyComboWatcher({ container, tags }: TKeyComboWatcherParams, { keyPressWatcher, keyReleaseWatcher }: TKeyComboWatcherDependencies): TKeyComboWatcher {\n  const keys: TKeysCombo = new Set<TGameKey>();\n  const watcher: TAbstractWatcherWithState<TKeyEvent> = AbstractWatcherWithState(WatcherType.KeyPressWatcher, 'key_combo_watcher', { keys }, tags);\n\n  function onPress(event: KeyboardEvent): void {\n    if (keys.has(event.code as TGameKey)) return;\n    (keys as Set<TGameKey>).add(event.code as TGameKey);\n    watcher.value$.next({ keys, pressed: event.code as TGameKey, event });\n  }\n\n  function onRelease(event: KeyboardEvent): void {\n    if (!keys.has(event.code as TGameKey)) return;\n\n    (keys as Set<TGameKey>).delete(event.code as TGameKey);\n    watcher.value$.next({ keys, released: event.code as TGameKey, event });\n  }\n\n  //When focus leave the container, release all keys\n  const releaseAllKeys = (): void => watcher.value$.value.keys.forEach((key: TGameKey): void => onRelease({ code: key } as KeyboardEvent));\n  container.startWatch(ContainerEvents.Blur, releaseAllKeys);\n\n  watcher.enabled$.pipe(distinctUntilChanged(), takeUntil(watcher.destroy$)).subscribe((value: boolean): void => {\n    if (value) {\n      container.startWatch(ContainerEvents.Blur, releaseAllKeys);\n    } else {\n      container.stopWatch(ContainerEvents.Blur, releaseAllKeys);\n    }\n  });\n\n  let pressSub$: Subscription | undefined;\n  let releaseSub$: Subscription | undefined;\n\n  watcher.enabled$.pipe(distinctUntilChanged(), takeUntil(watcher.destroy$)).subscribe((value: boolean): void => {\n    if (value) {\n      pressSub$ = keyPressWatcher.value$.subscribe(onPress);\n      releaseSub$ = keyReleaseWatcher.value$.subscribe(onRelease);\n    } else {\n      pressSub$?.unsubscribe();\n      releaseSub$?.unsubscribe();\n    }\n  });\n\n  const destroySub$: Subscription = watcher.destroy$.subscribe((): void => {\n    (keys as Set<TGameKey>).clear();\n    destroySub$.unsubscribe();\n  });\n\n  return watcher;\n}\n"],"names":["KeyComboWatcher","container","tags","keyPressWatcher","keyReleaseWatcher","keys","Set","watcher","AbstractWatcherWithState","WatcherType","KeyPressWatcher","onPress","event","has","code","add","value$","next","pressed","onRelease","delete","released","releaseAllKeys","value","forEach","key","pressSub$","releaseSub$","startWatch","ContainerEvents","Blur","enabled$","pipe","distinctUntilChanged","takeUntil","destroy$","subscribe","stopWatch","unsubscribe","destroySub$","clear"],"mappings":"0aAOO,SAASA,iBAAgBC,UAAEA,UAAAC,KAAWA,OAAgCC,gBAAEA,gBAAAC,kBAAiBA,oBAC9F,MAAMC,SAAuBC,IACvBC,QAAgDC,yBAAyBC,YAAYC,gBAAiB,oBAAqB,CAAEL,WAAQH,MAE3I,SAASS,QAAQC,OACXP,KAAKQ,IAAID,MAAME,QAClBT,KAAuBU,IAAIH,MAAME,MAClCP,QAAQS,OAAOC,KAAK,CAAEZ,UAAMa,QAASN,MAAME,KAAkBF,cAC/D,CAEA,SAASO,UAAUP,OACZP,KAAKQ,IAAID,MAAME,QAEnBT,KAAuBe,OAAOR,MAAME,MACrCP,QAAQS,OAAOC,KAAK,CAAEZ,UAAMgB,SAAUT,MAAME,KAAkBF,cAChE,CAGA,MAAMU,eAAiB,IAAYf,QAAQS,OAAOO,MAAMlB,KAAKmB,QAASC,KAAwBN,UAAU,CAAEL,KAAMW,OAWhH,IAAIC,UACAC,YAXJ1B,UAAU2B,WAAWC,gBAAgBC,KAAMR,gBAE3Cf,QAAQwB,SAASC,KAAKC,uBAAwBC,UAAU3B,QAAQ4B,WAAWC,UAAWb,QAChFA,MACFtB,UAAU2B,WAAWC,gBAAgBC,KAAMR,gBAE3CrB,UAAUoC,UAAUR,gBAAgBC,KAAMR,kBAO9Cf,QAAQwB,SAASC,KAAKC,uBAAwBC,UAAU3B,QAAQ4B,WAAWC,UAAWb,QAChFA,OACFG,UAAYvB,gBAAgBa,OAAOoB,UAAUzB,SAC7CgB,YAAcvB,kBAAkBY,OAAOoB,UAAUjB,aAEjDO,WAAWY,cACXX,aAAaW,iBAIjB,MAAMC,YAA4BhC,QAAQ4B,SAASC,UAAU,KAC1D/B,KAAuBmC,QACxBD,YAAYD,gBAGd,OAAO/B,OACT"}

package/dist/Keyboard/Watchers/KeyPressWatcher.js

@@ -0,0 +1,2 @@
+import{distinctUntilChanged}from"../../node_modules/rxjs/dist/esm5/internal/operators/distinctUntilChanged.js";import{takeUntil}from"../../node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js";import{KeyboardEventType}from"../Constants/KeyboardEventType.js";import{AbstractWatcher}from"../../Abstract/Watchers/AbstractWatcher.js";import{WatcherType}from"../../Abstract/Constants/WatcherType.js";function KeyPressWatcher({container:container,tags:tags}){const abstractWatcher=AbstractWatcher(WatcherType.KeyPressWatcher,"key_press_watcher",tags);function onChange(event){event.repeat||function(target){if(!(target instanceof HTMLElement))return!1;const tag=target.tagName.toLowerCase();return"input"===tag||"textarea"===tag||"select"===tag||!!target.isContentEditable}(event.target)||abstractWatcher.value$.next(event)}return abstractWatcher.enabled$.pipe(distinctUntilChanged(),takeUntil(abstractWatcher.destroy$)).subscribe(value=>{value?container.startWatch(KeyboardEventType.KeyDown,onChange):container.stopWatch(KeyboardEventType.KeyDown,onChange)}),abstractWatcher}export{KeyPressWatcher};
+//# sourceMappingURL=KeyPressWatcher.js.map

package/dist/Keyboard/Watchers/KeyPressWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyPressWatcher.js","sources":["../../../src/Keyboard/Watchers/KeyPressWatcher.ts"],"sourcesContent":["import type { TAbstractWatcher } from '@Anarchy/Engine/Abstract';\nimport { AbstractWatcher, WatcherType } from '@Anarchy/Engine/Abstract';\nimport { KeyboardEventType } from '@Anarchy/Engine/Keyboard/Constants';\nimport type { TKeyWatcher, TKeyWatcherParams } from '@Anarchy/Engine/Keyboard/Models';\nimport { distinctUntilChanged, takeUntil } from 'rxjs';\n\nexport function KeyPressWatcher({ container, tags }: TKeyWatcherParams): TKeyWatcher {\n  const abstractWatcher: TAbstractWatcher<KeyboardEvent> = AbstractWatcher(WatcherType.KeyPressWatcher, 'key_press_watcher', tags);\n\n  function onChange(event: KeyboardEvent): void {\n    if (event.repeat) return;\n    if (isTextInputTarget(event.target)) return;\n    abstractWatcher.value$.next(event);\n  }\n\n  abstractWatcher.enabled$.pipe(distinctUntilChanged(), takeUntil(abstractWatcher.destroy$)).subscribe((value: boolean): void => {\n    if (value) {\n      container.startWatch(KeyboardEventType.KeyDown, onChange);\n    } else {\n      container.stopWatch(KeyboardEventType.KeyDown, onChange);\n    }\n  });\n\n  function isTextInputTarget(target: EventTarget | null | undefined): boolean {\n    if (!(target instanceof HTMLElement)) return false;\n    const tag: string = target.tagName.toLowerCase();\n    if (tag === 'input' || tag === 'textarea' || tag === 'select') return true;\n    if (target.isContentEditable) return true;\n\n    return false;\n  }\n\n  return abstractWatcher;\n}\n"],"names":["KeyPressWatcher","container","tags","abstractWatcher","AbstractWatcher","WatcherType","onChange","event","repeat","target","HTMLElement","tag","tagName","toLowerCase","isContentEditable","isTextInputTarget","value$","next","enabled$","pipe","distinctUntilChanged","takeUntil","destroy$","subscribe","value","startWatch","KeyboardEventType","KeyDown","stopWatch"],"mappings":"kZAMO,SAASA,iBAAgBC,UAAEA,UAAAC,KAAWA,OAC3C,MAAMC,gBAAmDC,gBAAgBC,YAAYL,gBAAiB,oBAAqBE,MAE3H,SAASI,SAASC,OACZA,MAAMC,QAaZ,SAA2BC,QACzB,KAAMA,kBAAkBC,aAAc,OAAO,EAC7C,MAAMC,IAAcF,OAAOG,QAAQC,cACnC,MAAY,UAARF,KAA2B,aAARA,KAA8B,WAARA,OACzCF,OAAOK,iBAGb,CAnBMC,CAAkBR,MAAME,SAC5BN,gBAAgBa,OAAOC,KAAKV,MAC9B,CAmBA,OAjBAJ,gBAAgBe,SAASC,KAAKC,uBAAwBC,UAAUlB,gBAAgBmB,WAAWC,UAAWC,QAChGA,MACFvB,UAAUwB,WAAWC,kBAAkBC,QAASrB,UAEhDL,UAAU2B,UAAUF,kBAAkBC,QAASrB,YAa5CH,eACT"}

package/dist/Keyboard/Watchers/KeyReleaseWatcher.js

@@ -0,0 +1,2 @@
+import{distinctUntilChanged}from"../../node_modules/rxjs/dist/esm5/internal/operators/distinctUntilChanged.js";import{takeUntil}from"../../node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js";import{AbstractWatcher}from"../../Abstract/Watchers/AbstractWatcher.js";import{WatcherType}from"../../Abstract/Constants/WatcherType.js";import{KeyboardEventType}from"../Constants/KeyboardEventType.js";function KeyReleaseWatcher({container:container,tags:tags}){const abstractWatcher=AbstractWatcher(WatcherType.KeyReleaseWatcher,"key_release_watcher",tags),onChange=event=>abstractWatcher.value$.next(event);return abstractWatcher.enabled$.pipe(distinctUntilChanged(),takeUntil(abstractWatcher.destroy$)).subscribe(value=>{value?container.startWatch(KeyboardEventType.KeyUp,onChange):container.stopWatch(KeyboardEventType.KeyUp,onChange)}),abstractWatcher}export{KeyReleaseWatcher};
+//# sourceMappingURL=KeyReleaseWatcher.js.map

package/dist/Keyboard/Watchers/KeyReleaseWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyReleaseWatcher.js","sources":["../../../src/Keyboard/Watchers/KeyReleaseWatcher.ts"],"sourcesContent":["import type { TAbstractWatcher } from '@Anarchy/Engine/Abstract';\nimport { AbstractWatcher, WatcherType } from '@Anarchy/Engine/Abstract';\nimport { KeyboardEventType } from '@Anarchy/Engine/Keyboard/Constants';\nimport type { TKeyWatcher, TKeyWatcherParams } from '@Anarchy/Engine/Keyboard/Models';\nimport { distinctUntilChanged, takeUntil } from 'rxjs';\n\nexport function KeyReleaseWatcher({ container, tags }: TKeyWatcherParams): TKeyWatcher {\n  const abstractWatcher: TAbstractWatcher<KeyboardEvent> = AbstractWatcher(WatcherType.KeyReleaseWatcher, 'key_release_watcher', tags);\n\n  const onChange = (event: KeyboardEvent): void => abstractWatcher.value$.next(event);\n\n  abstractWatcher.enabled$.pipe(distinctUntilChanged(), takeUntil(abstractWatcher.destroy$)).subscribe((value: boolean): void => {\n    if (value) {\n      container.startWatch(KeyboardEventType.KeyUp, onChange);\n    } else {\n      container.stopWatch(KeyboardEventType.KeyUp, onChange);\n    }\n  });\n\n  return abstractWatcher;\n}\n"],"names":["KeyReleaseWatcher","container","tags","abstractWatcher","AbstractWatcher","WatcherType","onChange","event","value$","next","enabled$","pipe","distinctUntilChanged","takeUntil","destroy$","subscribe","value","startWatch","KeyboardEventType","KeyUp","stopWatch"],"mappings":"kZAMO,SAASA,mBAAkBC,UAAEA,UAAAC,KAAWA,OAC7C,MAAMC,gBAAmDC,gBAAgBC,YAAYL,kBAAmB,sBAAuBE,MAEzHI,SAAYC,OAA+BJ,gBAAgBK,OAAOC,KAAKF,OAU7E,OARAJ,gBAAgBO,SAASC,KAAKC,uBAAwBC,UAAUV,gBAAgBW,WAAWC,UAAWC,QAChGA,MACFf,UAAUgB,WAAWC,kBAAkBC,MAAOb,UAE9CL,UAAUmB,UAAUF,kBAAkBC,MAAOb,YAI1CH,eACT"}

package/dist/Kinematic/Adapters/ConfigToParams.js

@@ -0,0 +1,2 @@
+import{isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{Quaternion,Vector3}from"three";import{toQuaternion}from"../../Math/Utils/AnglesUtils.js";function configToParams(config){const{state:state,target:target,...rest}=config,{linearDirection:linearDirection,angularDirection:angularDirection,...stateRest}=state??{},{positionThreshold:positionThreshold,position:position,rotationThreshold:rotationThreshold,rotation:rotation,...targetRest}=target??{};return{...rest,state:{...stateRest,linearDirection:isDefined(linearDirection)?new Vector3(linearDirection.x,linearDirection.y,linearDirection.z):new Vector3,angularDirection:isDefined(angularDirection)?toQuaternion(angularDirection):void 0},target:{...targetRest,positionThreshold:positionThreshold??.01,position:isDefined(position)?new Vector3(position.x,position.y,position.z):new Vector3,rotationThreshold:rotationThreshold??1e-4,rotation:isDefined(rotation)?new Quaternion(rotation.x,rotation.y,rotation.z,rotation.w):new Quaternion}}}export{configToParams};
+//# sourceMappingURL=ConfigToParams.js.map

package/dist/Kinematic/Adapters/ConfigToParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigToParams.js","sources":["../../../src/Kinematic/Adapters/ConfigToParams.ts"],"sourcesContent":["import type { TKinematicConfig, TKinematicParams } from '@Anarchy/Engine/Kinematic/Models';\nimport { toQuaternion } from '@Anarchy/Engine/Math';\nimport { isDefined } from '@Anarchy/Shared/Utils';\nimport { Quaternion, Vector3 } from 'three';\n\nexport function configToParams(config: TKinematicConfig): TKinematicParams {\n  const { state, target, ...rest } = config;\n  const { linearDirection, angularDirection, ...stateRest } = state ?? {};\n  const { positionThreshold, position, rotationThreshold, rotation, ...targetRest } = target ?? {};\n\n  return {\n    ...rest,\n    state: {\n      ...stateRest,\n      linearDirection: isDefined(linearDirection) ? new Vector3(linearDirection.x, linearDirection.y, linearDirection.z) : new Vector3(),\n      angularDirection: isDefined(angularDirection) ? toQuaternion(angularDirection) : undefined\n    },\n    target: {\n      ...targetRest,\n      positionThreshold: positionThreshold ?? 0.01,\n      position: isDefined(position) ? new Vector3(position.x, position.y, position.z) : new Vector3(),\n      rotationThreshold: rotationThreshold ?? 0.0001, // 0.0001 rad = 0.0057 deg\n      rotation: isDefined(rotation) ? new Quaternion(rotation.x, rotation.y, rotation.z, rotation.w) : new Quaternion()\n    }\n  };\n}\n"],"names":["configToParams","config","state","target","rest","linearDirection","angularDirection","stateRest","positionThreshold","position","rotationThreshold","rotation","targetRest","isDefined","Vector3","x","y","z","toQuaternion","Quaternion","w"],"mappings":"6KAKO,SAASA,eAAeC,QAC7B,MAAMC,MAAEA,MAAAC,OAAOA,UAAWC,MAASH,QAC7BI,gBAAEA,gBAAAC,iBAAiBA,oBAAqBC,WAAcL,OAAS,CAAA,GAC/DM,kBAAEA,2BAAmBC,SAAAC,kBAAUA,kBAAAC,SAAmBA,YAAaC,YAAeT,QAAU,CAAA,EAE9F,MAAO,IACFC,KACHF,MAAO,IACFK,UACHF,gBAAiBQ,UAAUR,iBAAmB,IAAIS,QAAQT,gBAAgBU,EAAGV,gBAAgBW,EAAGX,gBAAgBY,GAAK,IAAIH,QACzHR,iBAAkBO,UAAUP,kBAAoBY,aAAaZ,uBAAoB,GAEnFH,OAAQ,IACHS,WACHJ,kBAAmBA,mBAAqB,IACxCC,SAAUI,UAAUJ,UAAY,IAAIK,QAAQL,SAASM,EAAGN,SAASO,EAAGP,SAASQ,GAAK,IAAIH,QACtFJ,kBAAmBA,mBAAqB,KACxCC,SAAUE,UAAUF,UAAY,IAAIQ,WAAWR,SAASI,EAAGJ,SAASK,EAAGL,SAASM,EAAGN,SAASS,GAAK,IAAID,YAG3G"}

package/dist/Kinematic/Adapters/EntityToConfig.js

@@ -0,0 +1,2 @@
+import{isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{filterOutEmptyFields}from"../../packages/anarchy-shared/src/Utils/ObjectUtils.js";import{Euler}from"three";import{quaternionToXyzw,vector3ToXyz,eulerToXyz}from"../../Utils/TransformUtils.js";function kinematicToConfig(entity){const{linearSpeed:linearSpeed,linearDirection:linearDirection,angularSpeed:angularSpeed,angularDirection:angularDirection,radius:radius,forwardAxis:forwardAxis,isInfiniteRotation:isInfiniteRotation}=entity.data.state;let target;return isDefined(entity.data.target)&&(target=filterOutEmptyFields({position:isDefined(entity.data.target.position)?vector3ToXyz(entity.data.target.position):void 0,rotation:isDefined(entity.data.target.rotation)?quaternionToXyzw(entity.data.target.rotation):void 0,positionThreshold:entity.data.target.positionThreshold,rotationThreshold:entity.data.target.rotationThreshold})),filterOutEmptyFields({isAutoUpdate:entity.autoUpdate$.value,target:target,state:{linearSpeed:linearSpeed,linearDirection:vector3ToXyz(linearDirection),angularSpeed:angularSpeed,angularDirection:eulerToXyz((new Euler).setFromQuaternion(angularDirection)),radius:radius,forwardAxis:forwardAxis,isInfiniteRotation:isInfiniteRotation}})}export{kinematicToConfig};
+//# sourceMappingURL=EntityToConfig.js.map

package/dist/Kinematic/Adapters/EntityToConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityToConfig.js","sources":["../../../src/Kinematic/Adapters/EntityToConfig.ts"],"sourcesContent":["import type { TKinematicConfig, TKinematicConfigTarget } from '@Anarchy/Engine/Kinematic/Models';\nimport type { TKinematicTransformAgent } from '@Anarchy/Engine/TransformDrive';\nimport { eulerToXyz, quaternionToXyzw, vector3ToXyz } from '@Anarchy/Engine/Utils';\nimport { filterOutEmptyFields, isDefined } from '@Anarchy/Shared/Utils';\nimport { Euler } from 'three';\n\nexport function kinematicToConfig(entity: TKinematicTransformAgent): TKinematicConfig {\n  const { linearSpeed, linearDirection, angularSpeed, angularDirection, radius, forwardAxis, isInfiniteRotation } = entity.data.state;\n\n  let target: TKinematicConfigTarget | undefined = undefined;\n  if (isDefined(entity.data.target)) {\n    target = filterOutEmptyFields({\n      position: isDefined(entity.data.target.position) ? vector3ToXyz(entity.data.target.position) : undefined,\n      rotation: isDefined(entity.data.target.rotation) ? quaternionToXyzw(entity.data.target.rotation) : undefined,\n      positionThreshold: entity.data.target.positionThreshold,\n      rotationThreshold: entity.data.target.rotationThreshold\n    });\n  }\n\n  return filterOutEmptyFields({\n    isAutoUpdate: entity.autoUpdate$.value,\n    target,\n    state: {\n      linearSpeed,\n      linearDirection: vector3ToXyz(linearDirection),\n      angularSpeed,\n      angularDirection: eulerToXyz(new Euler().setFromQuaternion(angularDirection)),\n      radius,\n      forwardAxis,\n      isInfiniteRotation\n    }\n  });\n}\n"],"names":["kinematicToConfig","entity","linearSpeed","linearDirection","angularSpeed","angularDirection","radius","forwardAxis","isInfiniteRotation","data","state","target","isDefined","filterOutEmptyFields","position","vector3ToXyz","rotation","quaternionToXyzw","positionThreshold","rotationThreshold","isAutoUpdate","autoUpdate$","value","eulerToXyz","Euler","setFromQuaternion"],"mappings":"mRAMO,SAASA,kBAAkBC,QAChC,MAAMC,YAAEA,YAAAC,gBAAaA,gBAAAC,aAAiBA,aAAAC,iBAAcA,iBAAAC,OAAkBA,mBAAQC,YAAAC,mBAAaA,oBAAuBP,OAAOQ,KAAKC,MAE9H,IAAIC,OAUJ,OATIC,UAAUX,OAAOQ,KAAKE,UACxBA,OAASE,qBAAqB,CAC5BC,SAAUF,UAAUX,OAAOQ,KAAKE,OAAOG,UAAYC,aAAad,OAAOQ,KAAKE,OAAOG,eAAY,EAC/FE,SAAUJ,UAAUX,OAAOQ,KAAKE,OAAOK,UAAYC,iBAAiBhB,OAAOQ,KAAKE,OAAOK,eAAY,EACnGE,kBAAmBjB,OAAOQ,KAAKE,OAAOO,kBACtCC,kBAAmBlB,OAAOQ,KAAKE,OAAOQ,qBAInCN,qBAAqB,CAC1BO,aAAcnB,OAAOoB,YAAYC,MACjCX,cACAD,MAAO,CACLR,wBACAC,gBAAiBY,aAAaZ,iBAC9BC,0BACAC,iBAAkBkB,YAAW,IAAIC,OAAQC,kBAAkBpB,mBAC3DC,cACAC,wBACAC,wCAGN"}

package/dist/Kinematic/Constants/ForwardAxis.js

@@ -0,0 +1,2 @@
+var ForwardAxis=(ForwardAxis2=>(ForwardAxis2.X="X",ForwardAxis2.Z="Z",ForwardAxis2))(ForwardAxis||{});export{ForwardAxis};
+//# sourceMappingURL=ForwardAxis.js.map

package/dist/Kinematic/Constants/ForwardAxis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForwardAxis.js","sources":["../../../src/Kinematic/Constants/ForwardAxis.ts"],"sourcesContent":["export enum ForwardAxis {\n  X = 'X',\n  Z = 'Z'\n}\n"],"names":["ForwardAxis"],"mappings":"AAAO,IAAKA,aAAAA,eACVA,aAAA,EAAI,IACJA,aAAA,EAAI,IAFMA,eAAAA,aAAA,CAAA"}

package/dist/Kinematic/Constants/KinematicConstants.js

@@ -0,0 +1,2 @@
+import{vector3ToXyz,eulerToXyz}from"../../Utils/TransformUtils.js";import{Quaternion,Vector3,Euler}from"three";import{ForwardAxis}from"./ForwardAxis.js";var KinematicSpeed=(KinematicSpeed2=>(KinematicSpeed2.Instant="instant",KinematicSpeed2))(KinematicSpeed||{});const DEFAULT_RADIUS=.001,DefaultKinematicState={linearSpeed:0,linearDirection:new Vector3,angularSpeed:0,radius:.001,angularDirection:new Quaternion,forwardAxis:ForwardAxis.X,isInfiniteRotation:!1},DefaultKinematicConfigState={...DefaultKinematicState,angularDirection:eulerToXyz((new Euler).setFromQuaternion(DefaultKinematicState.angularDirection)),linearDirection:vector3ToXyz(DefaultKinematicState.linearDirection)},DefaultKinematicTarget={positionThreshold:.01,position:void 0,rotationThreshold:1e-4,rotation:void 0},DefaultIsAutoUpdate=!0;export{DEFAULT_RADIUS,DefaultIsAutoUpdate,DefaultKinematicConfigState,DefaultKinematicState,DefaultKinematicTarget,KinematicSpeed};
+//# sourceMappingURL=KinematicConstants.js.map

package/dist/Kinematic/Constants/KinematicConstants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KinematicConstants.js","sources":["../../../src/Kinematic/Constants/KinematicConstants.ts"],"sourcesContent":["import type { TKinematicConfigState, TKinematicState, TKinematicTarget } from '@Anarchy/Engine/Kinematic/Models';\nimport type { TMeters } from '@Anarchy/Engine/Math';\nimport { eulerToXyz, vector3ToXyz } from '@Anarchy/Engine/Utils/TransformUtils';\nimport { Euler, Quaternion, Vector3 } from 'three';\n\nimport { ForwardAxis } from './ForwardAxis';\n\nexport enum KinematicSpeed {\n  Instant = 'instant'\n}\n\nexport const DEFAULT_RADIUS: TMeters = 1e-3 as TMeters; // 1 millimeter\n\nexport const DefaultKinematicState: TKinematicState = {\n  linearSpeed: 0,\n  linearDirection: new Vector3(),\n  angularSpeed: 0,\n  radius: DEFAULT_RADIUS,\n  angularDirection: new Quaternion(),\n  forwardAxis: ForwardAxis.X,\n  isInfiniteRotation: false\n};\n\nexport const DefaultKinematicConfigState: TKinematicConfigState = {\n  ...DefaultKinematicState,\n  angularDirection: eulerToXyz(new Euler().setFromQuaternion(DefaultKinematicState.angularDirection)),\n  linearDirection: vector3ToXyz(DefaultKinematicState.linearDirection)\n};\n\nexport const DefaultKinematicTarget: TKinematicTarget = {\n  positionThreshold: 0.01,\n  position: undefined,\n  rotationThreshold: 0.0001,\n  rotation: undefined\n};\n\nexport const DefaultIsAutoUpdate: boolean = true;\n"],"names":["KinematicSpeed","DEFAULT_RADIUS","DefaultKinematicState","linearSpeed","linearDirection","Vector3","angularSpeed","radius","angularDirection","Quaternion","forwardAxis","ForwardAxis","X","isInfiniteRotation","DefaultKinematicConfigState","eulerToXyz","Euler","setFromQuaternion","vector3ToXyz","DefaultKinematicTarget","positionThreshold","position","rotationThreshold","rotation","DefaultIsAutoUpdate"],"mappings":"yJAOO,IAAKA,gBAAAA,kBACVA,gBAAA,QAAU,UADAA,kBAAAA,gBAAA,CAAA,GAIL,MAAMC,eAA0B,KAE1BC,sBAAyC,CACpDC,YAAa,EACbC,gBAAiB,IAAIC,QACrBC,aAAc,EACdC,OANqC,KAOrCC,iBAAkB,IAAIC,WACtBC,YAAaC,YAAYC,EACzBC,oBAAoB,GAGTC,4BAAqD,IAC7DZ,sBACHM,iBAAkBO,YAAW,IAAIC,OAAQC,kBAAkBf,sBAAsBM,mBACjFJ,gBAAiBc,aAAahB,sBAAsBE,kBAGzCe,uBAA2C,CACtDC,kBAAmB,IACnBC,cAAU,EACVC,kBAAmB,KACnBC,cAAU,GAGCC,qBAA+B"}

package/dist/Kinematic/Utils/KinematicUtils.js

@@ -0,0 +1,2 @@
+import{isNotDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import isEqual from"../../node_modules/lodash-es/isEqual.js";import{DefaultKinematicConfigState,DefaultKinematicTarget,DefaultIsAutoUpdate}from"../Constants/KinematicConstants.js";function ignoreDefaultStateKinematic(config){if(isNotDefined(config))return;const{state:state,target:target,isAutoUpdate:isAutoUpdate}=config,isDefaultState=isEqual(state,DefaultKinematicConfigState),isDefaultTarget=isEqual(target,DefaultKinematicTarget),isDefaultAutoUpdate=isEqual(isAutoUpdate,DefaultIsAutoUpdate);return isDefaultState&&isDefaultTarget&&isDefaultAutoUpdate?void 0:config}export{ignoreDefaultStateKinematic};
+//# sourceMappingURL=KinematicUtils.js.map

package/dist/Kinematic/Utils/KinematicUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KinematicUtils.js","sources":["../../../src/Kinematic/Utils/KinematicUtils.ts"],"sourcesContent":["import { DefaultIsAutoUpdate, DefaultKinematicConfigState, DefaultKinematicTarget } from '@Anarchy/Engine/Kinematic/Constants';\nimport type { TKinematicConfig } from '@Anarchy/Engine/Kinematic/Models';\nimport { isNotDefined } from '@Anarchy/Shared/Utils';\nimport { isEqual } from 'lodash-es';\n\nexport function ignoreDefaultStateKinematic(config: TKinematicConfig | undefined): TKinematicConfig | undefined {\n  if (isNotDefined(config)) return undefined;\n\n  const { state, target, isAutoUpdate } = config;\n  const isDefaultState: boolean = isEqual(state, DefaultKinematicConfigState);\n  const isDefaultTarget: boolean = isEqual(target, DefaultKinematicTarget);\n  const isDefaultAutoUpdate: boolean = isEqual(isAutoUpdate, DefaultIsAutoUpdate);\n\n  return isDefaultState && isDefaultTarget && isDefaultAutoUpdate ? undefined : config;\n}\n"],"names":["ignoreDefaultStateKinematic","config","isNotDefined","state","target","isAutoUpdate","isDefaultState","isEqual","DefaultKinematicConfigState","isDefaultTarget","DefaultKinematicTarget","isDefaultAutoUpdate","DefaultIsAutoUpdate"],"mappings":"oQAKO,SAASA,4BAA4BC,QAC1C,GAAIC,aAAaD,QAAS,OAE1B,MAAME,MAAEA,MAAAC,OAAOA,OAAAC,aAAQA,cAAiBJ,OAClCK,eAA0BC,QAAQJ,MAAOK,6BACzCC,gBAA2BF,QAAQH,OAAQM,wBAC3CC,oBAA+BJ,QAAQF,aAAcO,qBAE3D,OAAON,gBAAkBG,iBAAmBE,yBAAsB,EAAYV,MAChF"}

package/dist/Light/Adapters/ConfigToParams.js

@@ -0,0 +1,2 @@
+import{configToParamsCameraOptionsOnly}from"../../Camera/Adapters/ConfigToParams.js";import{isNotDefined,isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{Vector2,Color}from"three";import{configToParamsObject3d}from"../../ThreeLib/Utils/Object3dUtils.js";function configToParams(config){const{position:position,rotation:rotation,scale:scale,layers:layers,color:color,shadow:shadow,...rest}=config;return{...rest,...configToParamsObject3d({position:position,rotation:rotation,scale:scale,layers:layers}),...(colorStr=color,{color:new Color(colorStr)}),...getLightShadowParams(shadow)};var colorStr}function getLightShadowParams(shadow){if(isNotDefined(shadow))return{};let camera={};return isDefined(shadow.camera)&&(camera=configToParamsCameraOptionsOnly(shadow.camera)),{shadow:{...shadow,camera:camera,mapSize:new Vector2(shadow.mapSize.x,shadow.mapSize.y)}}}export{configToParams};
+//# sourceMappingURL=ConfigToParams.js.map

package/dist/Light/Adapters/ConfigToParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigToParams.js","sources":["../../../src/Light/Adapters/ConfigToParams.ts"],"sourcesContent":["import { configToParamsCameraOptionsOnly } from '@Anarchy/Engine/Camera/Adapters/ConfigToParams';\nimport type { TAnyLightConfig, TLightParams, TLightShadowConfig, TLightShadowParams, TShadowCameraConfig, TShadowCameraParams } from '@Anarchy/Engine/Light/Models';\nimport { configToParamsObject3d } from '@Anarchy/Engine/ThreeLib';\nimport { isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\nimport { Color, Vector2 } from 'three';\n\nexport function configToParams(config: TAnyLightConfig): TLightParams {\n  const { position, rotation, scale, layers, color, shadow, ...rest } = config;\n\n  return {\n    ...rest,\n    ...configToParamsObject3d({ position, rotation, scale, layers }),\n    ...getLightColorParams(color),\n    ...getLightShadowParams(shadow)\n  };\n}\n\nfunction getLightColorParams(colorStr: string): Readonly<{ color: Color }> {\n  return { color: new Color(colorStr) };\n}\n\nfunction getLightShadowParams(shadow: TLightShadowConfig | undefined): Readonly<{ shadow?: TLightShadowParams }> {\n  if (isNotDefined(shadow)) return {};\n  let camera: TShadowCameraParams = {} as any;\n  if (isDefined(shadow.camera)) {\n    const cameraConfig: TShadowCameraConfig | undefined = shadow.camera;\n    camera = configToParamsCameraOptionsOnly(cameraConfig);\n  }\n\n  return { shadow: { ...shadow, camera, mapSize: new Vector2(shadow.mapSize.x, shadow.mapSize.y) } };\n}\n"],"names":["configToParams","config","position","rotation","scale","layers","color","shadow","rest","configToParamsObject3d","colorStr","Color","getLightShadowParams","isNotDefined","camera","isDefined","configToParamsCameraOptionsOnly","mapSize","Vector2","x","y"],"mappings":"0RAMO,SAASA,eAAeC,QAC7B,MAAMC,SAAEA,kBAAUC,SAAAC,MAAUA,MAAAC,OAAOA,aAAQC,MAAAC,OAAOA,UAAWC,MAASP,OAEtE,MAAO,IACFO,QACAC,uBAAuB,CAAEP,kBAAUC,kBAAUC,YAAOC,oBAM9BK,SALFJ,MAMlB,CAAEA,MAAO,IAAIK,MAAMD,eALrBE,qBAAqBL,SAI5B,IAA6BG,QAF7B,CAMA,SAASE,qBAAqBL,QAC5B,GAAIM,aAAaN,QAAS,MAAO,CAAA,EACjC,IAAIO,OAA8B,CAAA,EAMlC,OALIC,UAAUR,OAAOO,UAEnBA,OAASE,gCAD6CT,OAAOO,SAIxD,CAAEP,OAAQ,IAAKA,OAAQO,cAAQG,QAAS,IAAIC,QAAQX,OAAOU,QAAQE,EAAGZ,OAAOU,QAAQG,IAC9F"}

package/dist/Light/Adapters/EntityToConfig.js

@@ -0,0 +1,2 @@
+import{isNotDefined,isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{filterOutEmptyFields}from"../../packages/anarchy-shared/src/Utils/ObjectUtils.js";import{Vector2}from"three";import{getCommonCameraConfig,getPerspectiveCameraOnlyConfig,getOrthographicCameraOnlyConfig}from"../../Camera/Adapters/EntityToConfig.js";import{LightType}from"../Constants/LightType.js";import{vector2ToXy}from"../../Utils/TransformUtils.js";import{extractSerializableRegistrableFields}from"../../Mixins/Generics/ExtractSerializableRegistrableFields.js";import{serializeColor}from"../../Color/Adapters/EntityToConfig.js";import{isPerspectiveCameraParams,isOrthographicCameraParams}from"../../Camera/Utils/CameraUtils.js";function lightToConfig(entity){const{drive:drive}=entity,json=entity.entity.toJSON().object;return filterOutEmptyFields({type:json.type,color:serializeColor(entity.entity.color),intensity:json.intensity,castShadow:json.castShadow,...onlyHemisphereLightToConfig(entity),...onlyRectAreaLightToConfig(entity),...onlyPointLightToConfig(entity),...onlySpotLightToConfig(entity),...onlyLightShadowToConfig(entity),...extractSerializableRegistrableFields(entity),...drive.serialize()})}function onlyHemisphereLightToConfig(entity){return entity.getType()!==LightType.Hemisphere?{}:filterOutEmptyFields({groundColor:serializeColor(entity.entity.groundColor)})}function onlyRectAreaLightToConfig(entity){if(entity.getType()!==LightType.RectArea)return{};const json=entity.entity.toJSON().object;return filterOutEmptyFields({width:json.width,height:json.height})}function onlyPointLightToConfig(entity){if(entity.getType()!==LightType.Point)return{};const json=entity.entity.toJSON().object;return filterOutEmptyFields({distance:json.distance,decay:json.decay})}function onlySpotLightToConfig(entity){if(entity.getType()!==LightType.Spot)return{};const json=entity.entity.toJSON().object;return filterOutEmptyFields({distance:json.distance,angle:json.angle,penumbra:json.penumbra,decay:json.decay})}function onlyLightShadowToConfig(entity){const shadow=entity.entity.toJSON().object.shadow;if(isNotDefined(shadow))return{};const camera=shadow.camera,result=filterOutEmptyFields({shadow:{...shadow,mapSize:getMapSize(shadow)??getMapSize(entity.entity.shadow),normalBias:shadow.normalBias??entity.entity.shadow?.normalBias,camera:void 0}});if(isNotDefined(camera))return result;const cameraConfig=Object.assign(getCommonCameraConfig(camera),{type:camera.type});return isPerspectiveCameraParams(camera)&&Object.assign(cameraConfig,getPerspectiveCameraOnlyConfig(camera)),isOrthographicCameraParams(camera)&&Object.assign(cameraConfig,getOrthographicCameraOnlyConfig(camera)),result.shadow.camera=cameraConfig,result}function getMapSize(shadow){let mapSize;return isDefined(shadow)&&isDefined(shadow.mapSize)&&(mapSize=isDefined(shadow?.mapSize)&&isDefined((shadow?.mapSize)[0])&&isDefined((shadow?.mapSize)[1])?{x:shadow.mapSize[0],y:shadow.mapSize[1]}:void 0),vector2ToXy(mapSize??new Vector2)}export{lightToConfig,onlyHemisphereLightToConfig,onlyLightShadowToConfig,onlyPointLightToConfig,onlyRectAreaLightToConfig,onlySpotLightToConfig};
+//# sourceMappingURL=EntityToConfig.js.map

package/dist/Light/Adapters/EntityToConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityToConfig.js","sources":["../../../src/Light/Adapters/EntityToConfig.ts"],"sourcesContent":["import type { TCommonCameraParams } from '@Anarchy/Engine/Camera';\nimport { getCommonCameraConfig, getOrthographicCameraOnlyConfig, getPerspectiveCameraOnlyConfig, isOrthographicCameraParams, isPerspectiveCameraParams } from '@Anarchy/Engine/Camera';\nimport { serializeColor } from '@Anarchy/Engine/Color';\nimport { LightType } from '@Anarchy/Engine/Light/Constants';\nimport type {\n  TAbstractLightConfig,\n  TAbstractLightWrapper,\n  TAmbientLightConfig,\n  TAnyLight,\n  TDirectionalLightConfig,\n  TDirectionalLightParams,\n  THemisphereLightConfig,\n  THemisphereLightWrapper,\n  TLightShadowConfig,\n  TLightShadowParams,\n  TPointLightConfig,\n  TPointLightParams,\n  TPointLightWrapper,\n  TRectAreaLightConfig,\n  TRectAreaLightWrapper,\n  TShadowCameraConfig,\n  TShadowCameraParams,\n  TSpotLightConfig,\n  TSpotLightParams,\n  TSpotLightWrapper\n} from '@Anarchy/Engine/Light/Models';\nimport { extractSerializableRegistrableFields } from '@Anarchy/Engine/Mixins';\nimport { vector2ToXy } from '@Anarchy/Engine/Utils';\nimport type { TWriteable } from '@Anarchy/Shared/Utils';\nimport { filterOutEmptyFields, isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\nimport type { DirectionalLightShadow, Object3DJSONObject, PointLightShadow, SpotLightShadow, Vector2Like } from 'three';\nimport { Vector2 } from 'three';\n\nexport function lightToConfig<T extends TAnyLight>(entity: TAbstractLightWrapper<T>): TDirectionalLightConfig | THemisphereLightConfig | TRectAreaLightConfig | TAmbientLightConfig | TSpotLightConfig {\n  const { drive } = entity;\n\n  const json: Object3DJSONObject = entity.entity.toJSON().object;\n\n  return filterOutEmptyFields({\n    type: json.type as LightType,\n    color: serializeColor(entity.entity.color),\n    intensity: (json as unknown as TAbstractLightConfig<T>).intensity,\n    castShadow: json.castShadow,\n    // ...onlyDirectionalLightToConfig(entity as TDirectionalLightWrapper),\n    ...onlyHemisphereLightToConfig(entity as THemisphereLightWrapper),\n    ...onlyRectAreaLightToConfig(entity as TRectAreaLightWrapper),\n    ...onlyPointLightToConfig(entity as TPointLightWrapper),\n    ...onlySpotLightToConfig(entity as TSpotLightWrapper),\n    ...onlyLightShadowToConfig(entity),\n    ...extractSerializableRegistrableFields(entity),\n    ...drive.serialize()\n  });\n}\n\n// export function onlyDirectionalLightToConfig(entity: TDirectionalLightWrapper): Partial<TDirectionalLightConfig> {\n//   const json: Object3DJSONObject = entity.entity.toJSON().object;\n//\n//   return filterOutEmptyFields({\n//     layers: json.layers,\n//     // matrix: json.matrix,\n//     // up: json.up\n//   });\n// }\n\nexport function onlyHemisphereLightToConfig(entity: THemisphereLightWrapper): Partial<THemisphereLightConfig> {\n  if (entity.getType() !== LightType.Hemisphere) return {} as THemisphereLightConfig;\n  return filterOutEmptyFields({\n    groundColor: serializeColor(entity.entity.groundColor)\n  });\n}\n\nexport function onlyRectAreaLightToConfig(entity: TRectAreaLightWrapper): Partial<TRectAreaLightConfig> {\n  if (entity.getType() !== LightType.RectArea) return {} as TRectAreaLightConfig;\n  const json: Object3DJSONObject = entity.entity.toJSON().object;\n\n  return filterOutEmptyFields({\n    width: (json as unknown as TRectAreaLightConfig).width,\n    height: (json as unknown as TRectAreaLightConfig).height\n  });\n}\n\nexport function onlyPointLightToConfig(entity: TPointLightWrapper): Partial<TPointLightConfig> {\n  if (entity.getType() !== LightType.Point) return {} as TPointLightConfig;\n  const json: Object3DJSONObject = entity.entity.toJSON().object;\n\n  return filterOutEmptyFields({\n    distance: (json as unknown as TPointLightConfig).distance,\n    decay: (json as unknown as TPointLightConfig).decay\n  });\n}\n\nexport function onlySpotLightToConfig(entity: TSpotLightWrapper): Partial<TSpotLightConfig> {\n  if (entity.getType() !== LightType.Spot) return {} as TSpotLightConfig;\n  const json: Object3DJSONObject = entity.entity.toJSON().object;\n\n  return filterOutEmptyFields({\n    distance: (json as unknown as TSpotLightConfig).distance,\n    angle: (json as unknown as TSpotLightConfig).angle,\n    penumbra: (json as unknown as TSpotLightConfig).penumbra,\n    decay: (json as unknown as TSpotLightConfig).decay\n  });\n}\n\nexport function onlyLightShadowToConfig<T extends TAnyLight>(\n  entity: TAbstractLightWrapper<T>\n): Readonly<{\n  shadow?: TLightShadowConfig;\n}> {\n  const json: Object3DJSONObject = entity.entity.toJSON().object;\n\n  const lightConfig = json as unknown as TDirectionalLightParams | TPointLightParams | TSpotLightParams;\n  const shadow: TLightShadowParams | undefined = lightConfig.shadow;\n  if (isNotDefined(shadow)) return {};\n  const camera: TShadowCameraParams = shadow.camera;\n\n  const result: Readonly<{ shadow: TWriteable<TLightShadowConfig> }> = filterOutEmptyFields({\n    shadow: {\n      ...shadow,\n      mapSize: getMapSize(shadow) ?? getMapSize(entity.entity.shadow),\n      normalBias: shadow.normalBias ?? entity.entity.shadow?.normalBias,\n      camera: undefined as unknown as TCommonCameraParams\n    }\n  });\n\n  if (isNotDefined(camera)) return result;\n\n  const cameraConfig: TShadowCameraConfig = Object.assign(getCommonCameraConfig(camera), { type: camera.type });\n  // eslint-disable-next-line functional/immutable-data\n  if (isPerspectiveCameraParams(camera)) Object.assign(cameraConfig, getPerspectiveCameraOnlyConfig(camera));\n  // eslint-disable-next-line functional/immutable-data\n  if (isOrthographicCameraParams(camera)) Object.assign(cameraConfig, getOrthographicCameraOnlyConfig(camera));\n\n  // eslint-disable-next-line functional/immutable-data\n  result.shadow.camera = cameraConfig;\n\n  return result;\n}\n\nfunction getMapSize(shadow: TLightShadowConfig | TLightShadowParams | DirectionalLightShadow | PointLightShadow | SpotLightShadow | undefined): Vector2Like {\n  let mapSize: Vector2Like | undefined = undefined;\n  if (isDefined(shadow) && isDefined(shadow.mapSize)) {\n    mapSize =\n      isDefined(shadow?.mapSize) && isDefined((shadow?.mapSize as any)[0]) && isDefined((shadow?.mapSize as any)[1])\n        ? { x: (shadow.mapSize as any)[0] as number, y: (shadow.mapSize as any)[1] as number }\n        : undefined;\n  }\n  return vector2ToXy(mapSize ?? new Vector2());\n}\n"],"names":["lightToConfig","entity","drive","json","toJSON","object","filterOutEmptyFields","type","color","serializeColor","intensity","castShadow","onlyHemisphereLightToConfig","onlyRectAreaLightToConfig","onlyPointLightToConfig","onlySpotLightToConfig","onlyLightShadowToConfig","extractSerializableRegistrableFields","serialize","getType","LightType","Hemisphere","groundColor","RectArea","width","height","Point","distance","decay","Spot","angle","penumbra","shadow","isNotDefined","camera","result","mapSize","getMapSize","normalBias","cameraConfig","Object","assign","getCommonCameraConfig","isPerspectiveCameraParams","getPerspectiveCameraOnlyConfig","isOrthographicCameraParams","getOrthographicCameraOnlyConfig","isDefined","x","y","vector2ToXy","Vector2"],"mappings":"utBAiCO,SAASA,cAAmCC,QACjD,MAAMC,MAAEA,OAAUD,OAEZE,KAA2BF,OAAOA,OAAOG,SAASC,OAExD,OAAOC,qBAAqB,CAC1BC,KAAMJ,KAAKI,KACXC,MAAOC,eAAeR,OAAOA,OAAOO,OACpCE,UAAYP,KAA4CO,UACxDC,WAAYR,KAAKQ,cAEdC,4BAA4BX,WAC5BY,0BAA0BZ,WAC1Ba,uBAAuBb,WACvBc,sBAAsBd,WACtBe,wBAAwBf,WACxBgB,qCAAqChB,WACrCC,MAAMgB,aAEb,CAYO,SAASN,4BAA4BX,QAC1C,OAAIA,OAAOkB,YAAcC,UAAUC,WAAmB,CAAA,EAC/Cf,qBAAqB,CAC1BgB,YAAab,eAAeR,OAAOA,OAAOqB,cAE9C,CAEO,SAAST,0BAA0BZ,QACxC,GAAIA,OAAOkB,YAAcC,UAAUG,eAAiB,CAAA,EACpD,MAAMpB,KAA2BF,OAAOA,OAAOG,SAASC,OAExD,OAAOC,qBAAqB,CAC1BkB,MAAQrB,KAAyCqB,MACjDC,OAAStB,KAAyCsB,QAEtD,CAEO,SAASX,uBAAuBb,QACrC,GAAIA,OAAOkB,YAAcC,UAAUM,YAAc,CAAA,EACjD,MAAMvB,KAA2BF,OAAOA,OAAOG,SAASC,OAExD,OAAOC,qBAAqB,CAC1BqB,SAAWxB,KAAsCwB,SACjDC,MAAQzB,KAAsCyB,OAElD,CAEO,SAASb,sBAAsBd,QACpC,GAAIA,OAAOkB,YAAcC,UAAUS,WAAa,CAAA,EAChD,MAAM1B,KAA2BF,OAAOA,OAAOG,SAASC,OAExD,OAAOC,qBAAqB,CAC1BqB,SAAWxB,KAAqCwB,SAChDG,MAAQ3B,KAAqC2B,MAC7CC,SAAW5B,KAAqC4B,SAChDH,MAAQzB,KAAqCyB,OAEjD,CAEO,SAASZ,wBACdf,QAIA,MAGM+B,OAH2B/B,OAAOA,OAAOG,SAASC,OAGG2B,OAC3D,GAAIC,aAAaD,QAAS,MAAO,CAAA,EACjC,MAAME,OAA8BF,OAAOE,OAErCC,OAA+D7B,qBAAqB,CACxF0B,OAAQ,IACHA,OACHI,QAASC,WAAWL,SAAWK,WAAWpC,OAAOA,OAAO+B,QACxDM,WAAYN,OAAOM,YAAcrC,OAAOA,OAAO+B,QAAQM,WACvDJ,YAAQ,KAIZ,GAAID,aAAaC,QAAS,OAAOC,OAEjC,MAAMI,aAAoCC,OAAOC,OAAOC,sBAAsBR,QAAS,CAAE3B,KAAM2B,OAAO3B,OAStG,OAPIoC,0BAA0BT,SAASM,OAAOC,OAAOF,aAAcK,+BAA+BV,SAE9FW,2BAA2BX,SAASM,OAAOC,OAAOF,aAAcO,gCAAgCZ,SAGpGC,OAAOH,OAAOE,OAASK,aAEhBJ,MACT,CAEA,SAASE,WAAWL,QAClB,IAAII,QAOJ,OANIW,UAAUf,SAAWe,UAAUf,OAAOI,WACxCA,QACEW,UAAUf,QAAQI,UAAYW,WAAWf,QAAQI,SAAgB,KAAOW,WAAWf,QAAQI,SAAgB,IACvG,CAAEY,EAAIhB,OAAOI,QAAgB,GAAca,EAAIjB,OAAOI,QAAgB,SACtE,GAEDc,YAAYd,SAAW,IAAIe,QACpC"}

package/dist/Light/Constants/LightType.js

@@ -0,0 +1,2 @@
+var LightType=(LightType2=>(LightType2.Ambient="AmbientLight",LightType2.Directional="DirectionalLight",LightType2.Hemisphere="HemisphereLight",LightType2.Point="PointLight",LightType2.RectArea="RectAreaLight",LightType2.Spot="SpotLight",LightType2))(LightType||{});export{LightType};
+//# sourceMappingURL=LightType.js.map

package/dist/Light/Constants/LightType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightType.js","sources":["../../../src/Light/Constants/LightType.ts"],"sourcesContent":["export enum LightType {\n  Ambient = 'AmbientLight',\n  Directional = 'DirectionalLight',\n  Hemisphere = 'HemisphereLight',\n  Point = 'PointLight',\n  RectArea = 'RectAreaLight',\n  Spot = 'SpotLight'\n}\n"],"names":["LightType"],"mappings":"AAAO,IAAKA,WAAAA,aACVA,WAAA,QAAU,eACVA,WAAA,YAAc,mBACdA,WAAA,WAAa,kBACbA,WAAA,MAAQ,aACRA,WAAA,SAAW,gBACXA,WAAA,KAAO,YANGA,aAAAA,WAAA,CAAA"}

package/dist/Light/Factories/LightFactory.js

@@ -0,0 +1,2 @@
+import{configToParams}from"../Adapters/ConfigToParams.js";import{isAmbientLightParams,isDirectionalLightParams,isPointLightParams,isHemisphereLightParams,isRectAreaLightParams,isSpotLightParams}from"../Utils/Utils.js";import{AmbientLightWrapper}from"../Wrappers/AmbientLightWrapper.js";import{DirectionalLightWrapper}from"../Wrappers/DirectionalLightWrapper.js";import{PointLightWrapper}from"../Wrappers/PointLightWrapper.js";import{HemisphereLightWrapper}from"../Wrappers/HemisphereLightWrapper.js";import{RectAreaLightWrapper}from"../Wrappers/RectAreaLightWrapper.js";import{SpotLightWrapper}from"../Wrappers/SpotLightWrapper.js";import{ReactiveFactory}from"../../Abstract/Factories/ReactiveFactory.js";import{FactoryType}from"../../Abstract/Constants/FactoryType.js";import{LightType}from"../Constants/LightType.js";function create(params,dependencies){if(params.type===LightType.Ambient&&isAmbientLightParams(params))return AmbientLightWrapper(params,dependencies);if(params.type===LightType.Directional&&isDirectionalLightParams(params))return DirectionalLightWrapper(params,dependencies);if(params.type===LightType.Point&&isPointLightParams(params))return PointLightWrapper(params,dependencies);if(params.type===LightType.Hemisphere&&isHemisphereLightParams(params))return HemisphereLightWrapper(params,dependencies);if(params.type===LightType.RectArea&&isRectAreaLightParams(params))return RectAreaLightWrapper(params,dependencies);if(params.type===LightType.Spot&&isSpotLightParams(params))return SpotLightWrapper(params,dependencies);throw new Error(`Unsupported light type: "${params.type}" or invalid params (does not match the light type)`)}function LightFactory(){const factory=ReactiveFactory(FactoryType.Light,create);return Object.assign(factory,{configToParams:configToParams})}export{LightFactory};
+//# sourceMappingURL=LightFactory.js.map

package/dist/Light/Factories/LightFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightFactory.js","sources":["../../../src/Light/Factories/LightFactory.ts"],"sourcesContent":["import type { TReactiveFactory } from '@Anarchy/Engine/Abstract';\nimport { FactoryType, ReactiveFactory } from '@Anarchy/Engine/Abstract';\nimport { configToParams } from '@Anarchy/Engine/Light/Adapters';\nimport { LightType } from '@Anarchy/Engine/Light/Constants';\nimport type { TLightFactory, TLightParams, TLightServiceDependencies, TLightWrapper } from '@Anarchy/Engine/Light/Models';\nimport { isAmbientLightParams, isDirectionalLightParams, isHemisphereLightParams, isPointLightParams, isRectAreaLightParams, isSpotLightParams } from '@Anarchy/Engine/Light/Utils';\nimport { AmbientLightWrapper, DirectionalLightWrapper, HemisphereLightWrapper, PointLightWrapper, RectAreaLightWrapper, SpotLightWrapper } from '@Anarchy/Engine/Light/Wrappers';\n\nfunction create(params: TLightParams, dependencies: TLightServiceDependencies): TLightWrapper | never {\n  if (params.type === LightType.Ambient && isAmbientLightParams(params)) return AmbientLightWrapper(params, dependencies);\n  if (params.type === LightType.Directional && isDirectionalLightParams(params)) return DirectionalLightWrapper(params, dependencies);\n  if (params.type === LightType.Point && isPointLightParams(params)) return PointLightWrapper(params, dependencies);\n  if (params.type === LightType.Hemisphere && isHemisphereLightParams(params)) return HemisphereLightWrapper(params, dependencies);\n  if (params.type === LightType.RectArea && isRectAreaLightParams(params)) return RectAreaLightWrapper(params, dependencies);\n  if (params.type === LightType.Spot && isSpotLightParams(params)) return SpotLightWrapper(params, dependencies);\n  throw new Error(`Unsupported light type: \"${params.type}\" or invalid params (does not match the light type)`);\n}\n\nexport function LightFactory(): TLightFactory {\n  const factory: TReactiveFactory<TLightWrapper, TLightParams, TLightServiceDependencies> = ReactiveFactory(FactoryType.Light, create);\n\n  // eslint-disable-next-line functional/immutable-data\n  return Object.assign(factory, { configToParams });\n}\n"],"names":["create","params","dependencies","type","LightType","Ambient","isAmbientLightParams","AmbientLightWrapper","Directional","isDirectionalLightParams","DirectionalLightWrapper","Point","isPointLightParams","PointLightWrapper","Hemisphere","isHemisphereLightParams","HemisphereLightWrapper","RectArea","isRectAreaLightParams","RectAreaLightWrapper","Spot","isSpotLightParams","SpotLightWrapper","Error","LightFactory","factory","ReactiveFactory","FactoryType","Light","Object","assign","configToParams"],"mappings":"mzBAQA,SAASA,OAAOC,OAAsBC,cACpC,GAAID,OAAOE,OAASC,UAAUC,SAAWC,qBAAqBL,QAAS,OAAOM,oBAAoBN,OAAQC,cAC1G,GAAID,OAAOE,OAASC,UAAUI,aAAeC,yBAAyBR,QAAS,OAAOS,wBAAwBT,OAAQC,cACtH,GAAID,OAAOE,OAASC,UAAUO,OAASC,mBAAmBX,QAAS,OAAOY,kBAAkBZ,OAAQC,cACpG,GAAID,OAAOE,OAASC,UAAUU,YAAcC,wBAAwBd,QAAS,OAAOe,uBAAuBf,OAAQC,cACnH,GAAID,OAAOE,OAASC,UAAUa,UAAYC,sBAAsBjB,QAAS,OAAOkB,qBAAqBlB,OAAQC,cAC7G,GAAID,OAAOE,OAASC,UAAUgB,MAAQC,kBAAkBpB,QAAS,OAAOqB,iBAAiBrB,OAAQC,cACjG,MAAM,IAAIqB,MAAM,4BAA4BtB,OAAOE,0DACrD,CAEO,SAASqB,eACd,MAAMC,QAAoFC,gBAAgBC,YAAYC,MAAO5B,QAG7H,OAAO6B,OAAOC,OAAOL,QAAS,CAAEM,+BAClC"}

package/dist/Light/Registries/LightRegistry.js

@@ -0,0 +1,2 @@
+import{AbstractEntityRegistry}from"../../Abstract/Registries/AbstractEntityRegistry.js";import{RegistryType}from"../../Abstract/Constants/RegistryType.js";function LightRegistry(){return AbstractEntityRegistry(RegistryType.Light)}export{LightRegistry};
+//# sourceMappingURL=LightRegistry.js.map

package/dist/Light/Registries/LightRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightRegistry.js","sources":["../../../src/Light/Registries/LightRegistry.ts"],"sourcesContent":["import { RegistryType } from '@Anarchy/Engine/Abstract/Constants';\nimport { AbstractEntityRegistry } from '@Anarchy/Engine/Abstract/Registries';\nimport type { TAbstractLightWrapper, TAnyLight, TLightRegistry } from '@Anarchy/Engine/Light/Models';\n\nexport function LightRegistry(): TLightRegistry {\n  return AbstractEntityRegistry<TAbstractLightWrapper<TAnyLight>>(RegistryType.Light);\n}\n"],"names":["LightRegistry","AbstractEntityRegistry","RegistryType","Light"],"mappings":"2JAIO,SAASA,gBACd,OAAOC,uBAAyDC,aAAaC,MAC/E"}

package/dist/Light/Services/LightService.js

@@ -0,0 +1,2 @@
+import{AbstractService}from"../../Abstract/Services/AbstractService.js";import{withCreateFromConfigServiceMixin}from"../../Mixins/Services/WithCreateFromConfigService.js";import{mergeAll}from"../../Utils/ObjectUtils.js";import{withCreateServiceMixin}from"../../Mixins/Services/WithCreateService.js";import{withSceneGetterService}from"../../Mixins/Services/WithSceneGetterService.js";import{withSerializableEntities}from"../../Mixins/Services/WithSerializableEntities.js";import{withRegistryService}from"../../Mixins/Services/WithRegistryService.js";import{withFactoryService}from"../../Mixins/Services/WithFactoryService.js";function LightService(factory,registry,dependencies,scene){const registrySub$=registry.added$.subscribe(({value:value})=>scene.addLight(value)),factorySub$=factory.entityCreated$.subscribe(wrapper=>registry.add(wrapper)),abstractService=AbstractService([registry,factory,registrySub$,factorySub$]),withCreateService=withCreateServiceMixin(factory,dependencies),withCreateFromConfigService=withCreateFromConfigServiceMixin(withCreateService.create,factory.configToParams,void 0),withFactory=withFactoryService(factory),withRegistry=withRegistryService(registry);return mergeAll(abstractService,withCreateService,withCreateFromConfigService,withFactory,withRegistry,withSerializableEntities(registry),withSceneGetterService(scene))}export{LightService};
+//# sourceMappingURL=LightService.js.map

package/dist/Light/Services/LightService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightService.js","sources":["../../../src/Light/Services/LightService.ts"],"sourcesContent":["import type { TAbstractService, TRegistryPack } from '@Anarchy/Engine/Abstract';\nimport { AbstractService } from '@Anarchy/Engine/Abstract';\nimport type {\n  TAbstractLightWrapper,\n  TAnyLight,\n  TAnyLightConfig,\n  TAnyLightWrapper,\n  TLightFactory,\n  TLightRegistry,\n  TLightService,\n  TLightServiceDependencies,\n  TLightServiceWithCreate,\n  TLightServiceWithCreateFromConfig,\n  TLightServiceWithFactory,\n  TLightServiceWithRegistry\n} from '@Anarchy/Engine/Light/Models';\nimport type { TDisposable } from '@Anarchy/Engine/Mixins';\nimport { withCreateFromConfigServiceMixin, withCreateServiceMixin, withFactoryService, withRegistryService, withSceneGetterService, withSerializableEntities } from '@Anarchy/Engine/Mixins';\nimport type { TSceneWrapper } from '@Anarchy/Engine/Scene';\nimport { mergeAll } from '@Anarchy/Engine/Utils';\nimport type { Subscription } from 'rxjs';\n\nexport function LightService(factory: TLightFactory, registry: TLightRegistry, dependencies: TLightServiceDependencies, scene: TSceneWrapper): TLightService {\n  const registrySub$: Subscription = registry.added$.subscribe(({ value }: TRegistryPack<TAbstractLightWrapper<TAnyLight>>) => scene.addLight(value));\n  const factorySub$: Subscription = factory.entityCreated$.subscribe((wrapper: TAnyLightWrapper): void => registry.add(wrapper));\n  const disposable: ReadonlyArray<TDisposable> = [registry, factory, registrySub$, factorySub$];\n  const abstractService: TAbstractService = AbstractService(disposable);\n\n  const withCreateService: TLightServiceWithCreate = withCreateServiceMixin(factory, dependencies);\n  const withCreateFromConfigService: TLightServiceWithCreateFromConfig = withCreateFromConfigServiceMixin(withCreateService.create, factory.configToParams, undefined);\n  const withFactory: TLightServiceWithFactory = withFactoryService(factory);\n  const withRegistry: TLightServiceWithRegistry = withRegistryService(registry);\n\n  return mergeAll(\n    abstractService,\n    withCreateService,\n    withCreateFromConfigService,\n    withFactory,\n    withRegistry,\n    withSerializableEntities<TAnyLightWrapper, TAnyLightConfig, undefined>(registry),\n    withSceneGetterService(scene)\n  );\n}\n"],"names":["LightService","factory","registry","dependencies","scene","registrySub$","added$","subscribe","value","addLight","factorySub$","entityCreated$","wrapper","add","abstractService","AbstractService","withCreateService","withCreateServiceMixin","withCreateFromConfigService","withCreateFromConfigServiceMixin","create","configToParams","withFactory","withFactoryService","withRegistry","withRegistryService","mergeAll","withSerializableEntities","withSceneGetterService"],"mappings":"inBAsBO,SAASA,aAAaC,QAAwBC,SAA0BC,aAAyCC,OACtH,MAAMC,aAA6BH,SAASI,OAAOC,UAAU,EAAGC,eAA6DJ,MAAMK,SAASD,QACtIE,YAA4BT,QAAQU,eAAeJ,UAAWK,SAAoCV,SAASW,IAAID,UAE/GE,gBAAoCC,gBADK,CAACb,SAAUD,QAASI,aAAcK,cAG3EM,kBAA6CC,uBAAuBhB,QAASE,cAC7Ee,4BAAiEC,iCAAiCH,kBAAkBI,OAAQnB,QAAQoB,uBACpIC,YAAwCC,mBAAmBtB,SAC3DuB,aAA0CC,oBAAoBvB,UAEpE,OAAOwB,SACLZ,gBACAE,kBACAE,4BACAI,YACAE,aACAG,yBAAuEzB,UACvE0B,uBAAuBxB,OAE3B"}

package/dist/Light/TransformDrive/LightTransformDrive.js

@@ -0,0 +1,2 @@
+function LightTransformDrive(params,{transformDriveService:transformDriveService},relatedEntityId){const transformAgents=transformDriveService.getTransformAgents(params,{hasConnected:!0});return transformDriveService.create({activeAgent:params.agent,relatedEntityId:relatedEntityId},transformAgents)}export{LightTransformDrive};
+//# sourceMappingURL=LightTransformDrive.js.map

package/dist/Light/TransformDrive/LightTransformDrive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightTransformDrive.js","sources":["../../../src/Light/TransformDrive/LightTransformDrive.ts"],"sourcesContent":["import type { TLightParams, TLightServiceDependencies, TLightTransformAgents, TLightTransformDrive } from '@Anarchy/Engine/Light/Models';\nimport type { TTransformDriveParams } from '@Anarchy/Engine/TransformDrive';\n\nexport function LightTransformDrive(params: TLightParams, { transformDriveService }: Pick<TLightServiceDependencies, 'transformDriveService'>, relatedEntityId: string): TLightTransformDrive {\n  const transformAgents: TLightTransformAgents = transformDriveService.getTransformAgents(params, { hasConnected: true }) as TLightTransformAgents;\n  const driveParams: TTransformDriveParams = { activeAgent: params.agent, relatedEntityId };\n\n  return transformDriveService.create(driveParams, transformAgents) as TLightTransformDrive;\n}\n"],"names":["LightTransformDrive","params","transformDriveService","relatedEntityId","transformAgents","getTransformAgents","hasConnected","create","activeAgent","agent"],"mappings":"AAGO,SAASA,oBAAoBC,QAAsBC,sBAAEA,uBAAmFC,iBAC7I,MAAMC,gBAAyCF,sBAAsBG,mBAAmBJ,OAAQ,CAAEK,cAAc,IAGhH,OAAOJ,sBAAsBK,OAFc,CAAEC,YAAaP,OAAOQ,MAAON,iCAEvBC,gBACnD"}

package/dist/Light/Utils/Utils.js

@@ -0,0 +1,2 @@
+import{isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{WrapperType}from"../../Abstract/Constants/WrapperType.js";function getWrapperType(light){if(isAmbientLight(light))return WrapperType.AmbientLight;if(isDirectionalLight(light))return WrapperType.DirectionalLight;if(isPointLight(light))return WrapperType.PointLight;if(isHemisphereLight(light))return WrapperType.HemisphereLight;if(isRectAreaLight(light))return WrapperType.RectAreaLight;if(isSpotLight(light))return WrapperType.SpotLight;throw new Error("Unknown light type")}function isAmbientLight(light){return Boolean(light.isAmbientLight)}function isDirectionalLight(light){return Boolean(light.isDirectionalLight)}function isPointLight(light){return Boolean(light.isPointLight)}function isHemisphereLight(light){return Boolean(light.isHemisphereLight)}function isRectAreaLight(light){return Boolean(light.isRectAreaLight)}function isSpotLight(light){return Boolean(light.isSpotLight)}function isAmbientLightParams(params){return isDefined(params.color)&&isDefined(params.intensity)}function isDirectionalLightParams(params){return isDefined(params.color)&&isDefined(params.intensity)}function isPointLightParams(params){return isDefined(params.color)&&isDefined(params.intensity)}function isHemisphereLightParams(params){return isDefined(params.color)&&isDefined(params.groundColor)&&isDefined(params.intensity)}function isRectAreaLightParams(params){return isDefined(params.color)&&isDefined(params.intensity)&&isDefined(params.height)&&isDefined(params.width)}function isSpotLightParams(params){return isDefined(params.color)&&isDefined(params.intensity)&&isDefined(params.angle)&&isDefined(params.penumbra)&&isDefined(params.decay)&&isDefined(params.distance)}export{getWrapperType,isAmbientLight,isAmbientLightParams,isDirectionalLight,isDirectionalLightParams,isHemisphereLight,isHemisphereLightParams,isPointLight,isPointLightParams,isRectAreaLight,isRectAreaLightParams,isSpotLight,isSpotLightParams};
+//# sourceMappingURL=Utils.js.map

package/dist/Light/Utils/Utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.js","sources":["../../../src/Light/Utils/Utils.ts"],"sourcesContent":["import { WrapperType } from '@Anarchy/Engine/Abstract';\nimport type {\n  TAmbientLight,\n  TAmbientLightParams,\n  TAnyLight,\n  TDirectionalLight,\n  TDirectionalLightParams,\n  THemisphereLight,\n  THemisphereLightParams,\n  TLightParams,\n  TPointLight,\n  TPointLightParams,\n  TRectAreaLight,\n  TRectAreaLightParams,\n  TSpotLight,\n  TSpotLightParams\n} from '@Anarchy/Engine/Light/Models';\nimport { isDefined } from '@Anarchy/Shared/Utils';\n\nexport function getWrapperType(light: TAnyLight): WrapperType | never {\n  if (isAmbientLight(light)) return WrapperType.AmbientLight;\n  else if (isDirectionalLight(light)) return WrapperType.DirectionalLight;\n  else if (isPointLight(light)) return WrapperType.PointLight;\n  else if (isHemisphereLight(light)) return WrapperType.HemisphereLight;\n  else if (isRectAreaLight(light)) return WrapperType.RectAreaLight;\n  else if (isSpotLight(light)) return WrapperType.SpotLight;\n  else throw new Error('Unknown light type');\n}\n\nexport function isAmbientLight(light: TAnyLight): light is TAmbientLight {\n  return Boolean((light as TAmbientLight).isAmbientLight);\n}\n\nexport function isDirectionalLight(light: TAnyLight): light is TDirectionalLight {\n  return Boolean((light as TDirectionalLight).isDirectionalLight);\n}\n\nexport function isPointLight(light: TAnyLight): light is TPointLight {\n  return Boolean((light as TPointLight).isPointLight);\n}\n\nexport function isHemisphereLight(light: TAnyLight): light is THemisphereLight {\n  return Boolean((light as THemisphereLight).isHemisphereLight);\n}\n\nexport function isRectAreaLight(light: TAnyLight): light is TRectAreaLight {\n  return Boolean((light as TRectAreaLight).isRectAreaLight);\n}\n\nexport function isSpotLight(light: TAnyLight): light is TSpotLight {\n  return Boolean((light as TSpotLight).isSpotLight);\n}\n\nexport function isAmbientLightParams(params: TLightParams): params is TAmbientLightParams {\n  return isDefined((params as TAmbientLightParams).color) && isDefined((params as TAmbientLightParams).intensity);\n}\n\nexport function isDirectionalLightParams(params: TLightParams): params is TDirectionalLightParams {\n  return isDefined((params as TDirectionalLightParams).color) && isDefined((params as TDirectionalLightParams).intensity);\n}\n\nexport function isPointLightParams(params: TLightParams): params is TPointLightParams {\n  return isDefined((params as TPointLightParams).color) && isDefined((params as TPointLightParams).intensity);\n}\n\nexport function isHemisphereLightParams(params: TLightParams): params is THemisphereLightParams {\n  return isDefined((params as THemisphereLightParams).color) && isDefined((params as THemisphereLightParams).groundColor) && isDefined((params as THemisphereLightParams).intensity);\n}\n\nexport function isRectAreaLightParams(params: TLightParams): params is TRectAreaLightParams {\n  return (\n    isDefined((params as TRectAreaLightParams).color) &&\n    isDefined((params as TRectAreaLightParams).intensity) &&\n    isDefined((params as TRectAreaLightParams).height) &&\n    isDefined((params as TRectAreaLightParams).width)\n  );\n}\n\nexport function isSpotLightParams(params: TLightParams): params is TSpotLightParams {\n  return (\n    isDefined((params as TSpotLightParams).color) &&\n    isDefined((params as TSpotLightParams).intensity) &&\n    isDefined((params as TSpotLightParams).angle) &&\n    isDefined((params as TSpotLightParams).penumbra) &&\n    isDefined((params as TSpotLightParams).decay) &&\n    isDefined((params as TSpotLightParams).distance)\n  );\n}\n"],"names":["getWrapperType","light","isAmbientLight","WrapperType","AmbientLight","isDirectionalLight","DirectionalLight","isPointLight","PointLight","isHemisphereLight","HemisphereLight","isRectAreaLight","RectAreaLight","isSpotLight","SpotLight","Error","Boolean","isAmbientLightParams","params","isDefined","color","intensity","isDirectionalLightParams","isPointLightParams","isHemisphereLightParams","groundColor","isRectAreaLightParams","height","width","isSpotLightParams","angle","penumbra","decay","distance"],"mappings":"8IAmBO,SAASA,eAAeC,OAC7B,GAAIC,eAAeD,OAAQ,OAAOE,YAAYC,aAAA,GACrCC,mBAAmBJ,OAAQ,OAAOE,YAAYG,iBAAA,GAC9CC,aAAaN,OAAQ,OAAOE,YAAYK,WAAA,GACxCC,kBAAkBR,OAAQ,OAAOE,YAAYO,gBAAA,GAC7CC,gBAAgBV,OAAQ,OAAOE,YAAYS,cAAA,GAC3CC,YAAYZ,OAAQ,OAAOE,YAAYW,UAC3C,MAAM,IAAIC,MAAM,qBACvB,CAEO,SAASb,eAAeD,OAC7B,OAAOe,QAASf,MAAwBC,eAC1C,CAEO,SAASG,mBAAmBJ,OACjC,OAAOe,QAASf,MAA4BI,mBAC9C,CAEO,SAASE,aAAaN,OAC3B,OAAOe,QAASf,MAAsBM,aACxC,CAEO,SAASE,kBAAkBR,OAChC,OAAOe,QAASf,MAA2BQ,kBAC7C,CAEO,SAASE,gBAAgBV,OAC9B,OAAOe,QAASf,MAAyBU,gBAC3C,CAEO,SAASE,YAAYZ,OAC1B,OAAOe,QAASf,MAAqBY,YACvC,CAEO,SAASI,qBAAqBC,QACnC,OAAOC,UAAWD,OAA+BE,QAAUD,UAAWD,OAA+BG,UACvG,CAEO,SAASC,yBAAyBJ,QACvC,OAAOC,UAAWD,OAAmCE,QAAUD,UAAWD,OAAmCG,UAC/G,CAEO,SAASE,mBAAmBL,QACjC,OAAOC,UAAWD,OAA6BE,QAAUD,UAAWD,OAA6BG,UACnG,CAEO,SAASG,wBAAwBN,QACtC,OAAOC,UAAWD,OAAkCE,QAAUD,UAAWD,OAAkCO,cAAgBN,UAAWD,OAAkCG,UAC1K,CAEO,SAASK,sBAAsBR,QACpC,OACEC,UAAWD,OAAgCE,QAC3CD,UAAWD,OAAgCG,YAC3CF,UAAWD,OAAgCS,SAC3CR,UAAWD,OAAgCU,MAE/C,CAEO,SAASC,kBAAkBX,QAChC,OACEC,UAAWD,OAA4BE,QACvCD,UAAWD,OAA4BG,YACvCF,UAAWD,OAA4BY,QACvCX,UAAWD,OAA4Ba,WACvCZ,UAAWD,OAA4Bc,QACvCb,UAAWD,OAA4Be,SAE3C"}

package/dist/Light/Wrappers/AbstractLightWrapper.js

@@ -0,0 +1,2 @@
+import{lightToConfig}from"../Adapters/EntityToConfig.js";import{getWrapperType}from"../Utils/Utils.js";import{applyShadowParams}from"./LightWrapperHelper.js";import{LightTransformDrive}from"../TransformDrive/LightTransformDrive.js";import{AbstractWrapper}from"../../Abstract/Wrappers/AbstractWrapper.js";import{DriveToTargetConnector}from"../../TransformDrive/Entities/Connectors/DriveToTargetConnector.js";import{withObject3d}from"../../Mixins/GameObjects/Mixins/WithObject3D.js";import{applyObject3dParams}from"../../Utils/WrapperHelpers.js";function AbstractLightWrapper(entity,params,dependencies){const wrapper=AbstractWrapper(entity,getWrapperType(entity),params),drive=LightTransformDrive(params,dependencies,wrapper.id),driveToTargetConnector=DriveToTargetConnector(drive,entity),result=Object.assign(wrapper,{drive:drive,driveToTargetConnector:driveToTargetConnector,...withObject3d(entity),entity:entity,getType:()=>entity.type,serialize:()=>lightToConfig(result)}),destroySub$=result.destroy$.subscribe(()=>{destroySub$.unsubscribe(),entity.shadow?.map?.dispose(),entity.dispose()});return applyShadowParams(params,result.entity),applyObject3dParams(result,params),result}export{AbstractLightWrapper};
+//# sourceMappingURL=AbstractLightWrapper.js.map

package/dist/Light/Wrappers/AbstractLightWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractLightWrapper.js","sources":["../../../src/Light/Wrappers/AbstractLightWrapper.ts"],"sourcesContent":["import type { TAbstractWrapper } from '@Anarchy/Engine/Abstract';\nimport { AbstractWrapper } from '@Anarchy/Engine/Abstract';\nimport { lightToConfig } from '@Anarchy/Engine/Light/Adapters';\nimport type { LightType } from '@Anarchy/Engine/Light/Constants';\nimport type { TAbstractLightConfig, TAbstractLightWrapper, TAnyLight, TLightParams, TLightServiceDependencies, TLightTransformDrive } from '@Anarchy/Engine/Light/Models';\nimport { LightTransformDrive } from '@Anarchy/Engine/Light/TransformDrive';\nimport { getWrapperType } from '@Anarchy/Engine/Light/Utils';\nimport { applyShadowParams } from '@Anarchy/Engine/Light/Wrappers/LightWrapperHelper';\nimport { withObject3d } from '@Anarchy/Engine/Mixins';\nimport type { TDriveToTargetConnector } from '@Anarchy/Engine/TransformDrive';\nimport { DriveToTargetConnector } from '@Anarchy/Engine/TransformDrive';\nimport { applyObject3dParams } from '@Anarchy/Engine/Utils';\nimport type { Subscription } from 'rxjs';\n\nexport function AbstractLightWrapper<T extends TAnyLight>(entity: T, params: TLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<T> {\n  const wrapper: TAbstractWrapper<T> = AbstractWrapper(entity, getWrapperType(entity), params);\n  const drive: TLightTransformDrive = LightTransformDrive(params, dependencies, wrapper.id);\n  const driveToTargetConnector: TDriveToTargetConnector = DriveToTargetConnector(drive, entity);\n\n  // eslint-disable-next-line functional/immutable-data\n  const result: TAbstractLightWrapper<T> = Object.assign(wrapper, {\n    drive,\n    driveToTargetConnector,\n    ...withObject3d(entity),\n    entity,\n    getType: (): LightType => entity.type as LightType,\n    serialize: (): TAbstractLightConfig<T> => lightToConfig(result) as TAbstractLightConfig<T>\n  });\n\n  const destroySub$: Subscription = result.destroy$.subscribe((): void => {\n    destroySub$.unsubscribe();\n\n    (entity as any).shadow?.map?.dispose();\n    entity.dispose();\n  });\n\n  applyShadowParams(params, result.entity);\n  applyObject3dParams(result, params);\n\n  return result;\n}\n"],"names":["AbstractLightWrapper","entity","params","dependencies","wrapper","AbstractWrapper","getWrapperType","drive","LightTransformDrive","id","driveToTargetConnector","DriveToTargetConnector","result","Object","assign","withObject3d","getType","type","serialize","lightToConfig","destroySub$","destroy$","subscribe","unsubscribe","shadow","map","dispose","applyShadowParams","applyObject3dParams"],"mappings":"giBAcO,SAASA,qBAA0CC,OAAWC,OAAsBC,cACzF,MAAMC,QAA+BC,gBAAgBJ,OAAQK,eAAeL,QAASC,QAC/EK,MAA8BC,oBAAoBN,OAAQC,aAAcC,QAAQK,IAChFC,uBAAkDC,uBAAuBJ,MAAON,QAGhFW,OAAmCC,OAAOC,OAAOV,QAAS,CAC9DG,YACAG,iDACGK,aAAad,QAChBA,cACAe,QAAS,IAAiBf,OAAOgB,KACjCC,UAAW,IAA+BC,cAAcP,UAGpDQ,YAA4BR,OAAOS,SAASC,UAAU,KAC1DF,YAAYG,cAEXtB,OAAeuB,QAAQC,KAAKC,UAC7BzB,OAAOyB,YAMT,OAHAC,kBAAkBzB,OAAQU,OAAOX,QACjC2B,oBAAoBhB,OAAQV,QAErBU,MACT"}

package/dist/Light/Wrappers/AmbientLightWrapper.js

@@ -0,0 +1,2 @@
+import{AmbientLight}from"three";import{AbstractLightWrapper}from"./AbstractLightWrapper.js";function AmbientLightWrapper(params,dependencies){const entity=new AmbientLight(params.color,params.intensity);return AbstractLightWrapper(entity,params,dependencies)}export{AmbientLightWrapper};
+//# sourceMappingURL=AmbientLightWrapper.js.map

package/dist/Light/Wrappers/AmbientLightWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmbientLightWrapper.js","sources":["../../../src/Light/Wrappers/AmbientLightWrapper.ts"],"sourcesContent":["import type { TAbstractLightWrapper, TAmbientLight, TAmbientLightParams, TLightServiceDependencies } from '@Anarchy/Engine/Light/Models';\nimport { AmbientLight } from 'three';\n\nimport { AbstractLightWrapper } from './AbstractLightWrapper';\n\nexport function AmbientLightWrapper(params: TAmbientLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TAmbientLight> {\n  const entity: TAmbientLight = new AmbientLight(params.color, params.intensity);\n  return AbstractLightWrapper(entity, params, dependencies);\n}\n"],"names":["AmbientLightWrapper","params","dependencies","entity","AmbientLight","color","intensity","AbstractLightWrapper"],"mappings":"4FAKO,SAASA,oBAAoBC,OAA6BC,cAC/D,MAAMC,OAAwB,IAAIC,aAAaH,OAAOI,MAAOJ,OAAOK,WACpE,OAAOC,qBAAqBJ,OAAQF,OAAQC,aAC9C"}

package/dist/Light/Wrappers/DirectionalLightWrapper.js

@@ -0,0 +1,2 @@
+import{DirectionalLight}from"three";import{AbstractLightWrapper}from"./AbstractLightWrapper.js";function DirectionalLightWrapper(params,dependencies){const entity=new DirectionalLight(params.color,params.intensity);return AbstractLightWrapper(entity,params,dependencies)}export{DirectionalLightWrapper};
+//# sourceMappingURL=DirectionalLightWrapper.js.map

package/dist/Light/Wrappers/DirectionalLightWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DirectionalLightWrapper.js","sources":["../../../src/Light/Wrappers/DirectionalLightWrapper.ts"],"sourcesContent":["import type { TAbstractLightWrapper, TDirectionalLight, TDirectionalLightParams, TLightServiceDependencies } from '@Anarchy/Engine/Light/Models';\nimport { DirectionalLight } from 'three';\n\nimport { AbstractLightWrapper } from './AbstractLightWrapper';\n\nexport function DirectionalLightWrapper(params: TDirectionalLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TDirectionalLight> {\n  const entity: TDirectionalLight = new DirectionalLight(params.color, params.intensity);\n  return AbstractLightWrapper(entity, params, dependencies);\n}\n"],"names":["DirectionalLightWrapper","params","dependencies","entity","DirectionalLight","color","intensity","AbstractLightWrapper"],"mappings":"gGAKO,SAASA,wBAAwBC,OAAiCC,cACvE,MAAMC,OAA4B,IAAIC,iBAAiBH,OAAOI,MAAOJ,OAAOK,WAC5E,OAAOC,qBAAqBJ,OAAQF,OAAQC,aAC9C"}

package/dist/Light/Wrappers/HemisphereLightWrapper.js

@@ -0,0 +1,2 @@
+import{HemisphereLight}from"three";import{AbstractLightWrapper}from"./AbstractLightWrapper.js";function HemisphereLightWrapper(params,dependencies){const entity=new HemisphereLight(params.color,params.groundColor,params.intensity);return AbstractLightWrapper(entity,params,dependencies)}export{HemisphereLightWrapper};
+//# sourceMappingURL=HemisphereLightWrapper.js.map

package/dist/Light/Wrappers/HemisphereLightWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HemisphereLightWrapper.js","sources":["../../../src/Light/Wrappers/HemisphereLightWrapper.ts"],"sourcesContent":["import type { TAbstractLightWrapper, THemisphereLight, THemisphereLightParams, TLightServiceDependencies } from '@Anarchy/Engine/Light/Models';\nimport { HemisphereLight } from 'three';\n\nimport { AbstractLightWrapper } from './AbstractLightWrapper';\n\nexport function HemisphereLightWrapper(params: THemisphereLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<THemisphereLight> {\n  const entity: THemisphereLight = new HemisphereLight(params.color, params.groundColor, params.intensity);\n  return AbstractLightWrapper(entity, params, dependencies);\n}\n"],"names":["HemisphereLightWrapper","params","dependencies","entity","HemisphereLight","color","groundColor","intensity","AbstractLightWrapper"],"mappings":"+FAKO,SAASA,uBAAuBC,OAAgCC,cACrE,MAAMC,OAA2B,IAAIC,gBAAgBH,OAAOI,MAAOJ,OAAOK,YAAaL,OAAOM,WAC9F,OAAOC,qBAAqBL,OAAQF,OAAQC,aAC9C"}

package/dist/Light/Wrappers/LightWrapperHelper.js

@@ -0,0 +1,2 @@
+import{isDirectionalLight,isPointLight,isSpotLight}from"../Utils/Utils.js";import{isDefined,isNotDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{Vector3}from"three";function applyShadowParams(params,entity){isDefined(params.castShadow)&&(entity.castShadow=params.castShadow),isDefined(params.shadow)&&(isDefined(params.shadow.mapSize)&&entity.shadow?.mapSize.copy(params.shadow.mapSize),isDefined(params.shadow.normalBias)&&entity.shadow&&(entity.shadow.normalBias=params.shadow.normalBias),isDefined(params.shadow?.camera)&&function(params,entity){const{shadow:shadow}=params;isNotDefined(shadow?.camera)||(isDirectionalLight(entity)&&function({shadow:shadow},entity){isNotDefined(shadow?.camera)||(applyCommonCameraParams(shadow.camera,entity),function(params,entity){const{left:left,right:right,top:top,bottom:bottom}=params;isDefined(left)&&(entity.shadow.camera.left=left),isDefined(right)&&(entity.shadow.camera.right=right),isDefined(bottom)&&(entity.shadow.camera.bottom=bottom),isDefined(top)&&(entity.shadow.camera.top=top)}(shadow.camera,entity))}(params,entity),isPointLight(entity)&&function({shadow:shadow},entity){isNotDefined(shadow?.camera)||(applyCommonCameraParams(shadow.camera,entity),applyPerspectiveCameraParams(shadow.camera,entity))}(params,entity),isSpotLight(entity)&&function({shadow:shadow},entity){isNotDefined(shadow?.camera)||(applyCommonCameraParams(shadow.camera,entity),applyPerspectiveCameraParams(shadow.camera,entity))}(params,entity))}(params,entity))}function applyCommonCameraParams(params,entity){if(isNotDefined(params))return;const{far:far,near:near,lookAt:lookAt,up:up,layers:layers,zoom:zoom}=params;isDefined(far)&&(entity.shadow.camera.far=far),isDefined(near)&&(entity.shadow.camera.near=near),isDefined(lookAt)&&entity.shadow.camera.lookAt(lookAt),isDefined(up)&&(entity.shadow.camera.up=(new Vector3).copy(params.up??{x:0,y:1,z:0})),isDefined(layers)&&isDefined(entity.shadow.camera.layers?.mask)&&(entity.shadow.camera.layers.mask=layers??1),isDefined(zoom)&&(entity.shadow.camera.zoom=zoom)}function applyPerspectiveCameraParams(params,entity){const{filmGauge:filmGauge,filmOffset:filmOffset,focus:focus,fov:fov}=params;isDefined(filmGauge)&&(entity.shadow.camera.filmGauge=filmGauge),isDefined(filmOffset)&&(entity.shadow.camera.filmOffset=filmOffset),isDefined(focus)&&(entity.shadow.camera.focus=focus),isDefined(fov)&&(entity.shadow.camera.fov=fov)}export{applyShadowParams};
+//# sourceMappingURL=LightWrapperHelper.js.map

package/dist/Light/Wrappers/LightWrapperHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightWrapperHelper.js","sources":["../../../src/Light/Wrappers/LightWrapperHelper.ts"],"sourcesContent":["import type {\n  TAbstractLightParams,\n  TAnyLight,\n  TDirectionalLight,\n  TLightParams,\n  TPointLight,\n  TShadowCameraParams,\n  TShadowOrthographicCameraParams,\n  TShadowPerspectiveCameraParams,\n  TSpotLight\n} from '@Anarchy/Engine/Light/Models';\nimport { isDirectionalLight, isPointLight, isSpotLight } from '@Anarchy/Engine/Light/Utils';\nimport type { TWriteable } from '@Anarchy/Shared/Utils';\nimport { isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\nimport { Vector3 } from 'three';\n\nexport function applyShadowParams<T extends TAnyLight, P extends TLightParams>(params: P, entity: TWriteable<T>): void {\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(params.castShadow)) entity.castShadow = params.castShadow;\n\n  if (isDefined(params.shadow)) {\n    if (isDefined(params.shadow.mapSize)) entity.shadow?.mapSize.copy(params.shadow.mapSize);\n\n    // eslint-disable-next-line functional/immutable-data\n    if (isDefined(params.shadow.normalBias) && entity.shadow) entity.shadow.normalBias = params.shadow.normalBias;\n    if (isDefined(params.shadow?.camera)) applyShadowCameraParams(params, entity);\n  }\n}\n\nfunction applyShadowCameraParams(params: TAbstractLightParams, entity: TWriteable<TAnyLight>): void {\n  const { shadow } = params;\n  if (isNotDefined(shadow?.camera)) return;\n\n  if (isDirectionalLight(entity)) applyDirectionalLightShadowCameraParams(params, entity);\n  if (isPointLight(entity)) applyPointLightShadowCameraParams(params, entity);\n  if (isSpotLight(entity)) applySpotLightShadowCameraParams(params, entity);\n}\n\nfunction applyCommonCameraParams(params: TShadowCameraParams, entity: TWriteable<TDirectionalLight | TPointLight | TSpotLight>): void {\n  if (isNotDefined(params)) return;\n\n  const { far, near, lookAt, up, layers, zoom } = params;\n\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(far)) entity.shadow.camera.far = far;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(near)) entity.shadow.camera.near = near;\n\n  if (isDefined(lookAt)) entity.shadow.camera.lookAt(lookAt);\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(up)) entity.shadow.camera.up = new Vector3().copy(params.up ?? { x: 0, y: 1, z: 0 });\n\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(layers) && isDefined(entity.shadow.camera.layers?.mask)) entity.shadow.camera.layers.mask = layers ?? 1;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(zoom)) entity.shadow.camera.zoom = zoom;\n}\n\nfunction applyOrthographicCameraParams(params: TShadowOrthographicCameraParams, entity: TWriteable<TDirectionalLight>): void {\n  const { left, right, top, bottom } = params;\n\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(left)) entity.shadow.camera.left = left;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(right)) entity.shadow.camera.right = right;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(bottom)) entity.shadow.camera.bottom = bottom;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(top)) entity.shadow.camera.top = top;\n}\n\nfunction applyPerspectiveCameraParams(params: TShadowPerspectiveCameraParams, entity: TWriteable<TPointLight | TSpotLight>): void {\n  const { filmGauge, filmOffset, focus, fov } = params;\n\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(filmGauge)) entity.shadow.camera.filmGauge = filmGauge;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(filmOffset)) entity.shadow.camera.filmOffset = filmOffset;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(focus)) entity.shadow.camera.focus = focus;\n  // eslint-disable-next-line functional/immutable-data\n  if (isDefined(fov)) entity.shadow.camera.fov = fov;\n}\n\nfunction applyDirectionalLightShadowCameraParams({ shadow }: TAbstractLightParams, entity: TWriteable<TDirectionalLight>): void {\n  if (isNotDefined(shadow?.camera)) return;\n\n  applyCommonCameraParams(shadow.camera, entity);\n  applyOrthographicCameraParams(shadow.camera, entity);\n}\n\nfunction applyPointLightShadowCameraParams({ shadow }: TAbstractLightParams, entity: TWriteable<TPointLight>): void {\n  if (isNotDefined(shadow?.camera)) return;\n\n  applyCommonCameraParams(shadow.camera, entity);\n  applyPerspectiveCameraParams(shadow.camera, entity);\n}\n\nfunction applySpotLightShadowCameraParams({ shadow }: TAbstractLightParams, entity: TWriteable<TSpotLight>): void {\n  if (isNotDefined(shadow?.camera)) return;\n\n  applyCommonCameraParams(shadow.camera, entity);\n  applyPerspectiveCameraParams(shadow.camera, entity);\n}\n"],"names":["applyShadowParams","params","entity","isDefined","castShadow","shadow","mapSize","copy","normalBias","camera","isNotDefined","isDirectionalLight","applyCommonCameraParams","left","right","top","bottom","applyOrthographicCameraParams","applyDirectionalLightShadowCameraParams","isPointLight","applyPerspectiveCameraParams","applyPointLightShadowCameraParams","isSpotLight","applySpotLightShadowCameraParams","applyShadowCameraParams","far","near","lookAt","up","layers","zoom","Vector3","x","y","z","mask","filmGauge","filmOffset","focus","fov"],"mappings":"gMAgBO,SAASA,kBAA+DC,OAAWC,QAEpFC,UAAUF,OAAOG,cAAaF,OAAOE,WAAaH,OAAOG,YAEzDD,UAAUF,OAAOI,UACfF,UAAUF,OAAOI,OAAOC,UAAUJ,OAAOG,QAAQC,QAAQC,KAAKN,OAAOI,OAAOC,SAG5EH,UAAUF,OAAOI,OAAOG,aAAeN,OAAOG,SAAQH,OAAOG,OAAOG,WAAaP,OAAOI,OAAOG,YAC/FL,UAAUF,OAAOI,QAAQI,SAIjC,SAAiCR,OAA8BC,QAC7D,MAAMG,OAAEA,QAAWJ,OACfS,aAAaL,QAAQI,UAErBE,mBAAmBT,SAmDzB,UAAiDG,OAAEA,QAAgCH,QAC7EQ,aAAaL,QAAQI,UAEzBG,wBAAwBP,OAAOI,OAAQP,QA7BzC,SAAuCD,OAAyCC,QAC9E,MAAMW,KAAEA,KAAAC,MAAMA,MAAAC,IAAOA,IAAAC,OAAKA,QAAWf,OAGjCE,UAAUU,QAAOX,OAAOG,OAAOI,OAAOI,KAAOA,MAE7CV,UAAUW,SAAQZ,OAAOG,OAAOI,OAAOK,MAAQA,OAE/CX,UAAUa,UAASd,OAAOG,OAAOI,OAAOO,OAASA,QAEjDb,UAAUY,OAAMb,OAAOG,OAAOI,OAAOM,IAAMA,IACjD,CAmBEE,CAA8BZ,OAAOI,OAAQP,QAC/C,CAxDkCgB,CAAwCjB,OAAQC,QAC5EiB,aAAajB,SAyDnB,UAA2CG,OAAEA,QAAgCH,QACvEQ,aAAaL,QAAQI,UAEzBG,wBAAwBP,OAAOI,OAAQP,QACvCkB,6BAA6Bf,OAAOI,OAAQP,QAC9C,CA9D4BmB,CAAkCpB,OAAQC,QAChEoB,YAAYpB,SA+DlB,UAA0CG,OAAEA,QAAgCH,QACtEQ,aAAaL,QAAQI,UAEzBG,wBAAwBP,OAAOI,OAAQP,QACvCkB,6BAA6Bf,OAAOI,OAAQP,QAC9C,CApE2BqB,CAAiCtB,OAAQC,QACpE,CAX0CsB,CAAwBvB,OAAQC,QAE1E,CAWA,SAASU,wBAAwBX,OAA6BC,QAC5D,GAAIQ,aAAaT,QAAS,OAE1B,MAAMwB,IAAEA,IAAAC,KAAKA,KAAAC,OAAMA,UAAQC,GAAAC,OAAIA,OAAAC,KAAQA,MAAS7B,OAG5CE,UAAUsB,OAAMvB,OAAOG,OAAOI,OAAOgB,IAAMA,KAE3CtB,UAAUuB,QAAOxB,OAAOG,OAAOI,OAAOiB,KAAOA,MAE7CvB,UAAUwB,gBAAgBtB,OAAOI,OAAOkB,OAAOA,QAE/CxB,UAAUyB,MAAK1B,OAAOG,OAAOI,OAAOmB,IAAK,IAAIG,SAAUxB,KAAKN,OAAO2B,IAAM,CAAEI,EAAG,EAAGC,EAAG,EAAGC,EAAG,KAG1F/B,UAAU0B,SAAW1B,UAAUD,OAAOG,OAAOI,OAAOoB,QAAQM,QAAOjC,OAAOG,OAAOI,OAAOoB,OAAOM,KAAON,QAAU,GAEhH1B,UAAU2B,QAAO5B,OAAOG,OAAOI,OAAOqB,KAAOA,KACnD,CAeA,SAASV,6BAA6BnB,OAAwCC,QAC5E,MAAMkC,UAAEA,UAAAC,WAAWA,WAAAC,MAAYA,MAAAC,IAAOA,KAAQtC,OAG1CE,UAAUiC,aAAYlC,OAAOG,OAAOI,OAAO2B,UAAYA,WAEvDjC,UAAUkC,cAAanC,OAAOG,OAAOI,OAAO4B,WAAaA,YAEzDlC,UAAUmC,SAAQpC,OAAOG,OAAOI,OAAO6B,MAAQA,OAE/CnC,UAAUoC,OAAMrC,OAAOG,OAAOI,OAAO8B,IAAMA,IACjD"}

package/dist/Light/Wrappers/PointLightWrapper.js

@@ -0,0 +1,2 @@
+import{PointLight}from"three";import{AbstractLightWrapper}from"./AbstractLightWrapper.js";function PointLightWrapper(params,dependencies){const entity=new PointLight(params.color,params.intensity,params.distance,params.decay);return AbstractLightWrapper(entity,params,dependencies)}export{PointLightWrapper};
+//# sourceMappingURL=PointLightWrapper.js.map

package/dist/Light/Wrappers/PointLightWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointLightWrapper.js","sources":["../../../src/Light/Wrappers/PointLightWrapper.ts"],"sourcesContent":["import type { TAbstractLightWrapper, TLightServiceDependencies, TPointLight, TPointLightParams } from '@Anarchy/Engine/Light/Models';\nimport { PointLight } from 'three';\n\nimport { AbstractLightWrapper } from './AbstractLightWrapper';\n\nexport function PointLightWrapper(params: TPointLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TPointLight> {\n  const entity: TPointLight = new PointLight(params.color, params.intensity, params.distance, params.decay);\n  return AbstractLightWrapper(entity, params, dependencies);\n}\n"],"names":["PointLightWrapper","params","dependencies","entity","PointLight","color","intensity","distance","decay","AbstractLightWrapper"],"mappings":"0FAKO,SAASA,kBAAkBC,OAA2BC,cAC3D,MAAMC,OAAsB,IAAIC,WAAWH,OAAOI,MAAOJ,OAAOK,UAAWL,OAAOM,SAAUN,OAAOO,OACnG,OAAOC,qBAAqBN,OAAQF,OAAQC,aAC9C"}

package/dist/Light/Wrappers/RectAreaLightWrapper.js

@@ -0,0 +1,2 @@
+import{RectAreaLight}from"three";import{AbstractLightWrapper}from"./AbstractLightWrapper.js";function RectAreaLightWrapper(params,dependencies){const entity=new RectAreaLight(params.color,params.intensity,params.height,params.width);return AbstractLightWrapper(entity,params,dependencies)}export{RectAreaLightWrapper};
+//# sourceMappingURL=RectAreaLightWrapper.js.map

package/dist/Light/Wrappers/RectAreaLightWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RectAreaLightWrapper.js","sources":["../../../src/Light/Wrappers/RectAreaLightWrapper.ts"],"sourcesContent":["import type { TAbstractLightWrapper, TLightServiceDependencies, TRectAreaLight, TRectAreaLightParams } from '@Anarchy/Engine/Light/Models';\nimport { RectAreaLight } from 'three';\n\nimport { AbstractLightWrapper } from './AbstractLightWrapper';\n\nexport function RectAreaLightWrapper(params: TRectAreaLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TRectAreaLight> {\n  const entity: TRectAreaLight = new RectAreaLight(params.color, params.intensity, params.height, params.width);\n  return AbstractLightWrapper(entity, params, dependencies);\n}\n"],"names":["RectAreaLightWrapper","params","dependencies","entity","RectAreaLight","color","intensity","height","width","AbstractLightWrapper"],"mappings":"6FAKO,SAASA,qBAAqBC,OAA8BC,cACjE,MAAMC,OAAyB,IAAIC,cAAcH,OAAOI,MAAOJ,OAAOK,UAAWL,OAAOM,OAAQN,OAAOO,OACvG,OAAOC,qBAAqBN,OAAQF,OAAQC,aAC9C"}

package/dist/Light/Wrappers/SpotLightWrapper.js

@@ -0,0 +1,2 @@
+import{SpotLight}from"three";import{AbstractLightWrapper}from"./AbstractLightWrapper.js";function SpotLightWrapper(params,dependencies){const entity=new SpotLight(params.color,params.intensity,params.distance,params.angle,params.penumbra,params.decay);return AbstractLightWrapper(entity,params,dependencies)}export{SpotLightWrapper};
+//# sourceMappingURL=SpotLightWrapper.js.map

package/dist/Light/Wrappers/SpotLightWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpotLightWrapper.js","sources":["../../../src/Light/Wrappers/SpotLightWrapper.ts"],"sourcesContent":["import type { TAbstractLightWrapper, TLightServiceDependencies, TSpotLight, TSpotLightParams } from '@Anarchy/Engine/Light/Models';\nimport { SpotLight } from 'three';\n\nimport { AbstractLightWrapper } from './AbstractLightWrapper';\n\nexport function SpotLightWrapper(params: TSpotLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TSpotLight> {\n  const entity: TSpotLight = new SpotLight(params.color, params.intensity, params.distance, params.angle, params.penumbra, params.decay);\n  return AbstractLightWrapper(entity, params, dependencies);\n}\n"],"names":["SpotLightWrapper","params","dependencies","entity","SpotLight","color","intensity","distance","angle","penumbra","decay","AbstractLightWrapper"],"mappings":"yFAKO,SAASA,iBAAiBC,OAA0BC,cACzD,MAAMC,OAAqB,IAAIC,UAAUH,OAAOI,MAAOJ,OAAOK,UAAWL,OAAOM,SAAUN,OAAOO,MAAOP,OAAOQ,SAAUR,OAAOS,OAChI,OAAOC,qBAAqBR,OAAQF,OAAQC,aAC9C"}

package/dist/LoadingManager/Constants/DefaultSpaceLoadingManagerName.js

@@ -0,0 +1,2 @@
+const DEFAULT_SPACE_LOADING_MANAGER_NAME="DefaultSpaceLoadingManager";export{DEFAULT_SPACE_LOADING_MANAGER_NAME};
+//# sourceMappingURL=DefaultSpaceLoadingManagerName.js.map