@webiny/project 0.0.0-unstable.61c048f412

package/features/Watch/initInvocationForwarding.js

@@ -0,0 +1,110 @@
+import path from "path";
+import { Worker } from "worker_threads";
+import { compress, decompress } from "@webiny/utils/compression/gzip.js";
+import mqtt from "mqtt";
+const WEBINY_WATCH_FN_INVOCATION_EVENT = "webiny.watch.functionInvocation";
+const WEBINY_WATCH_FN_INVOCATION_RESULT_EVENT = "webiny.watch.functionInvocationResult";
+const WEBINY_WATCH_FN_INVOCATION_HANDSHAKE_EVENT = "webiny.watch.functionInvocationHandshake";
+const WATCH_WORKER_PATH = path.join(import.meta.dirname, "localInvocationWorker.js");
+const jsonStringifyAndCompress = input => {
+  const jsonStringInput = JSON.stringify(input);
+  return compress(jsonStringInput);
+};
+const decompressAndJsonParse = async input => {
+  const inputBuffer = Buffer.from(input);
+  const jsonStringResult = await decompress(inputBuffer);
+  const value = jsonStringResult?.toString ? jsonStringResult.toString("utf-8") : jsonStringResult;
+  return JSON.parse(value);
+};
+export const initInvocationForwarding = async ({
+  iotEndpoint,
+  iotEndpointTopic,
+  sessionId,
+  functionsList
+}) => {
+  const client = await mqtt.connectAsync(iotEndpoint);
+  await client.subscribeAsync(iotEndpointTopic);
+  client.on("message", async (_, message) => {
+    const payload = JSON.parse(message.toString());
+    if (payload.eventType !== WEBINY_WATCH_FN_INVOCATION_EVENT) {
+      return;
+    }
+    if (payload.data.sessionId !== sessionId) {
+      return;
+    }
+    await client.publish(iotEndpointTopic, JSON.stringify({
+      eventType: WEBINY_WATCH_FN_INVOCATION_HANDSHAKE_EVENT,
+      eventId: new Date().getTime(),
+      data: {
+        originalEventId: payload.eventId,
+        compressedResult: null,
+        compressedError: null
+      }
+    }));
+    const invokedLambdaFunction = functionsList.list.find(lambdaFunction => lambdaFunction.name === payload.data.functionName);
+    if (!invokedLambdaFunction) {
+      throw new Error(`Lambda function "${payload.data.functionName}" not found.`);
+    }
+    try {
+      const result = await new Promise(async (resolve, reject) => {
+        const worker = new Worker(WATCH_WORKER_PATH, {
+          env: {
+            ...payload.data.env,
+            WEBINY_WATCH_LOCAL_INVOCATION: "1"
+          },
+          workerData: {
+            handler: {
+              path: invokedLambdaFunction.path,
+              args: await decompressAndJsonParse(payload.data.compressedArgs)
+            }
+          }
+        });
+        const {
+          default: exitHook
+        } = await import(/* webpackChunkName: "exit-hook" */"exit-hook");
+        const unsubscribeExitHook = exitHook(async () => {
+          await worker.terminate();
+        });
+        worker.on("message", message => {
+          unsubscribeExitHook();
+          const {
+            success,
+            result,
+            error
+          } = JSON.parse(message);
+          if (success) {
+            resolve(result);
+          } else {
+            reject(error);
+          }
+        });
+      });
+      await client.publish(iotEndpointTopic, JSON.stringify({
+        eventType: WEBINY_WATCH_FN_INVOCATION_RESULT_EVENT,
+        eventId: new Date().getTime(),
+        data: {
+          originalEventId: payload.eventId,
+          compressedResult: await jsonStringifyAndCompress(result),
+          compressedError: null
+        }
+      }));
+    } catch (error) {
+      console.log(error);
+      await client.publish(iotEndpointTopic, JSON.stringify({
+        eventType: WEBINY_WATCH_FN_INVOCATION_RESULT_EVENT,
+        eventId: new Date().getTime(),
+        data: {
+          originalEventId: payload.eventId,
+          compressedResult: null,
+          compressedError: await jsonStringifyAndCompress({
+            message: error.message,
+            stack: error.stack
+          })
+        }
+      }));
+    }
+  });
+  return client;
+};
+
+//# sourceMappingURL=initInvocationForwarding.js.map

