@luma.gl/engine 9.2.5 → 9.3.0-alpha.10

package/src/dynamic-texture/texture-data.ts

@@ -0,0 +1,336 @@
+import type {TypedArray, TextureFormat, ExternalImage} from '@luma.gl/core';
+import {isExternalImage, getExternalImageSize} from '@luma.gl/core';
+
+export type TextureImageSource = ExternalImage;
+
+/**
+ * One mip level
+ * Basic data structure is similar to `ImageData`
+ * additional optional fields can describe compressed texture data.
+ */
+export type TextureImageData = {
+  /** Preferred WebGPU style format string. */
+  textureFormat?: TextureFormat;
+  /** WebGPU style format string. Defaults to 'rgba8unorm' */
+  format?: TextureFormat;
+  /** Typed Array with the bytes of the image. @note beware row byte alignment requirements */
+  data: TypedArray;
+  /** Width of the image, in pixels, @note beware row byte alignment requirements */
+  width: number;
+  /** Height of the image, in rows */
+  height: number;
+};
+
+/**
+ * A single mip-level can be initialized by data or an ImageBitmap etc
+ * @note in the WebGPU spec a mip-level is called a subresource
+ */
+export type TextureMipLevelData = TextureImageData | TextureImageSource;
+
+/**
+ * Texture data for one image "slice" (which can consist of multiple miplevels)
+ * Thus data for one slice be a single mip level or an array of miplevels
+ * @note in the WebGPU spec each cross-section image in a 3D texture is called a "slice",
+ * in a array texture each image in the array is called an array "layer"
+ * luma.gl calls one image in a GPU texture a "slice" regardless of context.
+ */
+export type TextureSliceData = TextureMipLevelData | TextureMipLevelData[];
+
+/** Names of cube texture faces */
+export type TextureCubeFace = '+X' | '-X' | '+Y' | '-Y' | '+Z' | '-Z';
+
+/** Array of cube texture faces. @note: index in array is the face index */
+// prettier-ignore
+export const TEXTURE_CUBE_FACES = ['+X', '-X', '+Y', '-Y', '+Z', '-Z'] as const satisfies readonly TextureCubeFace[];
+
+/** Map of cube texture face names to face indexes */
+// prettier-ignore
+export const TEXTURE_CUBE_FACE_MAP = {'+X': 0, '-X': 1, '+Y': 2, '-Y': 3, '+Z': 4, '-Z': 5} as const satisfies Record<TextureCubeFace, number>;
+
+/** @todo - Define what data type is supported for 1D textures. TextureImageData with height = 1 */
+export type Texture1DData = TextureSliceData;
+
+/** Texture data can be one or more mip levels */
+export type Texture2DData = TextureSliceData;
+
+/** 6 face textures */
+export type TextureCubeData = Record<TextureCubeFace, TextureSliceData>;
+
+/** Array of textures */
+export type Texture3DData = TextureSliceData[];
+
+/** Array of textures */
+export type TextureArrayData = TextureSliceData[];
+
+/** Array of 6 face textures */
+export type TextureCubeArrayData = Record<TextureCubeFace, TextureSliceData>[];
+
+type TextureData =
+  | Texture1DData
+  | Texture3DData
+  | TextureArrayData
+  | TextureCubeArrayData
+  | TextureCubeData;
+
+/** Sync data props */
+export type TextureDataProps =
+  | {dimension: '1d'; data: Texture1DData | null}
+  | {dimension?: '2d'; data: Texture2DData | null}
+  | {dimension: '3d'; data: Texture3DData | null}
+  | {dimension: '2d-array'; data: TextureArrayData | null}
+  | {dimension: 'cube'; data: TextureCubeData | null}
+  | {dimension: 'cube-array'; data: TextureCubeArrayData | null};
+
+/** Async data props */
+export type TextureDataAsyncProps =
+  | {dimension: '1d'; data?: Promise<Texture1DData> | Texture1DData | null}
+  | {dimension?: '2d'; data?: Promise<Texture2DData> | Texture2DData | null}
+  | {dimension: '3d'; data?: Promise<Texture3DData> | Texture3DData | null}
+  | {dimension: '2d-array'; data?: Promise<TextureArrayData> | TextureArrayData | null}
+  | {dimension: 'cube'; data?: Promise<TextureCubeData> | TextureCubeData | null}
+  | {dimension: 'cube-array'; data?: Promise<TextureCubeArrayData> | TextureCubeArrayData | null};
+
+/** Describes data for one sub resource (one mip level of one slice (depth or array layer)) */
+export type TextureSubresource = {
+  /** slice (depth or array layer)) */
+  z: number;
+  /** mip level (0 - max mip levels) */
+  mipLevel: number;
+} & (
+  | {
+      type: 'external-image';
+      image: ExternalImage;
+      /** @deprecated is this an appropriate place for this flag? */
+      flipY?: boolean;
+    }
+  | {
+      type: 'texture-data';
+      data: TextureImageData;
+      textureFormat?: TextureFormat;
+    }
+);
+
+/** Check if texture data is a typed array */
+export function isTextureSliceData(data: TextureData): data is TextureImageData {
+  const typedArray = (data as TextureImageData)?.data;
+  return ArrayBuffer.isView(typedArray);
+}
+
+export function getFirstMipLevel(layer: TextureSliceData | null): TextureMipLevelData | null {
+  if (!layer) return null;
+  return Array.isArray(layer) ? (layer[0] ?? null) : layer;
+}
+
+export function getTextureSizeFromData(
+  props: TextureDataProps
+): {width: number; height: number} | null {
+  const {dimension, data} = props;
+  if (!data) {
+    return null;
+  }
+
+  switch (dimension) {
+    case '1d': {
+      const mipLevel = getFirstMipLevel(data);
+      if (!mipLevel) return null;
+      const {width} = getTextureMipLevelSize(mipLevel);
+      return {width, height: 1};
+    }
+    case '2d': {
+      const mipLevel = getFirstMipLevel(data);
+      return mipLevel ? getTextureMipLevelSize(mipLevel) : null;
+    }
+    case '3d':
+    case '2d-array': {
+      if (!Array.isArray(data) || data.length === 0) return null;
+      const mipLevel = getFirstMipLevel(data[0]);
+      return mipLevel ? getTextureMipLevelSize(mipLevel) : null;
+    }
+    case 'cube': {
+      const face = (Object.keys(data)[0] as TextureCubeFace) ?? null;
+      if (!face) return null;
+      const faceData = (data as Record<TextureCubeFace, TextureSliceData>)[face];
+      const mipLevel = getFirstMipLevel(faceData);
+      return mipLevel ? getTextureMipLevelSize(mipLevel) : null;
+    }
+    case 'cube-array': {
+      if (!Array.isArray(data) || data.length === 0) return null;
+      const firstCube = data[0];
+      const face = (Object.keys(firstCube)[0] as TextureCubeFace) ?? null;
+      if (!face) return null;
+      const mipLevel = getFirstMipLevel(firstCube[face]);
+      return mipLevel ? getTextureMipLevelSize(mipLevel) : null;
+    }
+    default:
+      return null;
+  }
+}
+
+function getTextureMipLevelSize(data: TextureMipLevelData): {width: number; height: number} {
+  if (isExternalImage(data)) {
+    return getExternalImageSize(data);
+  }
+  if (typeof data === 'object' && 'width' in data && 'height' in data) {
+    return {width: data.width, height: data.height};
+  }
+  throw new Error('Unsupported mip-level data');
+}
+
+/** Type guard: is a mip-level `TextureImageData` (vs ExternalImage or bare typed array) */
+function isTextureImageData(data: unknown): data is TextureImageData {
+  return (
+    typeof data === 'object' &&
+    data !== null &&
+    'data' in data &&
+    'width' in data &&
+    'height' in data
+  );
+}
+
+function isTypedArrayMipLevelData(data: unknown): data is TypedArray {
+  return ArrayBuffer.isView(data);
+}
+
+export function resolveTextureImageFormat(data: TextureImageData): TextureFormat | undefined {
+  const {textureFormat, format} = data;
+  if (textureFormat && format && textureFormat !== format) {
+    throw new Error(
+      `Conflicting texture formats "${textureFormat}" and "${format}" provided for the same mip level`
+    );
+  }
+  return textureFormat ?? format;
+}
+
+/** Resolve size for a single mip-level datum */
+// function getTextureMipLevelSizeFromData(data: TextureMipLevelData): {
+//   width: number;
+//   height: number;
+// } {
+//   if (this.device.isExternalImage(data)) {
+//     return this.device.getExternalImageSize(data);
+//   }
+//   if (this.isTextureImageData(data)) {
+//     return {width: data.width, height: data.height};
+//   }
+//   // Fallback (should not happen with current types)
+//   throw new Error('Unsupported mip-level data');
+// }
+
+/** Convert cube face label to depth index */
+export function getCubeFaceIndex(face: TextureCubeFace): number {
+  const idx = TEXTURE_CUBE_FACE_MAP[face];
+  if (idx === undefined) throw new Error(`Invalid cube face: ${face}`);
+  return idx;
+}
+
+/** Convert cube face label to texture slice index. Index can be used with `setTexture2DData()`. */
+export function getCubeArrayFaceIndex(cubeIndex: number, face: TextureCubeFace): number {
+  return 6 * cubeIndex + getCubeFaceIndex(face);
+}
+
+// ------------------ Upload helpers ------------------
+
+/** Experimental: Set multiple mip levels (1D) */
+export function getTexture1DSubresources(data: Texture1DData): TextureSubresource[] {
+  // Not supported in WebGL; left explicit
+  throw new Error('setTexture1DData not supported in WebGL.');
+  // const subresources: TextureSubresource[] = [];
+  // return subresources;
+}
+
+/** Normalize 2D layer payload into an array of mip-level items */
+function _normalizeTexture2DData(
+  data: Texture2DData
+): (TextureImageData | ExternalImage | TypedArray)[] {
+  return Array.isArray(data) ? data : [data];
+}
+
+/** Experimental: Set multiple mip levels (2D), optionally at `z` (depth/array index) */
+export function getTexture2DSubresources(
+  slice: number,
+  lodData: Texture2DData,
+  baseLevelSize?: {width: number; height: number},
+  textureFormat?: TextureFormat
+): TextureSubresource[] {
+  const lodArray = _normalizeTexture2DData(lodData);
+  const z = slice;
+
+  const subresources: TextureSubresource[] = [];
+
+  for (let mipLevel = 0; mipLevel < lodArray.length; mipLevel++) {
+    const imageData = lodArray[mipLevel];
+    if (isExternalImage(imageData)) {
+      subresources.push({
+        type: 'external-image',
+        image: imageData,
+        z,
+        mipLevel
+      });
+    } else if (isTextureImageData(imageData)) {
+      subresources.push({
+        type: 'texture-data',
+        data: imageData,
+        textureFormat: resolveTextureImageFormat(imageData),
+        z,
+        mipLevel
+      });
+    } else if (isTypedArrayMipLevelData(imageData) && baseLevelSize) {
+      subresources.push({
+        type: 'texture-data',
+        data: {
+          data: imageData,
+          width: Math.max(1, baseLevelSize.width >> mipLevel),
+          height: Math.max(1, baseLevelSize.height >> mipLevel),
+          ...(textureFormat ? {format: textureFormat} : {})
+        },
+        textureFormat,
+        z,
+        mipLevel
+      });
+    } else {
+      throw new Error('Unsupported 2D mip-level payload');
+    }
+  }
+
+  return subresources;
+}
+
+/** 3D: multiple depth slices, each may carry multiple mip levels */
+export function getTexture3DSubresources(data: Texture3DData): TextureSubresource[] {
+  const subresources: TextureSubresource[] = [];
+  for (let depth = 0; depth < data.length; depth++) {
+    subresources.push(...getTexture2DSubresources(depth, data[depth]));
+  }
+  return subresources;
+}
+
+/** 2D array: multiple layers, each may carry multiple mip levels */
+export function getTextureArraySubresources(data: TextureArrayData): TextureSubresource[] {
+  const subresources: TextureSubresource[] = [];
+  for (let layer = 0; layer < data.length; layer++) {
+    subresources.push(...getTexture2DSubresources(layer, data[layer]));
+  }
+  return subresources;
+}
+
+/** Cube: 6 faces, each may carry multiple mip levels */
+export function getTextureCubeSubresources(data: TextureCubeData): TextureSubresource[] {
+  const subresources: TextureSubresource[] = [];
+  for (const [face, faceData] of Object.entries(data) as [TextureCubeFace, TextureSliceData][]) {
+    const faceDepth = getCubeFaceIndex(face);
+    subresources.push(...getTexture2DSubresources(faceDepth, faceData));
+  }
+  return subresources;
+}
+
+/** Cube array: multiple cubes (faces×layers), each face may carry multiple mips */
+export function getTextureCubeArraySubresources(data: TextureCubeArrayData): TextureSubresource[] {
+  const subresources: TextureSubresource[] = [];
+  data.forEach((cubeData, cubeIndex) => {
+    for (const [face, faceData] of Object.entries(cubeData)) {
+      const faceDepth = getCubeArrayFaceIndex(cubeIndex, face as TextureCubeFace);
+      subresources.push(...getTexture2DSubresources(faceDepth, faceData));
+    }
+  });
+  return subresources;
+}

