isomorfeus-asset-manager 0.15.0 → 0.15.2

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,9 +1,7 @@
1
1
  "use strict";
2
- var __create = Object.create;
3
2
  var __defProp = Object.defineProperty;
4
3
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
4
  var __getOwnPropNames = Object.getOwnPropertyNames;
6
- var __getProtoOf = Object.getPrototypeOf;
7
5
  var __hasOwnProp = Object.prototype.hasOwnProperty;
8
6
  var __export = (target, all) => {
9
7
  for (var name in all)
@@ -17,10 +15,6 @@ var __copyProps = (to, from, except, desc) => {
17
15
  }
18
16
  return to;
19
17
  };
20
- var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
21
- isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
22
- mod
23
- ));
24
18
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
25
19
 
26
20
  // lib/npm/node.ts
@@ -206,6 +200,8 @@ function writeUInt32LE(buffer, value, offset) {
206
200
  }
207
201
 
208
202
  // lib/shared/common.ts
203
+ var buildLogLevelDefault = "warning";
204
+ var transformLogLevelDefault = "silent";
209
205
  function validateTarget(target) {
210
206
  target += "";
211
207
  if (target.indexOf(",") >= 0)
@@ -306,6 +302,7 @@ function pushCommonFlags(flags, options, keys) {
306
302
  let jsxFragment = getFlag(options, keys, "jsxFragment", mustBeString);
307
303
  let jsxImportSource = getFlag(options, keys, "jsxImportSource", mustBeString);
308
304
  let jsxDev = getFlag(options, keys, "jsxDev", mustBeBoolean);
305
+ let jsxSideEffects = getFlag(options, keys, "jsxSideEffects", mustBeBoolean);
309
306
  let define = getFlag(options, keys, "define", mustBeObject);
310
307
  let logOverride = getFlag(options, keys, "logOverride", mustBeObject);
311
308
  let supported = getFlag(options, keys, "supported", mustBeObject);
@@ -363,6 +360,8 @@ function pushCommonFlags(flags, options, keys) {
363
360
  flags.push(`--jsx-import-source=${jsxImportSource}`);
364
361
  if (jsxDev)
365
362
  flags.push(`--jsx-dev`);
363
+ if (jsxSideEffects)
364
+ flags.push(`--jsx-side-effects`);
366
365
  if (define) {
367
366
  for (let key in define) {
368
367
  if (key.indexOf("=") >= 0)
@@ -616,11 +615,9 @@ function flagsForTransformOptions(callName, options, isTTY2, logLevelDefault) {
616
615
  };
617
616
  }
618
617
  function createChannel(streamIn) {
619
- let responseCallbacks = /* @__PURE__ */ new Map();
620
- let pluginCallbacks = /* @__PURE__ */ new Map();
621
- let watchCallbacks = /* @__PURE__ */ new Map();
622
- let serveCallbacks = /* @__PURE__ */ new Map();
623
- let closeData = null;
618
+ const requestCallbacksByKey = {};
619
+ const closeData = { didClose: false, reason: "" };
620
+ let responseCallbacks = {};
624
621
  let nextRequestID = 0;
625
622
  let nextBuildKey = 0;
626
623
  let stdout = new Uint8Array(16 * 1024);
@@ -650,105 +647,53 @@ function createChannel(streamIn) {
650
647
  }
651
648
  };
652
649
  let afterClose = (error) => {
653
- closeData = { reason: error ? ": " + (error.message || error) : "" };
650
+ closeData.didClose = true;
651
+ if (error)
652
+ closeData.reason = ": " + (error.message || error);
654
653
  const text = "The service was stopped" + closeData.reason;
655
- for (let callback of responseCallbacks.values()) {
656
- callback(text, null);
654
+ for (let id in responseCallbacks) {
655
+ responseCallbacks[id](text, null);
657
656
  }
658
- responseCallbacks.clear();
659
- for (let callbacks of serveCallbacks.values()) {
660
- callbacks.onWait(text);
661
- }
662
- serveCallbacks.clear();
663
- for (let callback of watchCallbacks.values()) {
664
- try {
665
- callback(new Error(text), null);
666
- } catch (e) {
667
- console.error(e);
668
- }
669
- }
670
- watchCallbacks.clear();
657
+ responseCallbacks = {};
671
658
  };
672
659
  let sendRequest = (refs, value, callback) => {
673
- if (closeData)
660
+ if (closeData.didClose)
674
661
  return callback("The service is no longer running" + closeData.reason, null);
675
662
  let id = nextRequestID++;
676
- responseCallbacks.set(id, (error, response) => {
663
+ responseCallbacks[id] = (error, response) => {
677
664
  try {
678
665
  callback(error, response);
679
666
  } finally {
680
667
  if (refs)
681
668
  refs.unref();
682
669
  }
683
- });
670
+ };
684
671
  if (refs)
685
672
  refs.ref();
686
673
  streamIn.writeToStdin(encodePacket({ id, isRequest: true, value }));
687
674
  };
688
675
  let sendResponse = (id, value) => {
689
- if (closeData)
676
+ if (closeData.didClose)
690
677
  throw new Error("The service is no longer running" + closeData.reason);
691
678
  streamIn.writeToStdin(encodePacket({ id, isRequest: false, value }));
692
679
  };
693
680
  let handleRequest = async (id, request) => {
694
681
  try {
695
- switch (request.command) {
696
- case "ping": {
697
- sendResponse(id, {});
698
- break;
699
- }
700
- case "on-start": {
701
- let callback = pluginCallbacks.get(request.key);
702
- if (!callback)
703
- sendResponse(id, {});
704
- else
705
- sendResponse(id, await callback(request));
706
- break;
707
- }
708
- case "on-resolve": {
709
- let callback = pluginCallbacks.get(request.key);
710
- if (!callback)
711
- sendResponse(id, {});
712
- else
713
- sendResponse(id, await callback(request));
714
- break;
715
- }
716
- case "on-load": {
717
- let callback = pluginCallbacks.get(request.key);
718
- if (!callback)
719
- sendResponse(id, {});
720
- else
721
- sendResponse(id, await callback(request));
722
- break;
723
- }
724
- case "serve-request": {
725
- let callbacks = serveCallbacks.get(request.key);
726
- if (callbacks && callbacks.onRequest)
727
- callbacks.onRequest(request.args);
728
- sendResponse(id, {});
729
- break;
730
- }
731
- case "serve-wait": {
732
- let callbacks = serveCallbacks.get(request.key);
733
- if (callbacks)
734
- callbacks.onWait(request.error);
735
- sendResponse(id, {});
736
- break;
737
- }
738
- case "watch-rebuild": {
739
- let callback = watchCallbacks.get(request.key);
740
- try {
741
- if (callback)
742
- callback(null, request.args);
743
- } catch (err) {
744
- console.error(err);
682
+ if (request.command === "ping") {
683
+ sendResponse(id, {});
684
+ return;
685
+ }
686
+ if (typeof request.key === "number") {
687
+ const requestCallbacks = requestCallbacksByKey[request.key];
688
+ if (requestCallbacks) {
689
+ const callback = requestCallbacks[request.command];
690
+ if (callback) {
691
+ await callback(id, request);
692
+ return;
745
693
  }
746
- sendResponse(id, {});
747
- break;
748
694
  }
749
- default:
750
- throw new Error(`Invalid command: ` + request.command);
751
695
  }
696
+ throw new Error(`Invalid command: ` + request.command);
752
697
  } catch (e) {
753
698
  sendResponse(id, { errors: [extractErrorMessageV8(e, streamIn, null, void 0, "")] });
754
699
  }
@@ -758,8 +703,8 @@ function createChannel(streamIn) {
758
703
  if (isFirstPacket) {
759
704
  isFirstPacket = false;
760
705
  let binaryVersion = String.fromCharCode(...bytes);
761
- if (binaryVersion !== "0.15.0") {
762
- throw new Error(`Cannot start service: Host version "${"0.15.0"}" does not match binary version ${JSON.stringify(binaryVersion)}`);
706
+ if (binaryVersion !== "0.15.8") {
707
+ throw new Error(`Cannot start service: Host version "${"0.15.8"}" does not match binary version ${JSON.stringify(binaryVersion)}`);
763
708
  }
764
709
  return;
765
710
  }
@@ -767,452 +712,259 @@ function createChannel(streamIn) {
767
712
  if (packet.isRequest) {
768
713
  handleRequest(packet.id, packet.value);
769
714
  } else {
770
- let callback = responseCallbacks.get(packet.id);
771
- responseCallbacks.delete(packet.id);
715
+ let callback = responseCallbacks[packet.id];
716
+ delete responseCallbacks[packet.id];
772
717
  if (packet.value.error)
773
718
  callback(packet.value.error, {});
774
719
  else
775
720
  callback(null, packet.value);
776
721
  }
777
722
  };
778
- let handlePlugins = async (initialOptions, plugins, buildKey, stash, refs) => {
779
- let onStartCallbacks = [];
780
- let onEndCallbacks = [];
781
- let onResolveCallbacks = {};
782
- let onLoadCallbacks = {};
783
- let nextCallbackID = 0;
784
- let i = 0;
785
- let requestPlugins = [];
786
- let isSetupDone = false;
787
- plugins = [...plugins];
788
- for (let item of plugins) {
789
- let keys = {};
790
- if (typeof item !== "object")
791
- throw new Error(`Plugin at index ${i} must be an object`);
792
- const name = getFlag(item, keys, "name", mustBeString);
793
- if (typeof name !== "string" || name === "")
794
- throw new Error(`Plugin at index ${i} is missing a name`);
723
+ let buildOrServe = ({ callName, refs, serveOptions, options, isTTY: isTTY2, defaultWD: defaultWD2, callback }) => {
724
+ let refCount = 0;
725
+ const buildKey = nextBuildKey++;
726
+ const requestCallbacks = {};
727
+ const buildRefs = {
728
+ ref() {
729
+ if (++refCount === 1) {
730
+ if (refs)
731
+ refs.ref();
732
+ }
733
+ },
734
+ unref() {
735
+ if (--refCount === 0) {
736
+ delete requestCallbacksByKey[buildKey];
737
+ if (refs)
738
+ refs.unref();
739
+ }
740
+ }
741
+ };
742
+ requestCallbacksByKey[buildKey] = requestCallbacks;
743
+ buildRefs.ref();
744
+ buildOrServeImpl(
745
+ callName,
746
+ buildKey,
747
+ sendRequest,
748
+ sendResponse,
749
+ buildRefs,
750
+ streamIn,
751
+ requestCallbacks,
752
+ options,
753
+ serveOptions,
754
+ isTTY2,
755
+ defaultWD2,
756
+ closeData,
757
+ (err, res) => {
758
+ try {
759
+ callback(err, res);
760
+ } finally {
761
+ buildRefs.unref();
762
+ }
763
+ }
764
+ );
765
+ };
766
+ let transform2 = ({ callName, refs, input, options, isTTY: isTTY2, fs: fs3, callback }) => {
767
+ const details = createObjectStash();
768
+ let start = (inputPath) => {
795
769
  try {
796
- let setup = getFlag(item, keys, "setup", mustBeFunction);
797
- if (typeof setup !== "function")
798
- throw new Error(`Plugin is missing a setup function`);
799
- checkForInvalidFlags(item, keys, `on plugin ${JSON.stringify(name)}`);
800
- let plugin = {
801
- name,
802
- onResolve: [],
803
- onLoad: []
804
- };
805
- i++;
806
- let resolve = (path3, options = {}) => {
807
- if (!isSetupDone)
808
- throw new Error('Cannot call "resolve" before plugin setup has completed');
809
- if (typeof path3 !== "string")
810
- throw new Error(`The path to resolve must be a string`);
811
- let keys2 = /* @__PURE__ */ Object.create(null);
812
- let pluginName = getFlag(options, keys2, "pluginName", mustBeString);
813
- let importer = getFlag(options, keys2, "importer", mustBeString);
814
- let namespace = getFlag(options, keys2, "namespace", mustBeString);
815
- let resolveDir = getFlag(options, keys2, "resolveDir", mustBeString);
816
- let kind = getFlag(options, keys2, "kind", mustBeString);
817
- let pluginData = getFlag(options, keys2, "pluginData", canBeAnything);
818
- checkForInvalidFlags(options, keys2, "in resolve() call");
819
- return new Promise((resolve2, reject) => {
820
- const request = {
821
- command: "resolve",
822
- path: path3,
823
- key: buildKey,
824
- pluginName: name
825
- };
826
- if (pluginName != null)
827
- request.pluginName = pluginName;
828
- if (importer != null)
829
- request.importer = importer;
830
- if (namespace != null)
831
- request.namespace = namespace;
832
- if (resolveDir != null)
833
- request.resolveDir = resolveDir;
834
- if (kind != null)
835
- request.kind = kind;
836
- if (pluginData != null)
837
- request.pluginData = stash.store(pluginData);
838
- sendRequest(refs, request, (error, response) => {
839
- if (error !== null)
840
- reject(new Error(error));
841
- else
842
- resolve2({
843
- errors: replaceDetailsInMessages(response.errors, stash),
844
- warnings: replaceDetailsInMessages(response.warnings, stash),
845
- path: response.path,
846
- external: response.external,
847
- sideEffects: response.sideEffects,
848
- namespace: response.namespace,
849
- suffix: response.suffix,
850
- pluginData: stash.load(response.pluginData)
851
- });
852
- });
853
- });
770
+ if (typeof input !== "string" && !(input instanceof Uint8Array))
771
+ throw new Error('The input to "transform" must be a string or a Uint8Array');
772
+ let {
773
+ flags,
774
+ mangleCache
775
+ } = flagsForTransformOptions(callName, options, isTTY2, transformLogLevelDefault);
776
+ let request = {
777
+ command: "transform",
778
+ flags,
779
+ inputFS: inputPath !== null,
780
+ input: inputPath !== null ? encodeUTF8(inputPath) : typeof input === "string" ? encodeUTF8(input) : input
854
781
  };
855
- let promise = setup({
856
- initialOptions,
857
- resolve,
858
- onStart(callback2) {
859
- let registeredText = `This error came from the "onStart" callback registered here:`;
860
- let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onStart");
861
- onStartCallbacks.push({ name, callback: callback2, note: registeredNote });
862
- },
863
- onEnd(callback2) {
864
- let registeredText = `This error came from the "onEnd" callback registered here:`;
865
- let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onEnd");
866
- onEndCallbacks.push({ name, callback: callback2, note: registeredNote });
867
- },
868
- onResolve(options, callback2) {
869
- let registeredText = `This error came from the "onResolve" callback registered here:`;
870
- let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onResolve");
871
- let keys2 = {};
872
- let filter = getFlag(options, keys2, "filter", mustBeRegExp);
873
- let namespace = getFlag(options, keys2, "namespace", mustBeString);
874
- checkForInvalidFlags(options, keys2, `in onResolve() call for plugin ${JSON.stringify(name)}`);
875
- if (filter == null)
876
- throw new Error(`onResolve() call is missing a filter`);
877
- let id = nextCallbackID++;
878
- onResolveCallbacks[id] = { name, callback: callback2, note: registeredNote };
879
- plugin.onResolve.push({ id, filter: filter.source, namespace: namespace || "" });
880
- },
881
- onLoad(options, callback2) {
882
- let registeredText = `This error came from the "onLoad" callback registered here:`;
883
- let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onLoad");
884
- let keys2 = {};
885
- let filter = getFlag(options, keys2, "filter", mustBeRegExp);
886
- let namespace = getFlag(options, keys2, "namespace", mustBeString);
887
- checkForInvalidFlags(options, keys2, `in onLoad() call for plugin ${JSON.stringify(name)}`);
888
- if (filter == null)
889
- throw new Error(`onLoad() call is missing a filter`);
890
- let id = nextCallbackID++;
891
- onLoadCallbacks[id] = { name, callback: callback2, note: registeredNote };
892
- plugin.onLoad.push({ id, filter: filter.source, namespace: namespace || "" });
893
- },
894
- esbuild: streamIn.esbuild
895
- });
896
- if (promise)
897
- await promise;
898
- requestPlugins.push(plugin);
899
- } catch (e) {
900
- return { ok: false, error: e, pluginName: name };
901
- }
902
- }
903
- const callback = async (request) => {
904
- switch (request.command) {
905
- case "on-start": {
906
- let response = { errors: [], warnings: [] };
907
- await Promise.all(onStartCallbacks.map(async ({ name, callback: callback2, note }) => {
908
- try {
909
- let result = await callback2();
910
- if (result != null) {
911
- if (typeof result !== "object")
912
- throw new Error(`Expected onStart() callback in plugin ${JSON.stringify(name)} to return an object`);
913
- let keys = {};
914
- let errors = getFlag(result, keys, "errors", mustBeArray);
915
- let warnings = getFlag(result, keys, "warnings", mustBeArray);
916
- checkForInvalidFlags(result, keys, `from onStart() callback in plugin ${JSON.stringify(name)}`);
917
- if (errors != null)
918
- response.errors.push(...sanitizeMessages(errors, "errors", stash, name));
919
- if (warnings != null)
920
- response.warnings.push(...sanitizeMessages(warnings, "warnings", stash, name));
921
- }
922
- } catch (e) {
923
- response.errors.push(extractErrorMessageV8(e, streamIn, stash, note && note(), name));
782
+ if (mangleCache)
783
+ request.mangleCache = mangleCache;
784
+ sendRequest(refs, request, (error, response) => {
785
+ if (error)
786
+ return callback(new Error(error), null);
787
+ let errors = replaceDetailsInMessages(response.errors, details);
788
+ let warnings = replaceDetailsInMessages(response.warnings, details);
789
+ let outstanding = 1;
790
+ let next = () => {
791
+ if (--outstanding === 0) {
792
+ let result = { warnings, code: response.code, map: response.map };
793
+ if (response.mangleCache)
794
+ result.mangleCache = response == null ? void 0 : response.mangleCache;
795
+ callback(null, result);
924
796
  }
925
- }));
926
- return response;
927
- }
928
- case "on-resolve": {
929
- let response = {}, name = "", callback2, note;
930
- for (let id of request.ids) {
931
- try {
932
- ({ name, callback: callback2, note } = onResolveCallbacks[id]);
933
- let result = await callback2({
934
- path: request.path,
935
- importer: request.importer,
936
- namespace: request.namespace,
937
- resolveDir: request.resolveDir,
938
- kind: request.kind,
939
- pluginData: stash.load(request.pluginData)
940
- });
941
- if (result != null) {
942
- if (typeof result !== "object")
943
- throw new Error(`Expected onResolve() callback in plugin ${JSON.stringify(name)} to return an object`);
944
- let keys = {};
945
- let pluginName = getFlag(result, keys, "pluginName", mustBeString);
946
- let path3 = getFlag(result, keys, "path", mustBeString);
947
- let namespace = getFlag(result, keys, "namespace", mustBeString);
948
- let suffix = getFlag(result, keys, "suffix", mustBeString);
949
- let external = getFlag(result, keys, "external", mustBeBoolean);
950
- let sideEffects = getFlag(result, keys, "sideEffects", mustBeBoolean);
951
- let pluginData = getFlag(result, keys, "pluginData", canBeAnything);
952
- let errors = getFlag(result, keys, "errors", mustBeArray);
953
- let warnings = getFlag(result, keys, "warnings", mustBeArray);
954
- let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
955
- let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
956
- checkForInvalidFlags(result, keys, `from onResolve() callback in plugin ${JSON.stringify(name)}`);
957
- response.id = id;
958
- if (pluginName != null)
959
- response.pluginName = pluginName;
960
- if (path3 != null)
961
- response.path = path3;
962
- if (namespace != null)
963
- response.namespace = namespace;
964
- if (suffix != null)
965
- response.suffix = suffix;
966
- if (external != null)
967
- response.external = external;
968
- if (sideEffects != null)
969
- response.sideEffects = sideEffects;
970
- if (pluginData != null)
971
- response.pluginData = stash.store(pluginData);
972
- if (errors != null)
973
- response.errors = sanitizeMessages(errors, "errors", stash, name);
974
- if (warnings != null)
975
- response.warnings = sanitizeMessages(warnings, "warnings", stash, name);
976
- if (watchFiles != null)
977
- response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles");
978
- if (watchDirs != null)
979
- response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs");
980
- break;
797
+ };
798
+ if (errors.length > 0)
799
+ return callback(failureErrorWithLog("Transform failed", errors, warnings), null);
800
+ if (response.codeFS) {
801
+ outstanding++;
802
+ fs3.readFile(response.code, (err, contents) => {
803
+ if (err !== null) {
804
+ callback(err, null);
805
+ } else {
806
+ response.code = contents;
807
+ next();
981
808
  }
982
- } catch (e) {
983
- return { id, errors: [extractErrorMessageV8(e, streamIn, stash, note && note(), name)] };
984
- }
809
+ });
985
810
  }
986
- return response;
987
- }
988
- case "on-load": {
989
- let response = {}, name = "", callback2, note;
990
- for (let id of request.ids) {
991
- try {
992
- ({ name, callback: callback2, note } = onLoadCallbacks[id]);
993
- let result = await callback2({
994
- path: request.path,
995
- namespace: request.namespace,
996
- suffix: request.suffix,
997
- pluginData: stash.load(request.pluginData)
998
- });
999
- if (result != null) {
1000
- if (typeof result !== "object")
1001
- throw new Error(`Expected onLoad() callback in plugin ${JSON.stringify(name)} to return an object`);
1002
- let keys = {};
1003
- let pluginName = getFlag(result, keys, "pluginName", mustBeString);
1004
- let contents = getFlag(result, keys, "contents", mustBeStringOrUint8Array);
1005
- let resolveDir = getFlag(result, keys, "resolveDir", mustBeString);
1006
- let pluginData = getFlag(result, keys, "pluginData", canBeAnything);
1007
- let loader = getFlag(result, keys, "loader", mustBeString);
1008
- let errors = getFlag(result, keys, "errors", mustBeArray);
1009
- let warnings = getFlag(result, keys, "warnings", mustBeArray);
1010
- let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
1011
- let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
1012
- checkForInvalidFlags(result, keys, `from onLoad() callback in plugin ${JSON.stringify(name)}`);
1013
- response.id = id;
1014
- if (pluginName != null)
1015
- response.pluginName = pluginName;
1016
- if (contents instanceof Uint8Array)
1017
- response.contents = contents;
1018
- else if (contents != null)
1019
- response.contents = encodeUTF8(contents);
1020
- if (resolveDir != null)
1021
- response.resolveDir = resolveDir;
1022
- if (pluginData != null)
1023
- response.pluginData = stash.store(pluginData);
1024
- if (loader != null)
1025
- response.loader = loader;
1026
- if (errors != null)
1027
- response.errors = sanitizeMessages(errors, "errors", stash, name);
1028
- if (warnings != null)
1029
- response.warnings = sanitizeMessages(warnings, "warnings", stash, name);
1030
- if (watchFiles != null)
1031
- response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles");
1032
- if (watchDirs != null)
1033
- response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs");
1034
- break;
811
+ if (response.mapFS) {
812
+ outstanding++;
813
+ fs3.readFile(response.map, (err, contents) => {
814
+ if (err !== null) {
815
+ callback(err, null);
816
+ } else {
817
+ response.map = contents;
818
+ next();
1035
819
  }
1036
- } catch (e) {
1037
- return { id, errors: [extractErrorMessageV8(e, streamIn, stash, note && note(), name)] };
1038
- }
820
+ });
1039
821
  }
1040
- return response;
822
+ next();
823
+ });
824
+ } catch (e) {
825
+ let flags = [];
826
+ try {
827
+ pushLogFlags(flags, options, {}, isTTY2, transformLogLevelDefault);
828
+ } catch {
1041
829
  }
1042
- default:
1043
- throw new Error(`Invalid command: ` + request.command);
830
+ const error = extractErrorMessageV8(e, streamIn, details, void 0, "");
831
+ sendRequest(refs, { command: "error", flags, error }, () => {
832
+ error.detail = details.load(error.detail);
833
+ callback(failureErrorWithLog("Transform failed", [error], []), null);
834
+ });
1044
835
  }
1045
836
  };
1046
- let runOnEndCallbacks = (result, logPluginError, done) => done();
1047
- if (onEndCallbacks.length > 0) {
1048
- runOnEndCallbacks = (result, logPluginError, done) => {
1049
- (async () => {
1050
- for (const { name, callback: callback2, note } of onEndCallbacks) {
1051
- try {
1052
- await callback2(result);
1053
- } catch (e) {
1054
- result.errors.push(await new Promise((resolve) => logPluginError(e, name, note && note(), resolve)));
1055
- }
1056
- }
1057
- })().then(done);
1058
- };
837
+ if ((typeof input === "string" || input instanceof Uint8Array) && input.length > 1024 * 1024) {
838
+ let next = start;
839
+ start = () => fs3.writeFile(input, next);
1059
840
  }
1060
- isSetupDone = true;
1061
- let refCount = 0;
1062
- return {
1063
- ok: true,
1064
- requestPlugins,
1065
- runOnEndCallbacks,
1066
- pluginRefs: {
1067
- ref() {
1068
- if (++refCount === 1)
1069
- pluginCallbacks.set(buildKey, callback);
1070
- },
1071
- unref() {
1072
- if (--refCount === 0)
1073
- pluginCallbacks.delete(buildKey);
1074
- }
1075
- }
1076
- };
841
+ start(null);
1077
842
  };
1078
- let buildServeData = (refs, options, request, key) => {
843
+ let formatMessages2 = ({ callName, refs, messages, options, callback }) => {
844
+ let result = sanitizeMessages(messages, "messages", null, "");
845
+ if (!options)
846
+ throw new Error(`Missing second argument in ${callName}() call`);
1079
847
  let keys = {};
1080
- let port = getFlag(options, keys, "port", mustBeInteger);
1081
- let host = getFlag(options, keys, "host", mustBeString);
1082
- let servedir = getFlag(options, keys, "servedir", mustBeString);
1083
- let onRequest = getFlag(options, keys, "onRequest", mustBeFunction);
1084
- let onWait;
1085
- let wait = new Promise((resolve, reject) => {
1086
- onWait = (error) => {
1087
- serveCallbacks.delete(key);
1088
- if (error !== null)
1089
- reject(new Error(error));
1090
- else
1091
- resolve();
1092
- };
1093
- });
1094
- request.serve = {};
1095
- checkForInvalidFlags(options, keys, `in serve() call`);
1096
- if (port !== void 0)
1097
- request.serve.port = port;
1098
- if (host !== void 0)
1099
- request.serve.host = host;
1100
- if (servedir !== void 0)
1101
- request.serve.servedir = servedir;
1102
- serveCallbacks.set(key, {
1103
- onRequest,
1104
- onWait
848
+ let kind = getFlag(options, keys, "kind", mustBeString);
849
+ let color = getFlag(options, keys, "color", mustBeBoolean);
850
+ let terminalWidth = getFlag(options, keys, "terminalWidth", mustBeInteger);
851
+ checkForInvalidFlags(options, keys, `in ${callName}() call`);
852
+ if (kind === void 0)
853
+ throw new Error(`Missing "kind" in ${callName}() call`);
854
+ if (kind !== "error" && kind !== "warning")
855
+ throw new Error(`Expected "kind" to be "error" or "warning" in ${callName}() call`);
856
+ let request = {
857
+ command: "format-msgs",
858
+ messages: result,
859
+ isWarning: kind === "warning"
860
+ };
861
+ if (color !== void 0)
862
+ request.color = color;
863
+ if (terminalWidth !== void 0)
864
+ request.terminalWidth = terminalWidth;
865
+ sendRequest(refs, request, (error, response) => {
866
+ if (error)
867
+ return callback(new Error(error), null);
868
+ callback(null, response.messages);
1105
869
  });
1106
- return {
1107
- wait,
1108
- stop() {
1109
- sendRequest(refs, { command: "serve-stop", key }, () => {
1110
- });
1111
- }
870
+ };
871
+ let analyzeMetafile2 = ({ callName, refs, metafile, options, callback }) => {
872
+ if (options === void 0)
873
+ options = {};
874
+ let keys = {};
875
+ let color = getFlag(options, keys, "color", mustBeBoolean);
876
+ let verbose = getFlag(options, keys, "verbose", mustBeBoolean);
877
+ checkForInvalidFlags(options, keys, `in ${callName}() call`);
878
+ let request = {
879
+ command: "analyze-metafile",
880
+ metafile
1112
881
  };
882
+ if (color !== void 0)
883
+ request.color = color;
884
+ if (verbose !== void 0)
885
+ request.verbose = verbose;
886
+ sendRequest(refs, request, (error, response) => {
887
+ if (error)
888
+ return callback(new Error(error), null);
889
+ callback(null, response.result);
890
+ });
1113
891
  };
1114
- const buildLogLevelDefault = "warning";
1115
- const transformLogLevelDefault = "silent";
1116
- let buildOrServe = (args) => {
1117
- let key = nextBuildKey++;
1118
- const details = createObjectStash();
1119
- let plugins;
1120
- let { refs, options, isTTY: isTTY2, callback } = args;
1121
- if (typeof options === "object") {
1122
- let value = options.plugins;
1123
- if (value !== void 0) {
1124
- if (!Array.isArray(value))
1125
- throw new Error(`"plugins" must be an array`);
1126
- plugins = value;
1127
- }
892
+ return {
893
+ readFromStdout,
894
+ afterClose,
895
+ service: {
896
+ buildOrServe,
897
+ transform: transform2,
898
+ formatMessages: formatMessages2,
899
+ analyzeMetafile: analyzeMetafile2
1128
900
  }
1129
- let logPluginError = (e, pluginName, note, done) => {
1130
- let flags = [];
1131
- try {
1132
- pushLogFlags(flags, options, {}, isTTY2, buildLogLevelDefault);
1133
- } catch {
1134
- }
1135
- const message = extractErrorMessageV8(e, streamIn, details, note, pluginName);
1136
- sendRequest(refs, { command: "error", flags, error: message }, () => {
1137
- message.detail = details.load(message.detail);
1138
- done(message);
1139
- });
1140
- };
1141
- let handleError = (e, pluginName) => {
1142
- logPluginError(e, pluginName, void 0, (error) => {
1143
- callback(failureErrorWithLog("Build failed", [error], []), null);
1144
- });
1145
- };
1146
- if (plugins && plugins.length > 0) {
1147
- if (streamIn.isSync)
1148
- return handleError(new Error("Cannot use plugins in synchronous API calls"), "");
1149
- handlePlugins(options, plugins, key, details, refs).then(
1150
- (result) => {
1151
- if (!result.ok) {
1152
- handleError(result.error, result.pluginName);
1153
- } else {
1154
- try {
1155
- buildOrServeContinue({
1156
- ...args,
1157
- key,
1158
- details,
1159
- logPluginError,
1160
- requestPlugins: result.requestPlugins,
1161
- runOnEndCallbacks: result.runOnEndCallbacks,
1162
- pluginRefs: result.pluginRefs
1163
- });
1164
- } catch (e) {
1165
- handleError(e, "");
1166
- }
1167
- }
1168
- },
1169
- (e) => handleError(e, "")
1170
- );
1171
- } else {
1172
- try {
1173
- buildOrServeContinue({
1174
- ...args,
1175
- key,
1176
- details,
1177
- logPluginError,
1178
- requestPlugins: null,
1179
- runOnEndCallbacks: (result, logPluginError2, done) => done(),
1180
- pluginRefs: null
1181
- });
1182
- } catch (e) {
1183
- handleError(e, "");
1184
- }
901
+ };
902
+ }
903
+ function buildOrServeImpl(callName, buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, options, serveOptions, isTTY2, defaultWD2, closeData, callback) {
904
+ const details = createObjectStash();
905
+ const logPluginError = (e, pluginName, note, done) => {
906
+ const flags = [];
907
+ try {
908
+ pushLogFlags(flags, options, {}, isTTY2, buildLogLevelDefault);
909
+ } catch {
1185
910
  }
911
+ const message = extractErrorMessageV8(e, streamIn, details, note, pluginName);
912
+ sendRequest(refs, { command: "error", flags, error: message }, () => {
913
+ message.detail = details.load(message.detail);
914
+ done(message);
915
+ });
1186
916
  };
1187
- let buildOrServeContinue = ({
1188
- callName,
1189
- refs: callerRefs,
1190
- serveOptions,
1191
- options,
1192
- isTTY: isTTY2,
1193
- defaultWD: defaultWD2,
1194
- callback,
1195
- key,
1196
- details,
1197
- logPluginError,
1198
- requestPlugins,
1199
- runOnEndCallbacks,
1200
- pluginRefs
1201
- }) => {
1202
- const refs = {
1203
- ref() {
1204
- if (pluginRefs)
1205
- pluginRefs.ref();
1206
- if (callerRefs)
1207
- callerRefs.ref();
917
+ const handleError = (e, pluginName) => {
918
+ logPluginError(e, pluginName, void 0, (error) => {
919
+ callback(failureErrorWithLog("Build failed", [error], []), null);
920
+ });
921
+ };
922
+ let plugins;
923
+ if (typeof options === "object") {
924
+ const value = options.plugins;
925
+ if (value !== void 0) {
926
+ if (!Array.isArray(value))
927
+ throw new Error(`"plugins" must be an array`);
928
+ plugins = value;
929
+ }
930
+ }
931
+ if (plugins && plugins.length > 0) {
932
+ if (streamIn.isSync) {
933
+ handleError(new Error("Cannot use plugins in synchronous API calls"), "");
934
+ return;
935
+ }
936
+ handlePlugins(
937
+ buildKey,
938
+ sendRequest,
939
+ sendResponse,
940
+ refs,
941
+ streamIn,
942
+ requestCallbacks,
943
+ options,
944
+ plugins,
945
+ details
946
+ ).then(
947
+ (result) => {
948
+ if (!result.ok) {
949
+ handleError(result.error, result.pluginName);
950
+ return;
951
+ }
952
+ try {
953
+ buildOrServeContinue(result.requestPlugins, result.runOnEndCallbacks);
954
+ } catch (e) {
955
+ handleError(e, "");
956
+ }
1208
957
  },
1209
- unref() {
1210
- if (pluginRefs)
1211
- pluginRefs.unref();
1212
- if (callerRefs)
1213
- callerRefs.unref();
1214
- }
1215
- };
958
+ (e) => handleError(e, "")
959
+ );
960
+ return;
961
+ }
962
+ try {
963
+ buildOrServeContinue(null, (result, logPluginError2, done) => done());
964
+ } catch (e) {
965
+ handleError(e, "");
966
+ }
967
+ function buildOrServeContinue(requestPlugins, runOnEndCallbacks) {
1216
968
  let writeDefault = !streamIn.isWriteUnavailable;
1217
969
  let {
1218
970
  entries,
@@ -1228,7 +980,7 @@ function createChannel(streamIn) {
1228
980
  } = flagsForBuildOptions(callName, options, isTTY2, buildLogLevelDefault, writeDefault);
1229
981
  let request = {
1230
982
  command: "build",
1231
- key,
983
+ key: buildKey,
1232
984
  entries,
1233
985
  flags,
1234
986
  write,
@@ -1242,7 +994,7 @@ function createChannel(streamIn) {
1242
994
  request.plugins = requestPlugins;
1243
995
  if (mangleCache)
1244
996
  request.mangleCache = mangleCache;
1245
- let serve2 = serveOptions && buildServeData(refs, serveOptions, request, key);
997
+ let serve2 = serveOptions && buildServeData(buildKey, sendRequest, sendResponse, refs, requestCallbacks, serveOptions, request);
1246
998
  let rebuild;
1247
999
  let stop;
1248
1000
  let copyResponseToResult = (response, result) => {
@@ -1269,11 +1021,11 @@ function createChannel(streamIn) {
1269
1021
  if (!rebuild) {
1270
1022
  let isDisposed = false;
1271
1023
  rebuild = () => new Promise((resolve, reject) => {
1272
- if (isDisposed || closeData)
1024
+ if (isDisposed || closeData.didClose)
1273
1025
  throw new Error("Cannot rebuild");
1274
1026
  sendRequest(
1275
1027
  refs,
1276
- { command: "rebuild", key },
1028
+ { command: "rebuild", key: buildKey },
1277
1029
  (error2, response2) => {
1278
1030
  if (error2) {
1279
1031
  const message = { id: "", pluginName: "", text: error2, location: null, notes: [], detail: void 0 };
@@ -1293,7 +1045,7 @@ function createChannel(streamIn) {
1293
1045
  if (isDisposed)
1294
1046
  return;
1295
1047
  isDisposed = true;
1296
- sendRequest(refs, { command: "rebuild-dispose", key }, () => {
1048
+ sendRequest(refs, { command: "rebuild-dispose", key: buildKey }, () => {
1297
1049
  });
1298
1050
  refs.unref();
1299
1051
  };
@@ -1308,36 +1060,35 @@ function createChannel(streamIn) {
1308
1060
  if (isStopped)
1309
1061
  return;
1310
1062
  isStopped = true;
1311
- watchCallbacks.delete(key);
1312
- sendRequest(refs, { command: "watch-stop", key }, () => {
1063
+ delete requestCallbacks["watch-rebuild"];
1064
+ sendRequest(refs, { command: "watch-stop", key: buildKey }, () => {
1313
1065
  });
1314
1066
  refs.unref();
1315
1067
  };
1316
1068
  if (watch) {
1317
- watchCallbacks.set(key, (serviceStopError, watchResponse) => {
1318
- if (serviceStopError) {
1319
- if (watch.onRebuild)
1320
- watch.onRebuild(serviceStopError, null);
1321
- return;
1322
- }
1323
- let result2 = {
1324
- errors: replaceDetailsInMessages(watchResponse.errors, details),
1325
- warnings: replaceDetailsInMessages(watchResponse.warnings, details)
1326
- };
1327
- copyResponseToResult(watchResponse, result2);
1328
- runOnEndCallbacks(result2, logPluginError, () => {
1329
- if (result2.errors.length > 0) {
1069
+ requestCallbacks["watch-rebuild"] = (id, request2) => {
1070
+ try {
1071
+ let watchResponse = request2.args;
1072
+ let result2 = {
1073
+ errors: replaceDetailsInMessages(watchResponse.errors, details),
1074
+ warnings: replaceDetailsInMessages(watchResponse.warnings, details)
1075
+ };
1076
+ copyResponseToResult(watchResponse, result2);
1077
+ runOnEndCallbacks(result2, logPluginError, () => {
1078
+ if (result2.errors.length > 0) {
1079
+ if (watch.onRebuild)
1080
+ watch.onRebuild(failureErrorWithLog("Build failed", result2.errors, result2.warnings), null);
1081
+ return;
1082
+ }
1083
+ result2.stop = stop;
1330
1084
  if (watch.onRebuild)
1331
- watch.onRebuild(failureErrorWithLog("Build failed", result2.errors, result2.warnings), null);
1332
- return;
1333
- }
1334
- if (watchResponse.rebuildID !== void 0)
1335
- result2.rebuild = rebuild;
1336
- result2.stop = stop;
1337
- if (watch.onRebuild)
1338
- watch.onRebuild(null, result2);
1339
- });
1340
- });
1085
+ watch.onRebuild(null, result2);
1086
+ });
1087
+ } catch (err) {
1088
+ console.error(err);
1089
+ }
1090
+ sendResponse(id, {});
1091
+ };
1341
1092
  }
1342
1093
  }
1343
1094
  result.stop = stop;
@@ -1376,144 +1127,329 @@ function createChannel(streamIn) {
1376
1127
  }
1377
1128
  return buildResponseToResult(response, callback);
1378
1129
  });
1130
+ }
1131
+ }
1132
+ var buildServeData = (buildKey, sendRequest, sendResponse, refs, requestCallbacks, options, request) => {
1133
+ let keys = {};
1134
+ let port = getFlag(options, keys, "port", mustBeInteger);
1135
+ let host = getFlag(options, keys, "host", mustBeString);
1136
+ let servedir = getFlag(options, keys, "servedir", mustBeString);
1137
+ let onRequest = getFlag(options, keys, "onRequest", mustBeFunction);
1138
+ let wait = new Promise((resolve, reject) => {
1139
+ requestCallbacks["serve-wait"] = (id, request2) => {
1140
+ if (request2.error !== null)
1141
+ reject(new Error(request2.error));
1142
+ else
1143
+ resolve();
1144
+ sendResponse(id, {});
1145
+ };
1146
+ });
1147
+ request.serve = {};
1148
+ checkForInvalidFlags(options, keys, `in serve() call`);
1149
+ if (port !== void 0)
1150
+ request.serve.port = port;
1151
+ if (host !== void 0)
1152
+ request.serve.host = host;
1153
+ if (servedir !== void 0)
1154
+ request.serve.servedir = servedir;
1155
+ requestCallbacks["serve-request"] = (id, request2) => {
1156
+ if (onRequest)
1157
+ onRequest(request2.args);
1158
+ sendResponse(id, {});
1379
1159
  };
1380
- let transform2 = ({ callName, refs, input, options, isTTY: isTTY2, fs: fs3, callback }) => {
1381
- const details = createObjectStash();
1382
- let start = (inputPath) => {
1383
- try {
1384
- if (typeof input !== "string" && !(input instanceof Uint8Array))
1385
- throw new Error('The input to "transform" must be a string or a Uint8Array');
1386
- let {
1387
- flags,
1388
- mangleCache
1389
- } = flagsForTransformOptions(callName, options, isTTY2, transformLogLevelDefault);
1390
- let request = {
1391
- command: "transform",
1392
- flags,
1393
- inputFS: inputPath !== null,
1394
- input: inputPath !== null ? encodeUTF8(inputPath) : typeof input === "string" ? encodeUTF8(input) : input
1395
- };
1396
- if (mangleCache)
1397
- request.mangleCache = mangleCache;
1398
- sendRequest(refs, request, (error, response) => {
1399
- if (error)
1400
- return callback(new Error(error), null);
1401
- let errors = replaceDetailsInMessages(response.errors, details);
1402
- let warnings = replaceDetailsInMessages(response.warnings, details);
1403
- let outstanding = 1;
1404
- let next = () => {
1405
- if (--outstanding === 0) {
1406
- let result = { warnings, code: response.code, map: response.map };
1407
- if (response.mangleCache)
1408
- result.mangleCache = response == null ? void 0 : response.mangleCache;
1409
- callback(null, result);
1410
- }
1160
+ return {
1161
+ wait,
1162
+ stop() {
1163
+ sendRequest(refs, { command: "serve-stop", key: buildKey }, () => {
1164
+ });
1165
+ }
1166
+ };
1167
+ };
1168
+ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, initialOptions, plugins, details) => {
1169
+ let onStartCallbacks = [];
1170
+ let onEndCallbacks = [];
1171
+ let onResolveCallbacks = {};
1172
+ let onLoadCallbacks = {};
1173
+ let nextCallbackID = 0;
1174
+ let i = 0;
1175
+ let requestPlugins = [];
1176
+ let isSetupDone = false;
1177
+ plugins = [...plugins];
1178
+ for (let item of plugins) {
1179
+ let keys = {};
1180
+ if (typeof item !== "object")
1181
+ throw new Error(`Plugin at index ${i} must be an object`);
1182
+ const name = getFlag(item, keys, "name", mustBeString);
1183
+ if (typeof name !== "string" || name === "")
1184
+ throw new Error(`Plugin at index ${i} is missing a name`);
1185
+ try {
1186
+ let setup = getFlag(item, keys, "setup", mustBeFunction);
1187
+ if (typeof setup !== "function")
1188
+ throw new Error(`Plugin is missing a setup function`);
1189
+ checkForInvalidFlags(item, keys, `on plugin ${JSON.stringify(name)}`);
1190
+ let plugin = {
1191
+ name,
1192
+ onResolve: [],
1193
+ onLoad: []
1194
+ };
1195
+ i++;
1196
+ let resolve = (path3, options = {}) => {
1197
+ if (!isSetupDone)
1198
+ throw new Error('Cannot call "resolve" before plugin setup has completed');
1199
+ if (typeof path3 !== "string")
1200
+ throw new Error(`The path to resolve must be a string`);
1201
+ let keys2 = /* @__PURE__ */ Object.create(null);
1202
+ let pluginName = getFlag(options, keys2, "pluginName", mustBeString);
1203
+ let importer = getFlag(options, keys2, "importer", mustBeString);
1204
+ let namespace = getFlag(options, keys2, "namespace", mustBeString);
1205
+ let resolveDir = getFlag(options, keys2, "resolveDir", mustBeString);
1206
+ let kind = getFlag(options, keys2, "kind", mustBeString);
1207
+ let pluginData = getFlag(options, keys2, "pluginData", canBeAnything);
1208
+ checkForInvalidFlags(options, keys2, "in resolve() call");
1209
+ return new Promise((resolve2, reject) => {
1210
+ const request = {
1211
+ command: "resolve",
1212
+ path: path3,
1213
+ key: buildKey,
1214
+ pluginName: name
1411
1215
  };
1412
- if (errors.length > 0)
1413
- return callback(failureErrorWithLog("Transform failed", errors, warnings), null);
1414
- if (response.codeFS) {
1415
- outstanding++;
1416
- fs3.readFile(response.code, (err, contents) => {
1417
- if (err !== null) {
1418
- callback(err, null);
1419
- } else {
1420
- response.code = contents;
1421
- next();
1422
- }
1423
- });
1424
- }
1425
- if (response.mapFS) {
1426
- outstanding++;
1427
- fs3.readFile(response.map, (err, contents) => {
1428
- if (err !== null) {
1429
- callback(err, null);
1430
- } else {
1431
- response.map = contents;
1432
- next();
1433
- }
1434
- });
1435
- }
1436
- next();
1216
+ if (pluginName != null)
1217
+ request.pluginName = pluginName;
1218
+ if (importer != null)
1219
+ request.importer = importer;
1220
+ if (namespace != null)
1221
+ request.namespace = namespace;
1222
+ if (resolveDir != null)
1223
+ request.resolveDir = resolveDir;
1224
+ if (kind != null)
1225
+ request.kind = kind;
1226
+ if (pluginData != null)
1227
+ request.pluginData = details.store(pluginData);
1228
+ sendRequest(refs, request, (error, response) => {
1229
+ if (error !== null)
1230
+ reject(new Error(error));
1231
+ else
1232
+ resolve2({
1233
+ errors: replaceDetailsInMessages(response.errors, details),
1234
+ warnings: replaceDetailsInMessages(response.warnings, details),
1235
+ path: response.path,
1236
+ external: response.external,
1237
+ sideEffects: response.sideEffects,
1238
+ namespace: response.namespace,
1239
+ suffix: response.suffix,
1240
+ pluginData: details.load(response.pluginData)
1241
+ });
1242
+ });
1437
1243
  });
1438
- } catch (e) {
1439
- let flags = [];
1440
- try {
1441
- pushLogFlags(flags, options, {}, isTTY2, transformLogLevelDefault);
1442
- } catch {
1244
+ };
1245
+ let promise = setup({
1246
+ initialOptions,
1247
+ resolve,
1248
+ onStart(callback) {
1249
+ let registeredText = `This error came from the "onStart" callback registered here:`;
1250
+ let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onStart");
1251
+ onStartCallbacks.push({ name, callback, note: registeredNote });
1252
+ },
1253
+ onEnd(callback) {
1254
+ let registeredText = `This error came from the "onEnd" callback registered here:`;
1255
+ let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onEnd");
1256
+ onEndCallbacks.push({ name, callback, note: registeredNote });
1257
+ },
1258
+ onResolve(options, callback) {
1259
+ let registeredText = `This error came from the "onResolve" callback registered here:`;
1260
+ let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onResolve");
1261
+ let keys2 = {};
1262
+ let filter = getFlag(options, keys2, "filter", mustBeRegExp);
1263
+ let namespace = getFlag(options, keys2, "namespace", mustBeString);
1264
+ checkForInvalidFlags(options, keys2, `in onResolve() call for plugin ${JSON.stringify(name)}`);
1265
+ if (filter == null)
1266
+ throw new Error(`onResolve() call is missing a filter`);
1267
+ let id = nextCallbackID++;
1268
+ onResolveCallbacks[id] = { name, callback, note: registeredNote };
1269
+ plugin.onResolve.push({ id, filter: filter.source, namespace: namespace || "" });
1270
+ },
1271
+ onLoad(options, callback) {
1272
+ let registeredText = `This error came from the "onLoad" callback registered here:`;
1273
+ let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onLoad");
1274
+ let keys2 = {};
1275
+ let filter = getFlag(options, keys2, "filter", mustBeRegExp);
1276
+ let namespace = getFlag(options, keys2, "namespace", mustBeString);
1277
+ checkForInvalidFlags(options, keys2, `in onLoad() call for plugin ${JSON.stringify(name)}`);
1278
+ if (filter == null)
1279
+ throw new Error(`onLoad() call is missing a filter`);
1280
+ let id = nextCallbackID++;
1281
+ onLoadCallbacks[id] = { name, callback, note: registeredNote };
1282
+ plugin.onLoad.push({ id, filter: filter.source, namespace: namespace || "" });
1283
+ },
1284
+ esbuild: streamIn.esbuild
1285
+ });
1286
+ if (promise)
1287
+ await promise;
1288
+ requestPlugins.push(plugin);
1289
+ } catch (e) {
1290
+ return { ok: false, error: e, pluginName: name };
1291
+ }
1292
+ }
1293
+ requestCallbacks["on-start"] = async (id, request) => {
1294
+ let response = { errors: [], warnings: [] };
1295
+ await Promise.all(onStartCallbacks.map(async ({ name, callback, note }) => {
1296
+ try {
1297
+ let result = await callback();
1298
+ if (result != null) {
1299
+ if (typeof result !== "object")
1300
+ throw new Error(`Expected onStart() callback in plugin ${JSON.stringify(name)} to return an object`);
1301
+ let keys = {};
1302
+ let errors = getFlag(result, keys, "errors", mustBeArray);
1303
+ let warnings = getFlag(result, keys, "warnings", mustBeArray);
1304
+ checkForInvalidFlags(result, keys, `from onStart() callback in plugin ${JSON.stringify(name)}`);
1305
+ if (errors != null)
1306
+ response.errors.push(...sanitizeMessages(errors, "errors", details, name));
1307
+ if (warnings != null)
1308
+ response.warnings.push(...sanitizeMessages(warnings, "warnings", details, name));
1443
1309
  }
1444
- const error = extractErrorMessageV8(e, streamIn, details, void 0, "");
1445
- sendRequest(refs, { command: "error", flags, error }, () => {
1446
- error.detail = details.load(error.detail);
1447
- callback(failureErrorWithLog("Transform failed", [error], []), null);
1310
+ } catch (e) {
1311
+ response.errors.push(extractErrorMessageV8(e, streamIn, details, note && note(), name));
1312
+ }
1313
+ }));
1314
+ sendResponse(id, response);
1315
+ };
1316
+ requestCallbacks["on-resolve"] = async (id, request) => {
1317
+ let response = {}, name = "", callback, note;
1318
+ for (let id2 of request.ids) {
1319
+ try {
1320
+ ({ name, callback, note } = onResolveCallbacks[id2]);
1321
+ let result = await callback({
1322
+ path: request.path,
1323
+ importer: request.importer,
1324
+ namespace: request.namespace,
1325
+ resolveDir: request.resolveDir,
1326
+ kind: request.kind,
1327
+ pluginData: details.load(request.pluginData)
1448
1328
  });
1329
+ if (result != null) {
1330
+ if (typeof result !== "object")
1331
+ throw new Error(`Expected onResolve() callback in plugin ${JSON.stringify(name)} to return an object`);
1332
+ let keys = {};
1333
+ let pluginName = getFlag(result, keys, "pluginName", mustBeString);
1334
+ let path3 = getFlag(result, keys, "path", mustBeString);
1335
+ let namespace = getFlag(result, keys, "namespace", mustBeString);
1336
+ let suffix = getFlag(result, keys, "suffix", mustBeString);
1337
+ let external = getFlag(result, keys, "external", mustBeBoolean);
1338
+ let sideEffects = getFlag(result, keys, "sideEffects", mustBeBoolean);
1339
+ let pluginData = getFlag(result, keys, "pluginData", canBeAnything);
1340
+ let errors = getFlag(result, keys, "errors", mustBeArray);
1341
+ let warnings = getFlag(result, keys, "warnings", mustBeArray);
1342
+ let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
1343
+ let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
1344
+ checkForInvalidFlags(result, keys, `from onResolve() callback in plugin ${JSON.stringify(name)}`);
1345
+ response.id = id2;
1346
+ if (pluginName != null)
1347
+ response.pluginName = pluginName;
1348
+ if (path3 != null)
1349
+ response.path = path3;
1350
+ if (namespace != null)
1351
+ response.namespace = namespace;
1352
+ if (suffix != null)
1353
+ response.suffix = suffix;
1354
+ if (external != null)
1355
+ response.external = external;
1356
+ if (sideEffects != null)
1357
+ response.sideEffects = sideEffects;
1358
+ if (pluginData != null)
1359
+ response.pluginData = details.store(pluginData);
1360
+ if (errors != null)
1361
+ response.errors = sanitizeMessages(errors, "errors", details, name);
1362
+ if (warnings != null)
1363
+ response.warnings = sanitizeMessages(warnings, "warnings", details, name);
1364
+ if (watchFiles != null)
1365
+ response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles");
1366
+ if (watchDirs != null)
1367
+ response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs");
1368
+ break;
1369
+ }
1370
+ } catch (e) {
1371
+ response = { id: id2, errors: [extractErrorMessageV8(e, streamIn, details, note && note(), name)] };
1372
+ break;
1449
1373
  }
1450
- };
1451
- if ((typeof input === "string" || input instanceof Uint8Array) && input.length > 1024 * 1024) {
1452
- let next = start;
1453
- start = () => fs3.writeFile(input, next);
1454
1374
  }
1455
- start(null);
1375
+ sendResponse(id, response);
1456
1376
  };
1457
- let formatMessages2 = ({ callName, refs, messages, options, callback }) => {
1458
- let result = sanitizeMessages(messages, "messages", null, "");
1459
- if (!options)
1460
- throw new Error(`Missing second argument in ${callName}() call`);
1461
- let keys = {};
1462
- let kind = getFlag(options, keys, "kind", mustBeString);
1463
- let color = getFlag(options, keys, "color", mustBeBoolean);
1464
- let terminalWidth = getFlag(options, keys, "terminalWidth", mustBeInteger);
1465
- checkForInvalidFlags(options, keys, `in ${callName}() call`);
1466
- if (kind === void 0)
1467
- throw new Error(`Missing "kind" in ${callName}() call`);
1468
- if (kind !== "error" && kind !== "warning")
1469
- throw new Error(`Expected "kind" to be "error" or "warning" in ${callName}() call`);
1470
- let request = {
1471
- command: "format-msgs",
1472
- messages: result,
1473
- isWarning: kind === "warning"
1474
- };
1475
- if (color !== void 0)
1476
- request.color = color;
1477
- if (terminalWidth !== void 0)
1478
- request.terminalWidth = terminalWidth;
1479
- sendRequest(refs, request, (error, response) => {
1480
- if (error)
1481
- return callback(new Error(error), null);
1482
- callback(null, response.messages);
1483
- });
1377
+ requestCallbacks["on-load"] = async (id, request) => {
1378
+ let response = {}, name = "", callback, note;
1379
+ for (let id2 of request.ids) {
1380
+ try {
1381
+ ({ name, callback, note } = onLoadCallbacks[id2]);
1382
+ let result = await callback({
1383
+ path: request.path,
1384
+ namespace: request.namespace,
1385
+ suffix: request.suffix,
1386
+ pluginData: details.load(request.pluginData)
1387
+ });
1388
+ if (result != null) {
1389
+ if (typeof result !== "object")
1390
+ throw new Error(`Expected onLoad() callback in plugin ${JSON.stringify(name)} to return an object`);
1391
+ let keys = {};
1392
+ let pluginName = getFlag(result, keys, "pluginName", mustBeString);
1393
+ let contents = getFlag(result, keys, "contents", mustBeStringOrUint8Array);
1394
+ let resolveDir = getFlag(result, keys, "resolveDir", mustBeString);
1395
+ let pluginData = getFlag(result, keys, "pluginData", canBeAnything);
1396
+ let loader = getFlag(result, keys, "loader", mustBeString);
1397
+ let errors = getFlag(result, keys, "errors", mustBeArray);
1398
+ let warnings = getFlag(result, keys, "warnings", mustBeArray);
1399
+ let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
1400
+ let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
1401
+ checkForInvalidFlags(result, keys, `from onLoad() callback in plugin ${JSON.stringify(name)}`);
1402
+ response.id = id2;
1403
+ if (pluginName != null)
1404
+ response.pluginName = pluginName;
1405
+ if (contents instanceof Uint8Array)
1406
+ response.contents = contents;
1407
+ else if (contents != null)
1408
+ response.contents = encodeUTF8(contents);
1409
+ if (resolveDir != null)
1410
+ response.resolveDir = resolveDir;
1411
+ if (pluginData != null)
1412
+ response.pluginData = details.store(pluginData);
1413
+ if (loader != null)
1414
+ response.loader = loader;
1415
+ if (errors != null)
1416
+ response.errors = sanitizeMessages(errors, "errors", details, name);
1417
+ if (warnings != null)
1418
+ response.warnings = sanitizeMessages(warnings, "warnings", details, name);
1419
+ if (watchFiles != null)
1420
+ response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles");
1421
+ if (watchDirs != null)
1422
+ response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs");
1423
+ break;
1424
+ }
1425
+ } catch (e) {
1426
+ response = { id: id2, errors: [extractErrorMessageV8(e, streamIn, details, note && note(), name)] };
1427
+ break;
1428
+ }
1429
+ }
1430
+ sendResponse(id, response);
1484
1431
  };
1485
- let analyzeMetafile2 = ({ callName, refs, metafile, options, callback }) => {
1486
- if (options === void 0)
1487
- options = {};
1488
- let keys = {};
1489
- let color = getFlag(options, keys, "color", mustBeBoolean);
1490
- let verbose = getFlag(options, keys, "verbose", mustBeBoolean);
1491
- checkForInvalidFlags(options, keys, `in ${callName}() call`);
1492
- let request = {
1493
- command: "analyze-metafile",
1494
- metafile
1432
+ let runOnEndCallbacks = (result, logPluginError, done) => done();
1433
+ if (onEndCallbacks.length > 0) {
1434
+ runOnEndCallbacks = (result, logPluginError, done) => {
1435
+ (async () => {
1436
+ for (const { name, callback, note } of onEndCallbacks) {
1437
+ try {
1438
+ await callback(result);
1439
+ } catch (e) {
1440
+ result.errors.push(await new Promise((resolve) => logPluginError(e, name, note && note(), resolve)));
1441
+ }
1442
+ }
1443
+ })().then(done);
1495
1444
  };
1496
- if (color !== void 0)
1497
- request.color = color;
1498
- if (verbose !== void 0)
1499
- request.verbose = verbose;
1500
- sendRequest(refs, request, (error, response) => {
1501
- if (error)
1502
- return callback(new Error(error), null);
1503
- callback(null, response.result);
1504
- });
1505
- };
1445
+ }
1446
+ isSetupDone = true;
1506
1447
  return {
1507
- readFromStdout,
1508
- afterClose,
1509
- service: {
1510
- buildOrServe,
1511
- transform: transform2,
1512
- formatMessages: formatMessages2,
1513
- analyzeMetafile: analyzeMetafile2
1514
- }
1448
+ ok: true,
1449
+ requestPlugins,
1450
+ runOnEndCallbacks
1515
1451
  };
1516
- }
1452
+ };
1517
1453
  function createObjectStash() {
1518
1454
  const map = /* @__PURE__ */ new Map();
1519
1455
  let nextID = 0;
@@ -1722,150 +1658,6 @@ var fs = require("fs");
1722
1658
  var os = require("os");
1723
1659
  var path = require("path");
1724
1660
  var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
1725
- var knownWindowsPackages = {
1726
- "win32 arm64 LE": "esbuild-windows-arm64",
1727
- "win32 ia32 LE": "esbuild-windows-32",
1728
- "win32 x64 LE": "esbuild-windows-64"
1729
- };
1730
- var knownUnixlikePackages = {
1731
- "android arm64 LE": "esbuild-android-arm64",
1732
- "darwin arm64 LE": "esbuild-darwin-arm64",
1733
- "darwin x64 LE": "esbuild-darwin-64",
1734
- "freebsd arm64 LE": "esbuild-freebsd-arm64",
1735
- "freebsd x64 LE": "esbuild-freebsd-64",
1736
- "linux arm LE": "esbuild-linux-arm",
1737
- "linux arm64 LE": "esbuild-linux-arm64",
1738
- "linux ia32 LE": "esbuild-linux-32",
1739
- "linux mips64el LE": "esbuild-linux-mips64le",
1740
- "linux ppc64 LE": "esbuild-linux-ppc64le",
1741
- "linux riscv64 LE": "esbuild-linux-riscv64",
1742
- "linux s390x BE": "esbuild-linux-s390x",
1743
- "linux x64 LE": "esbuild-linux-64",
1744
- "linux loong64 LE": "@esbuild/linux-loong64",
1745
- "netbsd x64 LE": "esbuild-netbsd-64",
1746
- "openbsd x64 LE": "esbuild-openbsd-64",
1747
- "sunos x64 LE": "esbuild-sunos-64"
1748
- };
1749
- var knownWebAssemblyFallbackPackages = {
1750
- "android x64 LE": "esbuild-android-64"
1751
- };
1752
- function pkgAndSubpathForCurrentPlatform() {
1753
- let pkg;
1754
- let subpath;
1755
- let isWASM = false;
1756
- let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
1757
- if (platformKey in knownWindowsPackages) {
1758
- pkg = knownWindowsPackages[platformKey];
1759
- subpath = "esbuild.exe";
1760
- } else if (platformKey in knownUnixlikePackages) {
1761
- pkg = knownUnixlikePackages[platformKey];
1762
- subpath = "bin/esbuild";
1763
- } else if (platformKey in knownWebAssemblyFallbackPackages) {
1764
- pkg = knownWebAssemblyFallbackPackages[platformKey];
1765
- subpath = "bin/esbuild";
1766
- isWASM = true;
1767
- } else {
1768
- throw new Error(`Unsupported platform: ${platformKey}`);
1769
- }
1770
- return { pkg, subpath, isWASM };
1771
- }
1772
- function pkgForSomeOtherPlatform() {
1773
- const libMainJS = require.resolve("esbuild");
1774
- const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
1775
- if (path.basename(nodeModulesDirectory) === "node_modules") {
1776
- for (const unixKey in knownUnixlikePackages) {
1777
- try {
1778
- const pkg = knownUnixlikePackages[unixKey];
1779
- if (fs.existsSync(path.join(nodeModulesDirectory, pkg)))
1780
- return pkg;
1781
- } catch {
1782
- }
1783
- }
1784
- for (const windowsKey in knownWindowsPackages) {
1785
- try {
1786
- const pkg = knownWindowsPackages[windowsKey];
1787
- if (fs.existsSync(path.join(nodeModulesDirectory, pkg)))
1788
- return pkg;
1789
- } catch {
1790
- }
1791
- }
1792
- }
1793
- return null;
1794
- }
1795
- function downloadedBinPath(pkg, subpath) {
1796
- const esbuildLibDir = path.dirname(require.resolve("esbuild"));
1797
- return path.join(esbuildLibDir, `downloaded-${pkg}-${path.basename(subpath)}`);
1798
- }
1799
- function generateBinPath() {
1800
- if (ESBUILD_BINARY_PATH) {
1801
- return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
1802
- }
1803
- const { pkg, subpath, isWASM } = pkgAndSubpathForCurrentPlatform();
1804
- let binPath;
1805
- try {
1806
- binPath = require.resolve(`${pkg}/${subpath}`);
1807
- } catch (e) {
1808
- binPath = downloadedBinPath(pkg, subpath);
1809
- if (!fs.existsSync(binPath)) {
1810
- try {
1811
- require.resolve(pkg);
1812
- } catch {
1813
- const otherPkg = pkgForSomeOtherPlatform();
1814
- if (otherPkg) {
1815
- throw new Error(`
1816
- You installed esbuild on another platform than the one you're currently using.
1817
- This won't work because esbuild is written with native code and needs to
1818
- install a platform-specific binary executable.
1819
-
1820
- Specifically the "${otherPkg}" package is present but this platform
1821
- needs the "${pkg}" package instead. People often get into this
1822
- situation by installing esbuild on Windows or macOS and copying "node_modules"
1823
- into a Docker image that runs Linux, or by copying "node_modules" between
1824
- Windows and WSL environments.
1825
-
1826
- If you are installing with npm, you can try not copying the "node_modules"
1827
- directory when you copy the files over, and running "npm ci" or "npm install"
1828
- on the destination platform after the copy. Or you could consider using yarn
1829
- instead which has built-in support for installing a package on multiple
1830
- platforms simultaneously.
1831
-
1832
- If you are installing with yarn, you can try listing both this platform and the
1833
- other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
1834
- feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
1835
- Keep in mind that this means multiple copies of esbuild will be present.
1836
-
1837
- Another alternative is to use the "esbuild-wasm" package instead, which works
1838
- the same way on all platforms. But it comes with a heavy performance cost and
1839
- can sometimes be 10x slower than the "esbuild" package, so you may also not
1840
- want to do that.
1841
- `);
1842
- }
1843
- throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild.
1844
-
1845
- If you are installing esbuild with npm, make sure that you don't specify the
1846
- "--no-optional" flag. The "optionalDependencies" package.json feature is used
1847
- by esbuild to install the correct binary executable for your current platform.`);
1848
- }
1849
- throw e;
1850
- }
1851
- }
1852
- let isYarnPnP = false;
1853
- try {
1854
- require("pnpapi");
1855
- isYarnPnP = true;
1856
- } catch (e) {
1857
- }
1858
- if (isYarnPnP) {
1859
- const esbuildLibDir = path.dirname(require.resolve("esbuild"));
1860
- const binTargetPath = path.join(esbuildLibDir, `pnpapi-${pkg}-${path.basename(subpath)}`);
1861
- if (!fs.existsSync(binTargetPath)) {
1862
- fs.copyFileSync(binPath, binTargetPath);
1863
- fs.chmodSync(binTargetPath, 493);
1864
- }
1865
- return { binPath: binTargetPath, isWASM };
1866
- }
1867
- return { binPath, isWASM };
1868
- }
1869
1661
 
1870
1662
  // lib/npm/node.ts
1871
1663
  var child_process = require("child_process");
@@ -1886,7 +1678,7 @@ if (process.env.ESBUILD_WORKER_THREADS !== "0") {
1886
1678
  }
1887
1679
  }
1888
1680
  var _a;
1889
- var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.15.0";
1681
+ var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.15.8";
1890
1682
  var esbuildCommandAndArgs = () => {
1891
1683
  if ((!ESBUILD_BINARY_PATH || true) && (path2.basename(__filename) !== "main.js" || path2.basename(__dirname) !== "lib")) {
1892
1684
  throw new Error(
@@ -1897,12 +1689,13 @@ More information: The file containing the code for esbuild's JavaScript API (${_
1897
1689
  }
1898
1690
  if (true) {
1899
1691
  return ["node", [path2.join(__dirname, "..", "bin", "esbuild")]];
1900
- }
1901
- const { binPath, isWASM } = generateBinPath();
1902
- if (isWASM) {
1903
- return ["node", [binPath]];
1904
1692
  } else {
1905
- return [binPath, []];
1693
+ const { binPath, isWASM } = generateBinPath();
1694
+ if (isWASM) {
1695
+ return ["node", [binPath]];
1696
+ } else {
1697
+ return [binPath, []];
1698
+ }
1906
1699
  }
1907
1700
  };
1908
1701
  var isTTY = () => tty.isatty(2);
@@ -1952,7 +1745,7 @@ var fsAsync = {
1952
1745
  }
1953
1746
  }
1954
1747
  };
1955
- var version = "0.15.0";
1748
+ var version = "0.15.8";
1956
1749
  var build = (options) => ensureServiceIsRunning().build(options);
1957
1750
  var serve = (serveOptions, buildOptions) => ensureServiceIsRunning().serve(serveOptions, buildOptions);
1958
1751
  var transform = (input, options) => ensureServiceIsRunning().transform(input, options);
@@ -2063,7 +1856,7 @@ var ensureServiceIsRunning = () => {
2063
1856
  if (longLivedService)
2064
1857
  return longLivedService;
2065
1858
  let [command, args] = esbuildCommandAndArgs();
2066
- let child = child_process.spawn(command, args.concat(`--service=${"0.15.0"}`, "--ping"), {
1859
+ let child = child_process.spawn(command, args.concat(`--service=${"0.15.8"}`, "--ping"), {
2067
1860
  windowsHide: true,
2068
1861
  stdio: ["pipe", "pipe", "inherit"],
2069
1862
  cwd: defaultWD
@@ -2177,7 +1970,7 @@ var runServiceSync = (callback) => {
2177
1970
  esbuild: node_exports
2178
1971
  });
2179
1972
  callback(service);
2180
- let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.15.0"}`), {
1973
+ let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.15.8"}`), {
2181
1974
  cwd: defaultWD,
2182
1975
  windowsHide: true,
2183
1976
  input: stdin,
@@ -2193,7 +1986,7 @@ var workerThreadService = null;
2193
1986
  var startWorkerThreadService = (worker_threads2) => {
2194
1987
  let { port1: mainPort, port2: workerPort } = new worker_threads2.MessageChannel();
2195
1988
  let worker = new worker_threads2.Worker(__filename, {
2196
- workerData: { workerPort, defaultWD, esbuildVersion: "0.15.0" },
1989
+ workerData: { workerPort, defaultWD, esbuildVersion: "0.15.8" },
2197
1990
  transferList: [workerPort],
2198
1991
  execArgv: []
2199
1992
  });