package/features/Watch/initInvocationForwarding.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["path","Worker","compress","decompress","mqtt","WEBINY_WATCH_FN_INVOCATION_EVENT","WEBINY_WATCH_FN_INVOCATION_RESULT_EVENT","WEBINY_WATCH_FN_INVOCATION_HANDSHAKE_EVENT","WATCH_WORKER_PATH","join","import","meta","dirname","jsonStringifyAndCompress","input","jsonStringInput","JSON","stringify","decompressAndJsonParse","inputBuffer","Buffer","from","jsonStringResult","value","toString","parse","initInvocationForwarding","iotEndpoint","iotEndpointTopic","sessionId","functionsList","client","connectAsync","subscribeAsync","on","_","message","payload","eventType","data","publish","eventId","Date","getTime","originalEventId","compressedResult","compressedError","invokedLambdaFunction","list","find","lambdaFunction","name","functionName","Error","result","Promise","resolve","reject","worker","env","WEBINY_WATCH_LOCAL_INVOCATION","workerData","handler","args","compressedArgs","default","exitHook","unsubscribeExitHook","terminate","success","error","console","log","stack"],"sources":["initInvocationForwarding.ts"],"sourcesContent":["import path from \"path\";\nimport { Worker } from \"worker_threads\";\nimport { compress, decompress } from \"@webiny/utils/compression/gzip.js\";\nimport mqtt from \"mqtt\";\nimport { type ListAppLambdaFunctionsService } from \"~/abstractions/index.js\";\n\nconst WEBINY_WATCH_FN_INVOCATION_EVENT = \"webiny.watch.functionInvocation\";\nconst WEBINY_WATCH_FN_INVOCATION_RESULT_EVENT = \"webiny.watch.functionInvocationResult\";\nconst WEBINY_WATCH_FN_INVOCATION_HANDSHAKE_EVENT = \"webiny.watch.functionInvocationHandshake\";\n\nconst WATCH_WORKER_PATH = path.join(import.meta.dirname, \"localInvocationWorker.js\");\n\nconst jsonStringifyAndCompress = (input: Record<string, any>): Promise<Buffer> => {\n    const jsonStringInput = JSON.stringify(input);\n    return compress(jsonStringInput);\n};\n\nconst decompressAndJsonParse = async (input: string) => {\n    const inputBuffer = Buffer.from(input);\n    const jsonStringResult = await decompress(inputBuffer);\n\n    const value = jsonStringResult?.toString\n        ? jsonStringResult.toString(\"utf-8\")\n        : (jsonStringResult as unknown as string);\n\n    return JSON.parse(value);\n};\n\nexport interface IInitInvocationForwardingParams {\n    iotEndpoint: string;\n    iotEndpointTopic: string;\n    sessionId: number;\n    functionsList: ListAppLambdaFunctionsService.Result;\n}\n\nexport const initInvocationForwarding = async ({\n    iotEndpoint,\n    iotEndpointTopic,\n    sessionId,\n    functionsList\n}: IInitInvocationForwardingParams) => {\n    const client = await mqtt.connectAsync(iotEndpoint);\n\n    await client.subscribeAsync(iotEndpointTopic);\n\n    client.on(\"message\", async (_, message) => {\n        const payload = JSON.parse(message.toString());\n\n        if (payload.eventType !== WEBINY_WATCH_FN_INVOCATION_EVENT) {\n            return;\n        }\n\n        if (payload.data.sessionId !== sessionId) {\n            return;\n        }\n\n        await client.publish(\n            iotEndpointTopic,\n            JSON.stringify({\n                eventType: WEBINY_WATCH_FN_INVOCATION_HANDSHAKE_EVENT,\n                eventId: new Date().getTime(),\n                data: {\n                    originalEventId: payload.eventId,\n                    compressedResult: null,\n                    compressedError: null\n                }\n            })\n        );\n\n        const invokedLambdaFunction = functionsList.list.find(\n            lambdaFunction => lambdaFunction.name === payload.data.functionName\n        );\n        if (!invokedLambdaFunction) {\n            throw new Error(`Lambda function \"${payload.data.functionName}\" not found.`);\n        }\n\n        try {\n            const result = await new Promise<Record<string, any>>(async (resolve, reject) => {\n                const worker = new Worker(WATCH_WORKER_PATH, {\n                    env: { ...payload.data.env, WEBINY_WATCH_LOCAL_INVOCATION: \"1\" },\n                    workerData: {\n                        handler: {\n                            path: invokedLambdaFunction.path,\n                            args: await decompressAndJsonParse(payload.data.compressedArgs)\n                        }\n                    }\n                });\n\n                const { default: exitHook } = await import(\n                    /* webpackChunkName: \"exit-hook\" */ \"exit-hook\"\n                );\n\n                const unsubscribeExitHook = exitHook(async () => {\n                    await worker.terminate();\n                });\n\n                worker.on(\"message\", message => {\n                    unsubscribeExitHook();\n\n                    const { success, result, error } = JSON.parse(message);\n                    if (success) {\n                        resolve(result);\n                    } else {\n                        reject(error);\n                    }\n                });\n            });\n\n            await client.publish(\n                iotEndpointTopic,\n                JSON.stringify({\n                    eventType: WEBINY_WATCH_FN_INVOCATION_RESULT_EVENT,\n                    eventId: new Date().getTime(),\n                    data: {\n                        originalEventId: payload.eventId,\n                        compressedResult: await jsonStringifyAndCompress(result),\n                        compressedError: null\n                    }\n                })\n            );\n        } catch (error) {\n            console.log(error);\n            await client.publish(\n                iotEndpointTopic,\n                JSON.stringify({\n                    eventType: WEBINY_WATCH_FN_INVOCATION_RESULT_EVENT,\n                    eventId: new Date().getTime(),\n                    data: {\n                        originalEventId: payload.eventId,\n                        compressedResult: null,\n                        compressedError: await jsonStringifyAndCompress({\n                            message: error.message,\n                            stack: error.stack\n                        })\n                    }\n                })\n            );\n        }\n    });\n\n    return client;\n};\n"],"mappings":"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","ignoreList":[]}

package/features/Watch/localInvocationWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/features/Watch/localInvocationWorker.js

@@ -0,0 +1,36 @@
+import { parentPort, workerData } from "worker_threads";
+const {
+  handler: handlerParams
+} = workerData;
+try {
+  const {
+    handler
+  } = await import(handlerParams.path);
+  const result = await handler(...handlerParams.args);
+  parentPort.postMessage(JSON.stringify({
+    success: true,
+    result,
+    error: null
+  }));
+} catch (error) {
+  const {
+    message,
+    code,
+    data,
+    stack
+  } = error;
+  parentPort.postMessage(JSON.stringify({
+    success: false,
+    result: null,
+    error: {
+      message,
+      code,
+      data,
+      stack
+    }
+  }));
+} finally {
+  process.exit(0);
+}
+
+//# sourceMappingURL=localInvocationWorker.js.map

package/features/Watch/localInvocationWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["parentPort","workerData","handler","handlerParams","path","result","args","postMessage","JSON","stringify","success","error","message","code","data","stack","process","exit"],"sources":["localInvocationWorker.ts"],"sourcesContent":["import { parentPort, workerData } from \"worker_threads\";\n\nconst { handler: handlerParams } = workerData;\n\ntry {\n    const { handler } = await import(handlerParams.path);\n\n    const result = await handler(...handlerParams.args);\n    parentPort!.postMessage(JSON.stringify({ success: true, result, error: null }));\n} catch (error) {\n    const { message, code, data, stack } = error;\n\n    parentPort!.postMessage(\n        JSON.stringify({\n            success: false,\n            result: null,\n            error: { message, code, data, stack }\n        })\n    );\n} finally {\n    process.exit(0);\n}\n"],"mappings":"AAAA,SAASA,UAAU,EAAEC,UAAU,QAAQ,gBAAgB;AAEvD,MAAM;EAAEC,OAAO,EAAEC;AAAc,CAAC,GAAGF,UAAU;AAE7C,IAAI;EACA,MAAM;IAAEC;EAAQ,CAAC,GAAG,MAAM,MAAM,CAACC,aAAa,CAACC,IAAI,CAAC;EAEpD,MAAMC,MAAM,GAAG,MAAMH,OAAO,CAAC,GAAGC,aAAa,CAACG,IAAI,CAAC;EACnDN,UAAU,CAAEO,WAAW,CAACC,IAAI,CAACC,SAAS,CAAC;IAAEC,OAAO,EAAE,IAAI;IAAEL,MAAM;IAAEM,KAAK,EAAE;EAAK,CAAC,CAAC,CAAC;AACnF,CAAC,CAAC,OAAOA,KAAK,EAAE;EACZ,MAAM;IAAEC,OAAO;IAAEC,IAAI;IAAEC,IAAI;IAAEC;EAAM,CAAC,GAAGJ,KAAK;EAE5CX,UAAU,CAAEO,WAAW,CACnBC,IAAI,CAACC,SAAS,CAAC;IACXC,OAAO,EAAE,KAAK;IACdL,MAAM,EAAE,IAAI;IACZM,KAAK,EAAE;MAAEC,OAAO;MAAEC,IAAI;MAAEC,IAAI;MAAEC;IAAM;EACxC,CAAC,CACL,CAAC;AACL,CAAC,SAAS;EACNC,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC;AACnB","ignoreList":[]}

