avoid bundle of index.js if there is a change that is not a .ts file. (#1145)

* avoid bundle of index.js if there is a change that is not a .ts file.
change delay to 800ms

* avoid re-writing entity-names all the time when there is no change

* add another validation to avoid reading the file every time

* do not merge this commit

* avoid updating the transform if there is no changes

* remvoe unnecessary code

* fix change files from node_modules

* fix path with special characters

* remove logs

Author: gonpombo8

packages/@dcl/inspector/src/lib/babylon/decentraland/gizmo-manager.ts

@@ -18,6 +18,7 @@ import { SceneContext } from './SceneContext'
 import { PatchedGizmoManager } from './gizmo-patch'
 import { ROOT } from '../../sdk/tree'
 import { LEFT_BUTTON } from './mouse-utils'
+import { recursiveCheck } from 'jest-matcher-deep-close-to/lib/recursiveCheck'
 
 const GIZMO_DUMMY_NODE = 'GIZMO_DUMMY_NODE'
 
@@ -160,12 +161,16 @@ export function createGizmoManager(context: SceneContext) {
 
   function updateEntityTransform(entity: Entity, newTransform: TransformType) {
     const { position, scale, rotation, parent } = newTransform
-    context.operations.updateValue(context.Transform, entity, {
+    const transform = {
       position: DclVector3.create(position.x, position.y, position.z),
       rotation: DclQuaternion.create(rotation.x, rotation.y, rotation.z, rotation.w),
       scale: DclVector3.create(scale.x, scale.y, scale.z),
       parent
-    })
+    }
+    if (!recursiveCheck(context.Transform.get(entity), transform, 2)) {
+      return
+    }
+    context.operations.updateValue(context.Transform, entity, transform)
   }
 
   /**

packages/@dcl/inspector/src/lib/data-layer/host/utils/engine-to-composite.ts

@@ -141,6 +141,8 @@ export function dumpEngineToCrdtCommands(engine: IEngine): Uint8Array {
  * @param fs FileSystem interface for writing the file
  * @returns Promise that resolves when the file has been written
  */
+
+let __ENTITY_NAMES_CACHE: Set<string> = new Set()
 export async function generateEntityNamesType(
   engine: IEngine,
   outputPath: string = 'scene-entity-names.d.ts',
@@ -149,7 +151,6 @@ export async function generateEntityNamesType(
 ): Promise<void> {
   try {
     // Find the Name component definition
-
     const NameComponent: typeof Name = engine.getComponentOrNull(Name.componentId) as typeof Name
 
     if (!NameComponent) {
@@ -166,9 +167,16 @@ export async function generateEntityNamesType(
 
     // Sort names for consistency
     names.sort()
+    const namesSet = new Set(names)
+
+    if (namesSet.difference(__ENTITY_NAMES_CACHE).size === 0) {
+      return
+    }
+
+    __ENTITY_NAMES_CACHE = namesSet
 
     // Remove duplicates
-    const uniqueNames = Array.from(new Set(names))
+    const uniqueNames = Array.from(namesSet)
 
     // Generate valid TypeScript identifiers and handle duplicates in a single pass
     const validNameMap = new Map<string, string>()
@@ -208,9 +216,19 @@ export async function generateEntityNamesType(
 
     fileContent += `} \n`
 
-    // Write to file
+    // Check if file exists and compare content before writing
+    const fileExists = await fs.existFile(outputPath)
+    if (fileExists) {
+      const existingContent = (await fs.readFile(outputPath)).toString('utf-8')
+      if (existingContent === fileContent) {
+        // Content is identical, no need to write
+        return
+      }
+    }
+
+    // Write to file only if content is different or file doesn't exist
     await fs.writeFile(outputPath, Buffer.from(fileContent, 'utf-8'))
   } catch (e) {
-    console.error('Fail to generate entity names types', e)
+    console.error(`Fail to generate entity names types: ${e}\n`)
   }
 }

packages/@dcl/sdk-commands/src/commands/start/server/file-watch-notifier.ts

@@ -11,28 +11,23 @@ import {
   WsSceneMessage,
   UpdateModelType
 } from '@dcl/protocol/out-js/decentraland/sdk/development/local_development.gen'
+import { debounce } from '../../../logic/debounce'
 
-function debounce<T extends (...args: any[]) => void>(callback: T, delay: number) {
-  let debounceTimer: NodeJS.Timeout
-  return (...args: Parameters<T>) => {
-    clearTimeout(debounceTimer)
-    debounceTimer = setTimeout(() => callback(...args), delay)
-  }
-}
 /**
  * This function gets file modification events and sends them to all the connected
  * websockets, it is used to hot-reload assets of the scene.
  *
  * IMPORTANT: this is a legacy protocol and needs to be revisited for SDK7
  */
 export async function wireFileWatcherToWebSockets(
-  components: Pick<PreviewComponents, 'fs' | 'ws'>,
+  components: Pick<PreviewComponents, 'fs' | 'ws' | 'logger'>,
   projectRoot: string,
   projectKind: ProjectUnion['kind'],
   desktopClient: boolean
 ) {
   const ignored = await getDCLIgnorePatterns(components, projectRoot)
   const sceneId = b64HashingFunction(projectRoot)
+
   chokidar
     .watch(path.resolve(projectRoot), {
       atomic: false,
@@ -52,7 +47,7 @@ export async function wireFileWatcherToWebSockets(
           updateScene(sceneId, file)
         }
         return __LEGACY__updateScene(projectRoot, sceneUpdateClients, projectKind)
-      }, 500)
+      }, 800)
     )
 }
 

packages/@dcl/sdk-commands/src/logic/bundle.ts

@@ -16,6 +16,8 @@ import { printProgressInfo, printProgressStep, printWarning } from './beautiful-
 import { CliError } from './error'
 import { getAllComposites } from './composite'
 import { isEditorScene } from './project-validations'
+import { watch } from 'chokidar'
+import { debounce } from './debounce'
 
 export type BundleComponents = Pick<CliComponents, 'logger' | 'fs'>
 
@@ -197,9 +199,34 @@ export async function bundleSingleProject(components: BundleComponents, options:
 
   /* istanbul ignore if */
   if (options.watch) {
-    await context.watch({})
+    // Instead of using esbuild's watch, we create our own watcher
+    const watcher = watch(path.resolve(options.workingDirectory), {
+      ignored: ['**/dist/**', '**/*.crdt', '**/*.composite', path.resolve(options.outputFile)],
+      ignoreInitial: true
+    })
+
+    const debouncedRebuild = debounce(async () => {
+      try {
+        await context.rebuild()
+        printProgressInfo(components.logger, `Bundle saved ${colors.bold(options.outputFile)}`)
+      } catch (err: any) {
+        /* istanbul ignore next */
+        components.logger.error(err.toString())
+      }
+    }, 100)
+
+    watcher.on('all', async (event, filePath) => {
+      // Only rebuild for TypeScript and JavaScript files
+      if (/\.(ts|tsx|js|jsx)$/.test(filePath)) {
+        printProgressInfo(components.logger, `File ${filePath} changed, rebuilding...`)
+        debouncedRebuild()
+      }
+    })
 
+    // Do initial build
+    await context.rebuild()
     printProgressInfo(components.logger, `Bundle saved ${colors.bold(options.outputFile)}`)
+    printProgressInfo(components.logger, `The compiler is watching for changes`)
   } else {
     try {
       await context.rebuild()

packages/@dcl/sdk-commands/src/logic/debounce.ts

@@ -0,0 +1,7 @@
+export function debounce<T extends (...args: any[]) => void>(callback: T, delay: number) {
+  let debounceTimer: NodeJS.Timeout
+  return (...args: Parameters<T>) => {
+    clearTimeout(debounceTimer)
+    debounceTimer = setTimeout(() => callback(...args), delay)
+  }
+}

scripts/prepare.spec.ts

@@ -129,26 +129,3 @@ function installCrossDependencies(...paths: string[]) {
     }
   }
 }
-
-function checkNoLocalPackages(...paths: string[]) {
-  for (const path of paths) {
-    const packageJson = resolve(path, 'package.json')
-    it('checking ' + packageJson, async () => {
-      const { dependencies, devDependencies } = JSON.parse(await readFile(packageJson, 'utf-8'))
-      const errors: string[] = []
-      for (const [key, value] of Object.entries({ ...dependencies, ...devDependencies } as Record<string, string>)) {
-        if (
-          value.startsWith('file:') ||
-          value.startsWith('http:') ||
-          value.startsWith('https:') ||
-          value.startsWith('git:')
-        ) {
-          errors.push(`Dependency ${key} is not pointing to a published version: ${value}`)
-        }
-      }
-      if (errors.length) {
-        throw new Error(errors.join('\n'))
-      }
-    })
-  }
-}