package/src/geometries/cone-geometry.ts

@@ -2,13 +2,18 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {TruncatedConeGeometryProps} from './truncated-cone-geometry';
 import {TruncatedConeGeometry} from './truncated-cone-geometry';
 import {uid} from '../utils/uid';
 
-export type ConeGeometryProps = {
+export type ConeGeometryProps = Omit<
+  TruncatedConeGeometryProps,
+  'topRadius' | 'bottomRadius' | 'topCap' | 'bottomCap'
+> & {
   id?: string;
   radius?: number;
   cap?: boolean;
+  attributes?: any;
 };
 
 export class ConeGeometry extends TruncatedConeGeometry {

package/src/geometries/cylinder-geometry.ts

@@ -2,10 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {TruncatedConeGeometryProps} from './truncated-cone-geometry';
 import {TruncatedConeGeometry} from './truncated-cone-geometry';
 import {uid} from '../utils/uid';
 
-export type CylinderGeometryProps = {
+export type CylinderGeometryProps = Omit<
+  TruncatedConeGeometryProps,
+  'topRadius' | 'bottomRadius'
+> & {
   id?: string;
   radius?: number;
   attributes?: any;

package/src/geometry/gpu-geometry.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import type {PrimitiveTopology, BufferLayout} from '@luma.gl/core';
-import {Device, Buffer, getVertexFormatFromAttribute} from '@luma.gl/core';
+import {Device, Buffer, vertexFormatDecoder} from '@luma.gl/core';
 import type {Geometry} from '../geometry/geometry';
 import {uid} from '../utils/uid';
 
@@ -127,8 +127,13 @@ export function getAttributeBuffersFromGeometry(
         id: `${attributeName}-buffer`
       });
       const {value, size, normalized} = attribute;
-      // @ts-expect-error
-      bufferLayout.push({name, format: getVertexFormatFromAttribute(value, size, normalized)});
+      if (size === undefined) {
+        throw new Error(`Attribute ${attributeName} is missing a size`);
+      }
+      bufferLayout.push({
+        name,
+        format: vertexFormatDecoder.getVertexFormatFromAttribute(value, size, normalized)
+      });
     }
   }
 

package/src/index.ts

@@ -19,6 +19,10 @@ export {makeAnimationLoop} from './animation-loop/make-animation-loop';
 
 export type {ModelProps} from './model/model';
 export {Model} from './model/model';
+export type {MaterialProps} from './material/material';
+export {Material} from './material/material';
+export type {MaterialFactoryProps} from './material/material-factory';
+export {MaterialFactory} from './material/material-factory';
 
 // Transforms
 export type {BufferTransformProps} from './compute/buffer-transform';
@@ -26,14 +30,20 @@ export {BufferTransform} from './compute/buffer-transform';
 export type {TextureTransformProps} from './compute/texture-transform';
 export {TextureTransform} from './compute/texture-transform';
 
-export {PipelineFactory} from './factories/pipeline-factory';
-export {ShaderFactory} from './factories/shader-factory';
-
 // Models
 export type {ClipSpaceProps} from './models/clip-space';
 export {ClipSpace} from './models/clip-space';
 export type {BackgroundTextureModelProps} from './models/billboard-texture-model';
 export {BackgroundTextureModel} from './models/billboard-texture-model';
+export type {
+  BaseLightModelProps,
+  PointLightModelProps,
+  SpotLightModelProps,
+  DirectionalLightModelProps
+} from './models/light-model-utils';
+export {PointLightModel} from './models/point-light-model';
+export {SpotLightModel} from './models/spot-light-model';
+export {DirectionalLightModel} from './models/directional-light-model';
 
 // Scenegraph Core nodes
 export {ScenegraphNode} from './scenegraph/scenegraph-node';
@@ -83,19 +93,32 @@ export {Computation} from './compute/computation';
 export type {
   TextureCubeFace,
   TextureImageData,
-  TextureData,
   Texture1DData,
   Texture2DData,
   Texture3DData,
   TextureCubeData,
   TextureArrayData,
   TextureCubeArrayData
-} from './async-texture/async-texture';
+} from './dynamic-texture/texture-data';
 