package/features/Watch/replaceLambdaFunctions.d.ts

@@ -0,0 +1,18 @@
+import { type ListAppLambdaFunctionsService, type LoggerService, type PulumiExportService, type WatchedLambdaFunctionsService, type UiService } from "../../abstractions/index.js";
+import { type AppModel } from "../../models/index.js";
+export interface IReplaceLambdaFunctionsParams {
+    app: AppModel;
+    iotEndpoint: string;
+    iotEndpointTopic: string;
+    sessionId: number;
+    functionsList: ListAppLambdaFunctionsService.Result;
+    increaseTimeout?: number;
+    localExecutionHandshakeTimeout?: number;
+    dependencies: {
+        uiService: UiService.Interface;
+        loggerService: LoggerService.Interface;
+        pulumiExportService: PulumiExportService.Interface;
+        watchedLambdaFunctionsService: WatchedLambdaFunctionsService.Interface;
+    };
+}
+export declare const replaceLambdaFunctions: ({ app, iotEndpoint, iotEndpointTopic, sessionId, functionsList, increaseTimeout, localExecutionHandshakeTimeout, dependencies }: IReplaceLambdaFunctionsParams) => Promise<void[]>;

package/features/Watch/replaceLambdaFunctions.js

@@ -0,0 +1,91 @@
+import fs from "fs";
+import pRetry from "p-retry";
+import { GetFunctionConfigurationCommand, LambdaClient, UpdateFunctionCodeCommand, UpdateFunctionConfigurationCommand } from "@webiny/aws-sdk/client-lambda/index.js";
+const WATCH_MODE_NOTE_IN_DESCRIPTION = " (💡 local development mode, redeploy to remove)";
+const DEFAULT_INCREASE_TIMEOUT = 120;
+export const replaceLambdaFunctions = async ({
+  app,
+  iotEndpoint,
+  iotEndpointTopic,
+  sessionId,
+  functionsList,
+  increaseTimeout,
+  localExecutionHandshakeTimeout,
+  dependencies
+}) => {
+  const {
+    loggerService: logger,
+    pulumiExportService: exportStackState,
+    watchedLambdaFunctionsService
+  } = dependencies;
+  const stackExport = await exportStackState.execute(app);
+  if (!stackExport) {
+    // If no stack export is found, return an empty array. This is a valid scenario.
+    // For example, watching the Admin app locally, but not deploying it.
+    logger.info("No AWS Lambda functions to replace.");
+    return [];
+  }
+
+  // Find the URNs of Lambda functions that will be replaced
+  const functionNamesToUpdate = functionsList.list.map(fn => fn.name);
+  const replacedFunctionUrns = [];
+  if (stackExport.deployment?.resources) {
+    for (const resource of stackExport.deployment.resources) {
+      if (resource.type === "aws:lambda/function:Function") {
+        const functionName = resource.inputs?.name;
+        if (functionName && functionNamesToUpdate.includes(functionName)) {
+          replacedFunctionUrns.push(resource.urn);
+          logger.debug(`Will replace Lambda function: ${functionName} (${resource.urn})`);
+        }
+      }
+    }
+  }
+
+  // Mark these functions as needing replacement on next deployment
+  if (replacedFunctionUrns.length > 0) {
+    watchedLambdaFunctionsService.markDirty(app.name, replacedFunctionUrns);
+    logger.info(`Marked ${replacedFunctionUrns.length} Lambda function(s) for replacement on next deployment.`);
+  }
+  logger.info("replacing %s AWS Lambda function(s).", functionsList.meta.count);
+  const lambdaClient = new LambdaClient();
+  const replacementsPromises = functionsList.list.map(async fn => {
+    const getFnConfigCmd = new GetFunctionConfigurationCommand({
+      FunctionName: fn.name
+    });
+    const lambdaFnConfiguration = await lambdaClient.send(getFnConfigCmd);
+    const updateFnCodeCmd = new UpdateFunctionCodeCommand({
+      FunctionName: fn.name,
+      ZipFile: fs.readFileSync(import.meta.dirname + "/handler/handler.zip")
+    });
+    await lambdaClient.send(updateFnCodeCmd);
+    let Description = lambdaFnConfiguration.Description || "";
+    if (!Description.endsWith(WATCH_MODE_NOTE_IN_DESCRIPTION)) {
+      Description += WATCH_MODE_NOTE_IN_DESCRIPTION;
+    }
+    const Timeout = increaseTimeout || DEFAULT_INCREASE_TIMEOUT;
+    await pRetry(() => lambdaClient.send(new UpdateFunctionConfigurationCommand({
+      FunctionName: fn.name,
+      Timeout,
+      Description,
+      Environment: {
+        Variables: {
+          ...lambdaFnConfiguration.Environment?.Variables,
+          WEBINY_WATCH: JSON.stringify({
+            enabled: true,
+            localExecutionHandshakeTimeout,
+            sessionId,
+            iotEndpoint,
+            iotEndpointTopic,
+            functionName: fn.name
+          })
+        }
+      }
+    })));
+  });
+  return Promise.all(replacementsPromises).then(res => {
+    logger.info("%s AWS Lambda function(s) replaced.", functionsList.meta.count);
+    return res;
+  });
+};
+
+//# sourceMappingURL=replaceLambdaFunctions.js.map

package/features/Watch/replaceLambdaFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fs","pRetry","GetFunctionConfigurationCommand","LambdaClient","UpdateFunctionCodeCommand","UpdateFunctionConfigurationCommand","WATCH_MODE_NOTE_IN_DESCRIPTION","DEFAULT_INCREASE_TIMEOUT","replaceLambdaFunctions","app","iotEndpoint","iotEndpointTopic","sessionId","functionsList","increaseTimeout","localExecutionHandshakeTimeout","dependencies","loggerService","logger","pulumiExportService","exportStackState","watchedLambdaFunctionsService","stackExport","execute","info","functionNamesToUpdate","list","map","fn","name","replacedFunctionUrns","deployment","resources","resource","type","functionName","inputs","includes","push","urn","debug","length","markDirty","meta","count","lambdaClient","replacementsPromises","getFnConfigCmd","FunctionName","lambdaFnConfiguration","send","updateFnCodeCmd","ZipFile","readFileSync","import","dirname","Description","endsWith","Timeout","Environment","Variables","WEBINY_WATCH","JSON","stringify","enabled","Promise","all","then","res"],"sources":["replaceLambdaFunctions.ts"],"sourcesContent":["import fs from \"fs\";\nimport pRetry from \"p-retry\";\nimport {\n    GetFunctionConfigurationCommand,\n    LambdaClient,\n    UpdateFunctionCodeCommand,\n    UpdateFunctionConfigurationCommand\n} from \"@webiny/aws-sdk/client-lambda/index.js\";\nimport {\n    type ListAppLambdaFunctionsService,\n    type LoggerService,\n    type PulumiExportService,\n    type WatchedLambdaFunctionsService,\n    type UiService\n} from \"~/abstractions/index.js\";\nimport { type AppModel } from \"~/models/index.js\";\n\nconst WATCH_MODE_NOTE_IN_DESCRIPTION = \" (💡 local development mode, redeploy to remove)\";\nconst DEFAULT_INCREASE_TIMEOUT = 120;\n\nexport interface IReplaceLambdaFunctionsParams {\n    app: AppModel;\n    iotEndpoint: string;\n    iotEndpointTopic: string;\n    sessionId: number;\n    functionsList: ListAppLambdaFunctionsService.Result;\n    increaseTimeout?: number;\n    localExecutionHandshakeTimeout?: number;\n    dependencies: {\n        uiService: UiService.Interface;\n        loggerService: LoggerService.Interface;\n        pulumiExportService: PulumiExportService.Interface;\n        watchedLambdaFunctionsService: WatchedLambdaFunctionsService.Interface;\n    };\n}\n\nexport const replaceLambdaFunctions = async ({\n    app,\n    iotEndpoint,\n    iotEndpointTopic,\n    sessionId,\n    functionsList,\n    increaseTimeout,\n    localExecutionHandshakeTimeout,\n    dependencies\n}: IReplaceLambdaFunctionsParams) => {\n    const {\n        loggerService: logger,\n        pulumiExportService: exportStackState,\n        watchedLambdaFunctionsService\n    } = dependencies;\n\n    const stackExport = await exportStackState.execute(app);\n    if (!stackExport) {\n        // If no stack export is found, return an empty array. This is a valid scenario.\n        // For example, watching the Admin app locally, but not deploying it.\n        logger.info(\"No AWS Lambda functions to replace.\");\n        return [];\n    }\n\n    // Find the URNs of Lambda functions that will be replaced\n    const functionNamesToUpdate = functionsList.list.map(fn => fn.name);\n    const replacedFunctionUrns: string[] = [];\n\n    if (stackExport.deployment?.resources) {\n        for (const resource of stackExport.deployment.resources) {\n            if (resource.type === \"aws:lambda/function:Function\") {\n                const functionName = resource.inputs?.name;\n                if (functionName && functionNamesToUpdate.includes(functionName)) {\n                    replacedFunctionUrns.push(resource.urn);\n                    logger.debug(`Will replace Lambda function: ${functionName} (${resource.urn})`);\n                }\n            }\n        }\n    }\n\n    // Mark these functions as needing replacement on next deployment\n    if (replacedFunctionUrns.length > 0) {\n        watchedLambdaFunctionsService.markDirty(app.name, replacedFunctionUrns);\n        logger.info(\n            `Marked ${replacedFunctionUrns.length} Lambda function(s) for replacement on next deployment.`\n        );\n    }\n\n    logger.info(\"replacing %s AWS Lambda function(s).\", functionsList.meta.count);\n    const lambdaClient = new LambdaClient();\n\n    const replacementsPromises = functionsList.list.map(async fn => {\n        const getFnConfigCmd = new GetFunctionConfigurationCommand({ FunctionName: fn.name });\n        const lambdaFnConfiguration = await lambdaClient.send(getFnConfigCmd);\n\n        const updateFnCodeCmd = new UpdateFunctionCodeCommand({\n            FunctionName: fn.name,\n            ZipFile: fs.readFileSync(import.meta.dirname + \"/handler/handler.zip\")\n        });\n\n        await lambdaClient.send(updateFnCodeCmd);\n\n        let Description = lambdaFnConfiguration.Description || \"\";\n        if (!Description.endsWith(WATCH_MODE_NOTE_IN_DESCRIPTION)) {\n            Description += WATCH_MODE_NOTE_IN_DESCRIPTION;\n        }\n\n        const Timeout = increaseTimeout || DEFAULT_INCREASE_TIMEOUT;\n\n        await pRetry(() =>\n            lambdaClient.send(\n                new UpdateFunctionConfigurationCommand({\n                    FunctionName: fn.name,\n                    Timeout,\n                    Description,\n                    Environment: {\n                        Variables: {\n                            ...lambdaFnConfiguration.Environment?.Variables,\n                            WEBINY_WATCH: JSON.stringify({\n                                enabled: true,\n                                localExecutionHandshakeTimeout,\n                                sessionId,\n                                iotEndpoint,\n                                iotEndpointTopic,\n                                functionName: fn.name\n                            })\n                        }\n                    }\n                })\n            )\n        );\n    });\n\n    return Promise.all(replacementsPromises).then(res => {\n        logger.info(\"%s AWS Lambda function(s) replaced.\", functionsList.meta.count);\n        return res;\n    });\n};\n"],"mappings":"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","ignoreList":[]}

package/features/Watch/watchers/BasePackagesWatcher.d.ts

@@ -0,0 +1,15 @@
+import { type ListPackagesService, type LoggerService, type Watch } from "../../../abstractions/index.js";
+import { type RunnableWatchProcesses } from "./RunnableWatchProcesses.js";
+export interface IBasePackagesWatcherParams {
+    packages: IBasePackagesWatcherPackage[];
+    logger: LoggerService.Interface;
+    params: Watch.Params;
+}
+export type IBasePackagesWatcherPackage = ListPackagesService.Package;
+export declare class BasePackagesWatcher {
+    readonly packages: IBasePackagesWatcherPackage[];
+    readonly params: Watch.Params;
+    readonly logger: LoggerService.Interface;
+    constructor({ packages, params, logger }: IBasePackagesWatcherParams);
+    prepare(): RunnableWatchProcesses;
+}

package/features/Watch/watchers/BasePackagesWatcher.js

@@ -0,0 +1,16 @@
+export class BasePackagesWatcher {
+  constructor({
+    packages,
+    params,
+    logger
+  }) {
+    this.packages = packages;
+    this.params = params;
+    this.logger = logger;
+  }
+  prepare() {
+    throw new Error("Not implemented.");
+  }
+}
+
+//# sourceMappingURL=BasePackagesWatcher.js.map

package/features/Watch/watchers/BasePackagesWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BasePackagesWatcher","constructor","packages","params","logger","prepare","Error"],"sources":["BasePackagesWatcher.ts"],"sourcesContent":["import { type ListPackagesService, type LoggerService, type Watch } from \"~/abstractions/index.js\";\n\nimport { type RunnableWatchProcesses } from \"./RunnableWatchProcesses.js\";\n\nexport interface IBasePackagesWatcherParams {\n    packages: IBasePackagesWatcherPackage[];\n    logger: LoggerService.Interface;\n    params: Watch.Params;\n}\n\nexport type IBasePackagesWatcherPackage = ListPackagesService.Package;\n\nexport class BasePackagesWatcher {\n    public readonly packages: IBasePackagesWatcherPackage[];\n    public readonly params: Watch.Params;\n    public readonly logger: LoggerService.Interface;\n\n    public constructor({ packages, params, logger }: IBasePackagesWatcherParams) {\n        this.packages = packages;\n        this.params = params;\n        this.logger = logger;\n    }\n\n    public prepare(): RunnableWatchProcesses {\n        throw new Error(\"Not implemented.\");\n    }\n}\n"],"mappings":"AAYA,OAAO,MAAMA,mBAAmB,CAAC;EAKtBC,WAAWA,CAAC;IAAEC,QAAQ;IAAEC,MAAM;IAAEC;EAAmC,CAAC,EAAE;IACzE,IAAI,CAACF,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACC,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,MAAM,GAAGA,MAAM;EACxB;EAEOC,OAAOA,CAAA,EAA2B;IACrC,MAAM,IAAIC,KAAK,CAAC,kBAAkB,CAAC;EACvC;AACJ","ignoreList":[]}