-export type {AsyncTextureProps} from './async-texture/async-texture';
-export {AsyncTexture} from './async-texture/async-texture';
+export type {DynamicTextureProps} from './dynamic-texture/dynamic-texture';
+export {DynamicTexture} from './dynamic-texture/dynamic-texture';
 
-export {PickingManager} from './modules/picking/picking-manager';
+export type {
+  PickInfo,
+  PickingMode,
+  ResolvedPickingMode,
+  PickingBackend,
+  PickingManagerProps,
+  ResolvedPickingBackend
+} from './modules/picking/picking-manager';
+export {
+  PickingManager,
+  supportsIndexPicking,
+  resolvePickingMode,
+  resolvePickingBackend
+} from './modules/picking/picking-manager';
+export {picking} from './modules/picking/picking';
 export {picking as indexPicking} from './modules/picking/index-picking';
 export {picking as colorPicking} from './modules/picking/color-picking';
 
@@ -107,3 +130,10 @@ export {
 // DEPRECATED
 
 export {LegacyPickingManager} from './modules/picking/legacy-picking-manager';
+export {legacyColorPicking} from './modules/picking/legacy-color-picking';
+
+import {DynamicTexture, type DynamicTextureProps} from './dynamic-texture/dynamic-texture';
+/** @deprecated use DynamicTexture */
+export const AsyncTexture = DynamicTexture;
+/** @deprecated use DynamicTextureProps */
+export type AsyncTextureProps = DynamicTextureProps;

package/src/material/material-factory.ts

@@ -0,0 +1,157 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Binding, BindingsByGroup, Device} from '@luma.gl/core';
+import type {ShaderModule} from '@luma.gl/shadertools';
+import {ShaderInputs} from '../shader-inputs';
+import type {Material, MaterialProps} from './material';
+import {Material as MaterialClass} from './material';
+
+type MaterialModuleProps = Partial<Record<string, Record<string, unknown>>>;
+type MaterialBindings = Record<
+  string,
+  Binding | import('../dynamic-texture/dynamic-texture').DynamicTexture
+>;
+
+/** Logical bind-group slot reserved for material-owned bindings. */
+export const MATERIAL_BIND_GROUP = 3;
+
+/** Construction props for {@link MaterialFactory}. */
+export type MaterialFactoryProps = {
+  /** Shader modules that define the material schema for bind group `3`. */
+  modules?: ShaderModule[];
+};
+
+/**
+ * Creates typed {@link Material} instances for a stable material binding schema.
+ *
+ * @example
+ * ```ts
+ * const pbrFactory = new MaterialFactory<
+ *   {pbrMaterial: PBRMaterialUniforms},
+ *   PBRMaterialBindings
+ * >(device, {modules: [pbrMaterial]});
+ * const pbr = pbrFactory.createMaterial();
+ * pbr.setProps({pbrMaterial: {baseColorFactor: [1, 0, 0, 1]}});
+ * const pbrVariant = pbr.clone({bindings: {pbr_baseColorSampler: texture}});
+ * ```
+ *
+ * @example
+ * ```ts
+ * const phongFactory = new MaterialFactory<
+ *   {phongMaterial: PhongMaterialProps},
+ *   {}
+ * >(device, {modules: [phongMaterial]});
+ * const phong = phongFactory.createMaterial();
+ * phong.setProps({phongMaterial: {ambient: 0.4, diffuse: 0.7}});
+ * const phongVariant = phong.clone({moduleProps: {phongMaterial: {shininess: 64}}});
+ * ```
+ *
+ * @example
+ * ```ts
+ * const gouraudFactory = new MaterialFactory<
+ *   {gouraudMaterial: GouraudMaterialProps},
+ *   {}
+ * >(device, {modules: [gouraudMaterial]});
+ * const gouraud = gouraudFactory.createMaterial();
+ * gouraud.setProps({gouraudMaterial: {ambient: 0.25}});
+ * const gouraudVariant = gouraud.clone({moduleProps: {gouraudMaterial: {diffuse: 0.8}}});
+ * ```
+ */
+export class MaterialFactory<
+  TModuleProps extends MaterialModuleProps = MaterialModuleProps,
+  TBindings extends MaterialBindings = MaterialBindings
+> {
+  /** Device that creates materials for this schema. */
+  readonly device: Device;
+  /** Shader modules that define the material schema. */
+  readonly modules: ShaderModule[];
+
+  private _materialBindingNames: Set<string>;
+  private _materialModuleNames: Set<string>;
+
+  constructor(device: Device, props: MaterialFactoryProps = {}) {
+    this.device = device;
+    this.modules = props.modules || [];
+
+    const shaderInputs = new ShaderInputs(
+      Object.fromEntries(this.modules.map(module => [module.name, module]))
+    );
+    this._materialBindingNames = getMaterialBindingNames(shaderInputs);
+    this._materialModuleNames = getMaterialModuleNames(shaderInputs);
+  }
+
+  /** Creates one typed material instance for this factory's schema. */
+  createMaterial(
+    props: Omit<MaterialProps<TModuleProps, TBindings>, 'factory' | 'modules'> = {}
+  ): Material<TModuleProps, TBindings> {
+    return new MaterialClass<TModuleProps, TBindings>(this.device, {
+      ...props,
+      factory: this
+    });
+  }
+
+  /** Returns the logical material-owned resource binding names. */
+  getBindingNames(): string[] {
+    return Array.from(this._materialBindingNames);
+  }
+
+  /** Returns `true` when the supplied binding belongs to this material schema. */
+  ownsBinding(bindingName: string): boolean {
+    if (this._materialBindingNames.has(bindingName)) {
+      return true;
+    }
+
+    const aliasedModuleName = getModuleNameFromUniformBinding(bindingName);
+    return aliasedModuleName ? this._materialModuleNames.has(aliasedModuleName) : false;
+  }
+
+  /** Returns `true` when the supplied shader module is owned by this material schema. */
+  ownsModule(moduleName: string): boolean {
+    return this._materialModuleNames.has(moduleName);
+  }
+
+  /** Packages resolved material bindings into bind group `3`. */
+  getBindingsByGroup(
+    bindings: Partial<{[K in keyof TBindings]: Binding}> & Record<string, Binding>
+  ): BindingsByGroup {
+    return Object.keys(bindings).length > 0 ? {[MATERIAL_BIND_GROUP]: bindings} : {};
+  }
+}
+
+/** Returns the module name corresponding to an auto-generated `*Uniforms` binding. */
+export function getModuleNameFromUniformBinding(bindingName: string): string | null {
+  return bindingName.endsWith('Uniforms') ? bindingName.slice(0, -'Uniforms'.length) : null;
+}
+
+function getMaterialBindingNames(shaderInputs: ShaderInputs): Set<string> {
+  const bindingNames = new Set<string>();
+
+  for (const module of Object.values(shaderInputs.modules)) {
+    for (const binding of module.bindingLayout || []) {
+      if (binding.group === MATERIAL_BIND_GROUP) {
+        bindingNames.add(binding.name);
+      }
+    }
+  }
+
+  return bindingNames;
+}
+
+function getMaterialModuleNames(shaderInputs: ShaderInputs): Set<string> {
+  const moduleNames = new Set<string>();
+
+  for (const module of Object.values(shaderInputs.modules)) {
+    if (
+      module.name &&
+      module.bindingLayout?.some(
+        binding => binding.group === MATERIAL_BIND_GROUP && binding.name === module.name
+      )
+    ) {
+      moduleNames.add(module.name);
+    }
+  }
+
+  return moduleNames;
+}