package/features/Watch/watchers/MultiplePackagesWatcher.d.ts

@@ -0,0 +1,5 @@
+import { BasePackagesWatcher } from "./BasePackagesWatcher.js";
+import { RunnableWatchProcesses } from "./RunnableWatchProcesses.js";
+export declare class MultiplePackagesWatcher extends BasePackagesWatcher {
+    prepare(): RunnableWatchProcesses;
+}

package/features/Watch/watchers/MultiplePackagesWatcher.js

@@ -0,0 +1,18 @@
+import { BasePackagesWatcher } from "./BasePackagesWatcher.js";
+import { RunnableWatchProcess } from "./RunnableWatchProcess.js";
+import { RunnableWatchProcesses } from "./RunnableWatchProcesses.js";
+export class MultiplePackagesWatcher extends BasePackagesWatcher {
+  prepare() {
+    const packages = this.packages;
+    this.logger.debug(`Building %s packages...`, packages.length);
+    this.logger.debug("The following packages will be watched for changes:", packages);
+    return new RunnableWatchProcesses(packages.map(pkg => {
+      return new RunnableWatchProcess({
+        buildParams: this.params,
+        pkg
+      });
+    }));
+  }
+}
+
+//# sourceMappingURL=MultiplePackagesWatcher.js.map

package/features/Watch/watchers/MultiplePackagesWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BasePackagesWatcher","RunnableWatchProcess","RunnableWatchProcesses","MultiplePackagesWatcher","prepare","packages","logger","debug","length","map","pkg","buildParams","params"],"sources":["MultiplePackagesWatcher.ts"],"sourcesContent":["import { BasePackagesWatcher } from \"./BasePackagesWatcher.js\";\nimport { RunnableWatchProcess } from \"./RunnableWatchProcess.js\";\nimport { RunnableWatchProcesses } from \"./RunnableWatchProcesses.js\";\n\nexport class MultiplePackagesWatcher extends BasePackagesWatcher {\n    public override prepare() {\n        const packages = this.packages;\n        this.logger.debug(`Building %s packages...`, packages.length);\n        this.logger.debug(\"The following packages will be watched for changes:\", packages);\n\n        return new RunnableWatchProcesses(\n            packages.map(pkg => {\n                return new RunnableWatchProcess({\n                    buildParams: this.params,\n                    pkg\n                });\n            })\n        );\n    }\n}\n"],"mappings":"AAAA,SAASA,mBAAmB;AAC5B,SAASC,oBAAoB;AAC7B,SAASC,sBAAsB;AAE/B,OAAO,MAAMC,uBAAuB,SAASH,mBAAmB,CAAC;EAC7CI,OAAOA,CAAA,EAAG;IACtB,MAAMC,QAAQ,GAAG,IAAI,CAACA,QAAQ;IAC9B,IAAI,CAACC,MAAM,CAACC,KAAK,CAAC,yBAAyB,EAAEF,QAAQ,CAACG,MAAM,CAAC;IAC7D,IAAI,CAACF,MAAM,CAACC,KAAK,CAAC,qDAAqD,EAAEF,QAAQ,CAAC;IAElF,OAAO,IAAIH,sBAAsB,CAC7BG,QAAQ,CAACI,GAAG,CAACC,GAAG,IAAI;MAChB,OAAO,IAAIT,oBAAoB,CAAC;QAC5BU,WAAW,EAAE,IAAI,CAACC,MAAM;QACxBF;MACJ,CAAC,CAAC;IACN,CAAC,CACL,CAAC;EACL;AACJ","ignoreList":[]}

package/features/Watch/watchers/PackagesWatcher.d.ts

@@ -0,0 +1,5 @@
+import { BasePackagesWatcher } from "./BasePackagesWatcher.js";
+export declare class PackagesWatcher extends BasePackagesWatcher {
+    prepare(): import("./RunnableWatchProcesses.js").RunnableWatchProcesses;
+    private getWatcherClass;
+}

package/features/Watch/watchers/PackagesWatcher.js

@@ -0,0 +1,27 @@
+import { BasePackagesWatcher } from "./BasePackagesWatcher.js";
+import { ZeroPackagesWatcher } from "./ZeroPackagesWatcher.js";
+import { SinglePackageWatcher } from "./SinglePackageWatcher.js";
+import { MultiplePackagesWatcher } from "./MultiplePackagesWatcher.js";
+export class PackagesWatcher extends BasePackagesWatcher {
+  prepare() {
+    const WatcherClass = this.getWatcherClass();
+    const watcher = new WatcherClass({
+      packages: this.packages,
+      params: this.params,
+      logger: this.logger
+    });
+    return watcher.prepare();
+  }
+  getWatcherClass() {
+    const packagesCount = this.packages.length;
+    if (packagesCount === 0) {
+      return ZeroPackagesWatcher;
+    }
+    if (packagesCount === 1) {
+      return SinglePackageWatcher;
+    }
+    return MultiplePackagesWatcher;
+  }
+}
+
+//# sourceMappingURL=PackagesWatcher.js.map

package/features/Watch/watchers/PackagesWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BasePackagesWatcher","ZeroPackagesWatcher","SinglePackageWatcher","MultiplePackagesWatcher","PackagesWatcher","prepare","WatcherClass","getWatcherClass","watcher","packages","params","logger","packagesCount","length"],"sources":["PackagesWatcher.ts"],"sourcesContent":["import { BasePackagesWatcher } from \"./BasePackagesWatcher.js\";\nimport { ZeroPackagesWatcher } from \"./ZeroPackagesWatcher.js\";\nimport { SinglePackageWatcher } from \"./SinglePackageWatcher.js\";\nimport { MultiplePackagesWatcher } from \"./MultiplePackagesWatcher.js\";\n\nexport class PackagesWatcher extends BasePackagesWatcher {\n    public override prepare() {\n        const WatcherClass = this.getWatcherClass();\n\n        const watcher = new WatcherClass({\n            packages: this.packages,\n            params: this.params,\n            logger: this.logger\n        });\n\n        return watcher.prepare();\n    }\n\n    private getWatcherClass() {\n        const packagesCount = this.packages.length;\n        if (packagesCount === 0) {\n            return ZeroPackagesWatcher;\n        }\n\n        if (packagesCount === 1) {\n            return SinglePackageWatcher;\n        }\n        return MultiplePackagesWatcher;\n    }\n}\n"],"mappings":"AAAA,SAASA,mBAAmB;AAC5B,SAASC,mBAAmB;AAC5B,SAASC,oBAAoB;AAC7B,SAASC,uBAAuB;AAEhC,OAAO,MAAMC,eAAe,SAASJ,mBAAmB,CAAC;EACrCK,OAAOA,CAAA,EAAG;IACtB,MAAMC,YAAY,GAAG,IAAI,CAACC,eAAe,CAAC,CAAC;IAE3C,MAAMC,OAAO,GAAG,IAAIF,YAAY,CAAC;MAC7BG,QAAQ,EAAE,IAAI,CAACA,QAAQ;MACvBC,MAAM,EAAE,IAAI,CAACA,MAAM;MACnBC,MAAM,EAAE,IAAI,CAACA;IACjB,CAAC,CAAC;IAEF,OAAOH,OAAO,CAACH,OAAO,CAAC,CAAC;EAC5B;EAEQE,eAAeA,CAAA,EAAG;IACtB,MAAMK,aAAa,GAAG,IAAI,CAACH,QAAQ,CAACI,MAAM;IAC1C,IAAID,aAAa,KAAK,CAAC,EAAE;MACrB,OAAOX,mBAAmB;IAC9B;IAEA,IAAIW,aAAa,KAAK,CAAC,EAAE;MACrB,OAAOV,oBAAoB;IAC/B;IACA,OAAOC,uBAAuB;EAClC;AACJ","ignoreList":[]}

package/features/Watch/watchers/RunnableWatchProcess.d.ts

@@ -0,0 +1,20 @@
+import { type IBasePackagesWatcherPackage } from "./BasePackagesWatcher.js";
+import { type ForkOptions } from "child_process";
+import { type Watch } from "../../../abstractions/index.js";
+export interface RunnableProcessParams {
+    buildParams: Watch.Params;
+    pkg: IBasePackagesWatcherPackage;
+    forkOptions?: ForkOptions;
+}
+export declare class RunnableWatchProcess {
+    buildParams: Watch.Params;
+    pkg: IBasePackagesWatcherPackage;
+    forkOptions: ForkOptions | undefined;
+    pipeStdoutCallback: ((stdout: NodeJS.ReadableStream) => void) | undefined;
+    pipeStderrCallback: ((stderr: NodeJS.ReadableStream) => void) | undefined;
+    constructor(params: RunnableProcessParams);
+    run(): Promise<void>;
+    setForkOptions(options: ForkOptions): void;
+    pipeStdout(callback: (stdout: NodeJS.ReadableStream) => void): void;
+    pipeStderr(callback: (stderr: NodeJS.ReadableStream) => void): void;
+}

package/features/Watch/watchers/RunnableWatchProcess.js

@@ -0,0 +1,47 @@
+import { fork } from "child_process";
+import path from "path";
+export class RunnableWatchProcess {
+  constructor(params) {
+    this.buildParams = params.buildParams;
+    this.pkg = params.pkg;
+    this.forkOptions = params.forkOptions || {
+      env: {
+        ...process.env
+      },
+      stdio: ["pipe", "pipe", "pipe", "ipc"]
+    };
+  }
+  run() {
+    const workerPath = path.resolve(import.meta.dirname, "worker.js");
+    const buildProcess = fork(workerPath, [JSON.stringify({
+      ...this.buildParams,
+      package: this.pkg
+    })], this.forkOptions);
+    if (this.pipeStdoutCallback && buildProcess.stdout) {
+      this.pipeStdoutCallback(buildProcess.stdout);
+    }
+    if (this.pipeStderrCallback && buildProcess.stderr) {
+      this.pipeStderrCallback(buildProcess.stderr);
+    }
+    return new Promise((resolve, reject) => {
+      buildProcess.on("exit", code => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Build failed for package ${this.pkg.name} with exit code ${code}`));
+        }
+      });
+    });
+  }
+  setForkOptions(options) {
+    this.forkOptions = options;
+  }
+  pipeStdout(callback) {
+    this.pipeStdoutCallback = callback;
+  }
+  pipeStderr(callback) {
+    this.pipeStderrCallback = callback;
+  }
+}
+
+//# sourceMappingURL=RunnableWatchProcess.js.map

package/features/Watch/watchers/RunnableWatchProcess.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fork","path","RunnableWatchProcess","constructor","params","buildParams","pkg","forkOptions","env","process","stdio","run","workerPath","resolve","import","meta","dirname","buildProcess","JSON","stringify","package","pipeStdoutCallback","stdout","pipeStderrCallback","stderr","Promise","reject","on","code","Error","name","setForkOptions","options","pipeStdout","callback","pipeStderr"],"sources":["RunnableWatchProcess.ts"],"sourcesContent":["import { type IBasePackagesWatcherPackage } from \"./BasePackagesWatcher.js\";\nimport { fork, type ForkOptions } from \"child_process\";\nimport path from \"path\";\nimport { type Watch } from \"~/abstractions/index.js\";\n\nexport interface RunnableProcessParams {\n    buildParams: Watch.Params;\n    pkg: IBasePackagesWatcherPackage;\n    forkOptions?: ForkOptions;\n}\n\nexport class RunnableWatchProcess {\n    buildParams: Watch.Params;\n    pkg: IBasePackagesWatcherPackage;\n    forkOptions: ForkOptions | undefined;\n    pipeStdoutCallback: ((stdout: NodeJS.ReadableStream) => void) | undefined;\n    pipeStderrCallback: ((stderr: NodeJS.ReadableStream) => void) | undefined;\n    constructor(params: RunnableProcessParams) {\n        this.buildParams = params.buildParams;\n        this.pkg = params.pkg;\n        this.forkOptions = params.forkOptions || {\n            env: { ...process.env },\n            stdio: [\"pipe\", \"pipe\", \"pipe\", \"ipc\"]\n        };\n    }\n\n    run() {\n        const workerPath = path.resolve(import.meta.dirname, \"worker.js\");\n\n        const buildProcess = fork(\n            workerPath,\n            [JSON.stringify({ ...this.buildParams, package: this.pkg })],\n            this.forkOptions\n        );\n\n        if (this.pipeStdoutCallback && buildProcess.stdout) {\n            this.pipeStdoutCallback(buildProcess.stdout);\n        }\n\n        if (this.pipeStderrCallback && buildProcess.stderr) {\n            this.pipeStderrCallback(buildProcess.stderr);\n        }\n\n        return new Promise<void>((resolve, reject) => {\n            buildProcess.on(\"exit\", code => {\n                if (code === 0) {\n                    resolve();\n                } else {\n                    reject(\n                        new Error(\n                            `Build failed for package ${this.pkg.name} with exit code ${code}`\n                        )\n                    );\n                }\n            });\n        });\n    }\n\n    setForkOptions(options: ForkOptions) {\n        this.forkOptions = options;\n    }\n\n    pipeStdout(callback: (stdout: NodeJS.ReadableStream) => void) {\n        this.pipeStdoutCallback = callback;\n    }\n\n    pipeStderr(callback: (stderr: NodeJS.ReadableStream) => void) {\n        this.pipeStderrCallback = callback;\n    }\n}\n"],"mappings":"AACA,SAASA,IAAI,QAA0B,eAAe;AACtD,OAAOC,IAAI,MAAM,MAAM;AASvB,OAAO,MAAMC,oBAAoB,CAAC;EAM9BC,WAAWA,CAACC,MAA6B,EAAE;IACvC,IAAI,CAACC,WAAW,GAAGD,MAAM,CAACC,WAAW;IACrC,IAAI,CAACC,GAAG,GAAGF,MAAM,CAACE,GAAG;IACrB,IAAI,CAACC,WAAW,GAAGH,MAAM,CAACG,WAAW,IAAI;MACrCC,GAAG,EAAE;QAAE,GAAGC,OAAO,CAACD;MAAI,CAAC;MACvBE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IACzC,CAAC;EACL;EAEAC,GAAGA,CAAA,EAAG;IACF,MAAMC,UAAU,GAAGX,IAAI,CAACY,OAAO,CAACC,MAAM,CAACC,IAAI,CAACC,OAAO,EAAE,WAAW,CAAC;IAEjE,MAAMC,YAAY,GAAGjB,IAAI,CACrBY,UAAU,EACV,CAACM,IAAI,CAACC,SAAS,CAAC;MAAE,GAAG,IAAI,CAACd,WAAW;MAAEe,OAAO,EAAE,IAAI,CAACd;IAAI,CAAC,CAAC,CAAC,EAC5D,IAAI,CAACC,WACT,CAAC;IAED,IAAI,IAAI,CAACc,kBAAkB,IAAIJ,YAAY,CAACK,MAAM,EAAE;MAChD,IAAI,CAACD,kBAAkB,CAACJ,YAAY,CAACK,MAAM,CAAC;IAChD;IAEA,IAAI,IAAI,CAACC,kBAAkB,IAAIN,YAAY,CAACO,MAAM,EAAE;MAChD,IAAI,CAACD,kBAAkB,CAACN,YAAY,CAACO,MAAM,CAAC;IAChD;IAEA,OAAO,IAAIC,OAAO,CAAO,CAACZ,OAAO,EAAEa,MAAM,KAAK;MAC1CT,YAAY,CAACU,EAAE,CAAC,MAAM,EAAEC,IAAI,IAAI;QAC5B,IAAIA,IAAI,KAAK,CAAC,EAAE;UACZf,OAAO,CAAC,CAAC;QACb,CAAC,MAAM;UACHa,MAAM,CACF,IAAIG,KAAK,CACL,4BAA4B,IAAI,CAACvB,GAAG,CAACwB,IAAI,mBAAmBF,IAAI,EACpE,CACJ,CAAC;QACL;MACJ,CAAC,CAAC;IACN,CAAC,CAAC;EACN;EAEAG,cAAcA,CAACC,OAAoB,EAAE;IACjC,IAAI,CAACzB,WAAW,GAAGyB,OAAO;EAC9B;EAEAC,UAAUA,CAACC,QAAiD,EAAE;IAC1D,IAAI,CAACb,kBAAkB,GAAGa,QAAQ;EACtC;EAEAC,UAAUA,CAACD,QAAiD,EAAE;IAC1D,IAAI,CAACX,kBAAkB,GAAGW,QAAQ;EACtC;AACJ","ignoreList":[]}

package/features/Watch/watchers/RunnableWatchProcesses.d.ts

@@ -0,0 +1,13 @@
+import { type RunnableWatchProcess } from "./RunnableWatchProcess.js";
+import { type ForkOptions } from "child_process";
+export declare class RunnableWatchProcesses {
+    runnableBuildProcesses: RunnableWatchProcess[];
+    constructor(runnableBuildProcesses: RunnableWatchProcess[]);
+    run(): Promise<void>[];
+    get length(): number;
+    setForkOptions(options: ForkOptions): this;
+    pipeStdout(callback: (stdout: NodeJS.ReadableStream) => void): this;
+    pipeStderr(callback: (stderr: NodeJS.ReadableStream) => void): this;
+    getProcesses(): RunnableWatchProcess[];
+    forEach(callback: (process: RunnableWatchProcess) => void): void;
+}

package/features/Watch/watchers/RunnableWatchProcesses.js

@@ -0,0 +1,37 @@
+export class RunnableWatchProcesses {
+  constructor(runnableBuildProcesses) {
+    this.runnableBuildProcesses = runnableBuildProcesses;
+  }
+  run() {
+    return this.runnableBuildProcesses.map(runnableBuildProcess => runnableBuildProcess.run());
+  }
+  get length() {
+    return this.runnableBuildProcesses.length;
+  }
+  setForkOptions(options) {
+    this.runnableBuildProcesses.forEach(runnableBuildProcess => {
+      runnableBuildProcess.setForkOptions(options);
+    });
+    return this;
+  }
+  pipeStdout(callback) {
+    this.runnableBuildProcesses.forEach(runnableBuildProcess => {
+      runnableBuildProcess.pipeStdout(callback);
+    });
+    return this;
+  }
+  pipeStderr(callback) {
+    this.runnableBuildProcesses.forEach(runnableBuildProcess => {
+      runnableBuildProcess.pipeStderr(callback);
+    });
+    return this;
+  }
+  getProcesses() {
+    return this.runnableBuildProcesses;
+  }
+  forEach(callback) {
+    this.runnableBuildProcesses.forEach(callback);
+  }
+}
+
+//# sourceMappingURL=RunnableWatchProcesses.js.map

package/features/Watch/watchers/RunnableWatchProcesses.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RunnableWatchProcesses","constructor","runnableBuildProcesses","run","map","runnableBuildProcess","length","setForkOptions","options","forEach","pipeStdout","callback","pipeStderr","getProcesses"],"sources":["RunnableWatchProcesses.ts"],"sourcesContent":["import { type RunnableWatchProcess } from \"./RunnableWatchProcess.js\";\nimport { type ForkOptions } from \"child_process\";\n\nexport class RunnableWatchProcesses {\n    runnableBuildProcesses: RunnableWatchProcess[];\n\n    constructor(runnableBuildProcesses: RunnableWatchProcess[]) {\n        this.runnableBuildProcesses = runnableBuildProcesses;\n    }\n\n    run() {\n        return this.runnableBuildProcesses.map(runnableBuildProcess => runnableBuildProcess.run());\n    }\n\n    get length() {\n        return this.runnableBuildProcesses.length;\n    }\n\n    setForkOptions(options: ForkOptions) {\n        this.runnableBuildProcesses.forEach(runnableBuildProcess => {\n            runnableBuildProcess.setForkOptions(options);\n        });\n\n        return this;\n    }\n\n    pipeStdout(callback: (stdout: NodeJS.ReadableStream) => void) {\n        this.runnableBuildProcesses.forEach(runnableBuildProcess => {\n            runnableBuildProcess.pipeStdout(callback);\n        });\n\n        return this;\n    }\n\n    pipeStderr(callback: (stderr: NodeJS.ReadableStream) => void) {\n        this.runnableBuildProcesses.forEach(runnableBuildProcess => {\n            runnableBuildProcess.pipeStderr(callback);\n        });\n\n        return this;\n    }\n\n    getProcesses() {\n        return this.runnableBuildProcesses;\n    }\n\n    forEach(callback: (process: RunnableWatchProcess) => void) {\n        this.runnableBuildProcesses.forEach(callback);\n    }\n}\n"],"mappings":"AAGA,OAAO,MAAMA,sBAAsB,CAAC;EAGhCC,WAAWA,CAACC,sBAA8C,EAAE;IACxD,IAAI,CAACA,sBAAsB,GAAGA,sBAAsB;EACxD;EAEAC,GAAGA,CAAA,EAAG;IACF,OAAO,IAAI,CAACD,sBAAsB,CAACE,GAAG,CAACC,oBAAoB,IAAIA,oBAAoB,CAACF,GAAG,CAAC,CAAC,CAAC;EAC9F;EAEA,IAAIG,MAAMA,CAAA,EAAG;IACT,OAAO,IAAI,CAACJ,sBAAsB,CAACI,MAAM;EAC7C;EAEAC,cAAcA,CAACC,OAAoB,EAAE;IACjC,IAAI,CAACN,sBAAsB,CAACO,OAAO,CAACJ,oBAAoB,IAAI;MACxDA,oBAAoB,CAACE,cAAc,CAACC,OAAO,CAAC;IAChD,CAAC,CAAC;IAEF,OAAO,IAAI;EACf;EAEAE,UAAUA,CAACC,QAAiD,EAAE;IAC1D,IAAI,CAACT,sBAAsB,CAACO,OAAO,CAACJ,oBAAoB,IAAI;MACxDA,oBAAoB,CAACK,UAAU,CAACC,QAAQ,CAAC;IAC7C,CAAC,CAAC;IAEF,OAAO,IAAI;EACf;EAEAC,UAAUA,CAACD,QAAiD,EAAE;IAC1D,IAAI,CAACT,sBAAsB,CAACO,OAAO,CAACJ,oBAAoB,IAAI;MACxDA,oBAAoB,CAACO,UAAU,CAACD,QAAQ,CAAC;IAC7C,CAAC,CAAC;IAEF,OAAO,IAAI;EACf;EAEAE,YAAYA,CAAA,EAAG;IACX,OAAO,IAAI,CAACX,sBAAsB;EACtC;EAEAO,OAAOA,CAACE,QAAiD,EAAE;IACvD,IAAI,CAACT,sBAAsB,CAACO,OAAO,CAACE,QAAQ,CAAC;EACjD;AACJ","ignoreList":[]}

package/features/Watch/watchers/SinglePackageWatcher.d.ts

@@ -0,0 +1,5 @@
+import { BasePackagesWatcher } from "./BasePackagesWatcher.js";
+import { RunnableWatchProcesses } from "./RunnableWatchProcesses.js";
+export declare class SinglePackageWatcher extends BasePackagesWatcher {
+    prepare(): RunnableWatchProcesses;
+}

package/features/Watch/watchers/SinglePackageWatcher.js

@@ -0,0 +1,14 @@
+import { BasePackagesWatcher } from "./BasePackagesWatcher.js";
+import { RunnableWatchProcess } from "./RunnableWatchProcess.js";
+import { RunnableWatchProcesses } from "./RunnableWatchProcesses.js";
+export class SinglePackageWatcher extends BasePackagesWatcher {
+  prepare() {
+    const [pkg] = this.packages;
+    return new RunnableWatchProcesses([new RunnableWatchProcess({
+      buildParams: this.params,
+      pkg
+    })]);
+  }
+}
+
+//# sourceMappingURL=SinglePackageWatcher.js.map

package/features/Watch/watchers/SinglePackageWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BasePackagesWatcher","RunnableWatchProcess","RunnableWatchProcesses","SinglePackageWatcher","prepare","pkg","packages","buildParams","params"],"sources":["SinglePackageWatcher.ts"],"sourcesContent":["import { BasePackagesWatcher } from \"./BasePackagesWatcher.js\";\nimport { RunnableWatchProcess } from \"./RunnableWatchProcess.js\";\nimport { RunnableWatchProcesses } from \"./RunnableWatchProcesses.js\";\n\nexport class SinglePackageWatcher extends BasePackagesWatcher {\n    public override prepare() {\n        const [pkg] = this.packages;\n\n        return new RunnableWatchProcesses([\n            new RunnableWatchProcess({\n                buildParams: this.params,\n                pkg\n            })\n        ]);\n    }\n}\n"],"mappings":"AAAA,SAASA,mBAAmB;AAC5B,SAASC,oBAAoB;AAC7B,SAASC,sBAAsB;AAE/B,OAAO,MAAMC,oBAAoB,SAASH,mBAAmB,CAAC;EAC1CI,OAAOA,CAAA,EAAG;IACtB,MAAM,CAACC,GAAG,CAAC,GAAG,IAAI,CAACC,QAAQ;IAE3B,OAAO,IAAIJ,sBAAsB,CAAC,CAC9B,IAAID,oBAAoB,CAAC;MACrBM,WAAW,EAAE,IAAI,CAACC,MAAM;MACxBH;IACJ,CAAC,CAAC,CACL,CAAC;EACN;AACJ","ignoreList":[]}

package/features/Watch/watchers/WebinyConfigWatcher.d.ts

@@ -0,0 +1,16 @@
+import { type GetApp, type GetProjectConfigService, type ValidateProjectConfigService } from "../../../abstractions/index.js";
+export interface IWebinyConfigWatcherParams {
+    webinyConfigPath: string;
+    appName: GetApp.AppName;
+    getProjectConfigService: GetProjectConfigService.Interface;
+    validateProjectConfigService: ValidateProjectConfigService.Interface;
+}
+export declare class WebinyConfigWatcher {
+    private params;
+    onSuccessCallback?: () => void;
+    onErrorCallback?: (err: Error) => void;
+    constructor(params: IWebinyConfigWatcherParams);
+    run(): void;
+    onSuccess(callback: () => void): this;
+    onError(callback: (err: Error) => void): this;
+}