houdini 1.0.3 → 1.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -15475,109 +15475,6 @@ var require_minimatch = __commonJS({
15475
15475
  }
15476
15476
  });
15477
15477
 
15478
- // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
15479
- var require_cjs = __commonJS({
15480
- "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module2) {
15481
- "use strict";
15482
- var isMergeableObject = function isMergeableObject2(value) {
15483
- return isNonNullObject(value) && !isSpecial(value);
15484
- };
15485
- function isNonNullObject(value) {
15486
- return !!value && typeof value === "object";
15487
- }
15488
- function isSpecial(value) {
15489
- var stringValue = Object.prototype.toString.call(value);
15490
- return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
15491
- }
15492
- var canUseSymbol = typeof Symbol === "function" && Symbol.for;
15493
- var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
15494
- function isReactElement(value) {
15495
- return value.$$typeof === REACT_ELEMENT_TYPE;
15496
- }
15497
- function emptyTarget(val) {
15498
- return Array.isArray(val) ? [] : {};
15499
- }
15500
- function cloneUnlessOtherwiseSpecified(value, options) {
15501
- return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
15502
- }
15503
- function defaultArrayMerge(target, source, options) {
15504
- return target.concat(source).map(function(element) {
15505
- return cloneUnlessOtherwiseSpecified(element, options);
15506
- });
15507
- }
15508
- function getMergeFunction(key, options) {
15509
- if (!options.customMerge) {
15510
- return deepmerge;
15511
- }
15512
- var customMerge = options.customMerge(key);
15513
- return typeof customMerge === "function" ? customMerge : deepmerge;
15514
- }
15515
- function getEnumerableOwnPropertySymbols(target) {
15516
- return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
15517
- return target.propertyIsEnumerable(symbol);
15518
- }) : [];
15519
- }
15520
- function getKeys(target) {
15521
- return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
15522
- }
15523
- function propertyIsOnObject(object, property) {
15524
- try {
15525
- return property in object;
15526
- } catch (_) {
15527
- return false;
15528
- }
15529
- }
15530
- function propertyIsUnsafe(target, key) {
15531
- return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
15532
- }
15533
- function mergeObject(target, source, options) {
15534
- var destination = {};
15535
- if (options.isMergeableObject(target)) {
15536
- getKeys(target).forEach(function(key) {
15537
- destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
15538
- });
15539
- }
15540
- getKeys(source).forEach(function(key) {
15541
- if (propertyIsUnsafe(target, key)) {
15542
- return;
15543
- }
15544
- if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
15545
- destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
15546
- } else {
15547
- destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
15548
- }
15549
- });
15550
- return destination;
15551
- }
15552
- function deepmerge(target, source, options) {
15553
- options = options || {};
15554
- options.arrayMerge = options.arrayMerge || defaultArrayMerge;
15555
- options.isMergeableObject = options.isMergeableObject || isMergeableObject;
15556
- options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
15557
- var sourceIsArray = Array.isArray(source);
15558
- var targetIsArray = Array.isArray(target);
15559
- var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
15560
- if (!sourceAndTargetTypesMatch) {
15561
- return cloneUnlessOtherwiseSpecified(source, options);
15562
- } else if (sourceIsArray) {
15563
- return options.arrayMerge(target, source, options);
15564
- } else {
15565
- return mergeObject(target, source, options);
15566
- }
15567
- }
15568
- deepmerge.all = function deepmergeAll(array, options) {
15569
- if (!Array.isArray(array)) {
15570
- throw new Error("first argument should be an array");
15571
- }
15572
- return array.reduce(function(prev, next) {
15573
- return deepmerge(prev, next, options);
15574
- }, {});
15575
- };
15576
- var deepmerge_1 = deepmerge;
15577
- module2.exports = deepmerge_1;
15578
- }
15579
- });
15580
-
15581
15478
  // ../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js
15582
15479
  var require_universalify = __commonJS({
15583
15480
  "../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js"(exports) {
@@ -58387,6 +58284,109 @@ var require_main2 = __commonJS({
58387
58284
  }
58388
58285
  });
58389
58286
 
58287
+ // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
58288
+ var require_cjs = __commonJS({
58289
+ "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module2) {
58290
+ "use strict";
58291
+ var isMergeableObject = function isMergeableObject2(value) {
58292
+ return isNonNullObject(value) && !isSpecial(value);
58293
+ };
58294
+ function isNonNullObject(value) {
58295
+ return !!value && typeof value === "object";
58296
+ }
58297
+ function isSpecial(value) {
58298
+ var stringValue = Object.prototype.toString.call(value);
58299
+ return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
58300
+ }
58301
+ var canUseSymbol = typeof Symbol === "function" && Symbol.for;
58302
+ var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
58303
+ function isReactElement(value) {
58304
+ return value.$$typeof === REACT_ELEMENT_TYPE;
58305
+ }
58306
+ function emptyTarget(val) {
58307
+ return Array.isArray(val) ? [] : {};
58308
+ }
58309
+ function cloneUnlessOtherwiseSpecified(value, options) {
58310
+ return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
58311
+ }
58312
+ function defaultArrayMerge(target, source, options) {
58313
+ return target.concat(source).map(function(element) {
58314
+ return cloneUnlessOtherwiseSpecified(element, options);
58315
+ });
58316
+ }
58317
+ function getMergeFunction(key, options) {
58318
+ if (!options.customMerge) {
58319
+ return deepmerge;
58320
+ }
58321
+ var customMerge = options.customMerge(key);
58322
+ return typeof customMerge === "function" ? customMerge : deepmerge;
58323
+ }
58324
+ function getEnumerableOwnPropertySymbols(target) {
58325
+ return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
58326
+ return target.propertyIsEnumerable(symbol);
58327
+ }) : [];
58328
+ }
58329
+ function getKeys(target) {
58330
+ return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
58331
+ }
58332
+ function propertyIsOnObject(object, property) {
58333
+ try {
58334
+ return property in object;
58335
+ } catch (_) {
58336
+ return false;
58337
+ }
58338
+ }
58339
+ function propertyIsUnsafe(target, key) {
58340
+ return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
58341
+ }
58342
+ function mergeObject(target, source, options) {
58343
+ var destination = {};
58344
+ if (options.isMergeableObject(target)) {
58345
+ getKeys(target).forEach(function(key) {
58346
+ destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
58347
+ });
58348
+ }
58349
+ getKeys(source).forEach(function(key) {
58350
+ if (propertyIsUnsafe(target, key)) {
58351
+ return;
58352
+ }
58353
+ if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
58354
+ destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
58355
+ } else {
58356
+ destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
58357
+ }
58358
+ });
58359
+ return destination;
58360
+ }
58361
+ function deepmerge(target, source, options) {
58362
+ options = options || {};
58363
+ options.arrayMerge = options.arrayMerge || defaultArrayMerge;
58364
+ options.isMergeableObject = options.isMergeableObject || isMergeableObject;
58365
+ options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
58366
+ var sourceIsArray = Array.isArray(source);
58367
+ var targetIsArray = Array.isArray(target);
58368
+ var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
58369
+ if (!sourceAndTargetTypesMatch) {
58370
+ return cloneUnlessOtherwiseSpecified(source, options);
58371
+ } else if (sourceIsArray) {
58372
+ return options.arrayMerge(target, source, options);
58373
+ } else {
58374
+ return mergeObject(target, source, options);
58375
+ }
58376
+ }
58377
+ deepmerge.all = function deepmergeAll(array, options) {
58378
+ if (!Array.isArray(array)) {
58379
+ throw new Error("first argument should be an array");
58380
+ }
58381
+ return array.reduce(function(prev, next) {
58382
+ return deepmerge(prev, next, options);
58383
+ }, {});
58384
+ };
58385
+ var deepmerge_1 = deepmerge;
58386
+ module2.exports = deepmerge_1;
58387
+ }
58388
+ });
58389
+
58390
58390
  // src/lib/index.ts
58391
58391
  var lib_exports = {};
58392
58392
  __export(lib_exports, {
@@ -61900,9 +61900,6 @@ var houdini_mode = {
61900
61900
  }
61901
61901
  };
61902
61902
 
61903
- // src/lib/deepMerge.ts
61904
- var import_deepmerge = __toESM(require_cjs(), 1);
61905
-
61906
61903
  // src/lib/error.ts
61907
61904
  var HoudiniError = class extends Error {
61908
61905
  filepath = null;
@@ -61922,20 +61919,6 @@ var HoudiniError = class extends Error {
61922
61919
  }
61923
61920
  };
61924
61921
 
61925
- // src/lib/deepMerge.ts
61926
- function deepMerge(filepath, ...targets) {
61927
- try {
61928
- if (targets.length === 1) {
61929
- return targets[0];
61930
- } else if (targets.length === 2) {
61931
- return (0, import_deepmerge.default)(targets[0], targets[1]);
61932
- }
61933
- return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
61934
- } catch (e2) {
61935
- throw new HoudiniError({ filepath, message: "could not merge: " + targets });
61936
- }
61937
- }
61938
-
61939
61922
  // src/lib/fs.ts
61940
61923
  var fs_exports = {};
61941
61924
  __export(fs_exports, {
@@ -65833,9 +65816,7 @@ var DocumentStore = class extends Writable {
65833
65816
  super(initialState, () => {
65834
65817
  return () => {
65835
65818
  this.#lastVariables = null;
65836
- for (const plugin2 of this.#plugins) {
65837
- plugin2.cleanup?.(this.#lastContext);
65838
- }
65819
+ this.cleanup();
65839
65820
  };
65840
65821
  });
65841
65822
  this.#artifact = artifact;
@@ -65901,6 +65882,11 @@ var DocumentStore = class extends Writable {
65901
65882
  this.#step("forward", state);
65902
65883
  });
65903
65884
  }
65885
+ async cleanup() {
65886
+ for (const plugin2 of this.#plugins) {
65887
+ plugin2.cleanup?.(this.#lastContext);
65888
+ }
65889
+ }
65904
65890
  #step(direction, ctx, value) {
65905
65891
  const hook = direction === "error" ? "catch" : steps[direction][ctx.currentStep];
65906
65892
  let valid = (i2) => i2 <= this.#plugins.length;
@@ -66751,11 +66737,12 @@ async function getConfig({
66751
66737
  for (const plugin2 of plugins2) {
66752
66738
  if (plugin2.config) {
66753
66739
  try {
66754
- const configFactory = await import(plugin2.config);
66755
- const newValue = typeof configFactory === "function" ? configFactory(configFile) : configFactory;
66756
- configFile = deepMerge(configPath, configFile, newValue);
66740
+ const configFactory = (await import(plugin2.config)).default;
66741
+ if (configFactory) {
66742
+ configFile = typeof configFactory === "function" ? configFactory(configFile) : configFactory;
66743
+ }
66757
66744
  } catch {
66758
- console.log("could not load config file" + plugin2.config);
66745
+ console.log("could not load config file " + plugin2.config);
66759
66746
  }
66760
66747
  }
66761
66748
  }
@@ -67163,6 +67150,21 @@ async function cleanupFiles(pathFolder, listOfObj) {
67163
67150
  return allFilesNotInList;
67164
67151
  }
67165
67152
 
67153
+ // src/lib/deepMerge.ts
67154
+ var import_deepmerge = __toESM(require_cjs(), 1);
67155
+ function deepMerge(filepath, ...targets) {
67156
+ try {
67157
+ if (targets.length === 1) {
67158
+ return targets[0];
67159
+ } else if (targets.length === 2) {
67160
+ return (0, import_deepmerge.default)(targets[0], targets[1]);
67161
+ }
67162
+ return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
67163
+ } catch (e2) {
67164
+ throw new HoudiniError({ filepath, message: "could not merge: " + targets });
67165
+ }
67166
+ }
67167
+
67166
67168
  // ../../node_modules/.pnpm/estree-walker@3.0.1/node_modules/estree-walker/src/walker.js
67167
67169
  var WalkerBase = class {
67168
67170
  constructor() {
@@ -15480,109 +15480,6 @@ var require_minimatch = __commonJS({
15480
15480
  }
15481
15481
  });
15482
15482
 
15483
- // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
15484
- var require_cjs = __commonJS({
15485
- "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module) {
15486
- "use strict";
15487
- var isMergeableObject = function isMergeableObject2(value) {
15488
- return isNonNullObject(value) && !isSpecial(value);
15489
- };
15490
- function isNonNullObject(value) {
15491
- return !!value && typeof value === "object";
15492
- }
15493
- function isSpecial(value) {
15494
- var stringValue = Object.prototype.toString.call(value);
15495
- return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
15496
- }
15497
- var canUseSymbol = typeof Symbol === "function" && Symbol.for;
15498
- var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
15499
- function isReactElement(value) {
15500
- return value.$$typeof === REACT_ELEMENT_TYPE;
15501
- }
15502
- function emptyTarget(val) {
15503
- return Array.isArray(val) ? [] : {};
15504
- }
15505
- function cloneUnlessOtherwiseSpecified(value, options) {
15506
- return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
15507
- }
15508
- function defaultArrayMerge(target, source, options) {
15509
- return target.concat(source).map(function(element) {
15510
- return cloneUnlessOtherwiseSpecified(element, options);
15511
- });
15512
- }
15513
- function getMergeFunction(key, options) {
15514
- if (!options.customMerge) {
15515
- return deepmerge;
15516
- }
15517
- var customMerge = options.customMerge(key);
15518
- return typeof customMerge === "function" ? customMerge : deepmerge;
15519
- }
15520
- function getEnumerableOwnPropertySymbols(target) {
15521
- return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
15522
- return target.propertyIsEnumerable(symbol);
15523
- }) : [];
15524
- }
15525
- function getKeys(target) {
15526
- return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
15527
- }
15528
- function propertyIsOnObject(object, property) {
15529
- try {
15530
- return property in object;
15531
- } catch (_) {
15532
- return false;
15533
- }
15534
- }
15535
- function propertyIsUnsafe(target, key) {
15536
- return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
15537
- }
15538
- function mergeObject(target, source, options) {
15539
- var destination = {};
15540
- if (options.isMergeableObject(target)) {
15541
- getKeys(target).forEach(function(key) {
15542
- destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
15543
- });
15544
- }
15545
- getKeys(source).forEach(function(key) {
15546
- if (propertyIsUnsafe(target, key)) {
15547
- return;
15548
- }
15549
- if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
15550
- destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
15551
- } else {
15552
- destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
15553
- }
15554
- });
15555
- return destination;
15556
- }
15557
- function deepmerge(target, source, options) {
15558
- options = options || {};
15559
- options.arrayMerge = options.arrayMerge || defaultArrayMerge;
15560
- options.isMergeableObject = options.isMergeableObject || isMergeableObject;
15561
- options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
15562
- var sourceIsArray = Array.isArray(source);
15563
- var targetIsArray = Array.isArray(target);
15564
- var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
15565
- if (!sourceAndTargetTypesMatch) {
15566
- return cloneUnlessOtherwiseSpecified(source, options);
15567
- } else if (sourceIsArray) {
15568
- return options.arrayMerge(target, source, options);
15569
- } else {
15570
- return mergeObject(target, source, options);
15571
- }
15572
- }
15573
- deepmerge.all = function deepmergeAll(array, options) {
15574
- if (!Array.isArray(array)) {
15575
- throw new Error("first argument should be an array");
15576
- }
15577
- return array.reduce(function(prev, next) {
15578
- return deepmerge(prev, next, options);
15579
- }, {});
15580
- };
15581
- var deepmerge_1 = deepmerge;
15582
- module.exports = deepmerge_1;
15583
- }
15584
- });
15585
-
15586
15483
  // ../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js
15587
15484
  var require_universalify = __commonJS({
15588
15485
  "../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js"(exports) {
@@ -58392,6 +58289,109 @@ var require_main2 = __commonJS({
58392
58289
  }
58393
58290
  });
58394
58291
 
58292
+ // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
58293
+ var require_cjs = __commonJS({
58294
+ "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module) {
58295
+ "use strict";
58296
+ var isMergeableObject = function isMergeableObject2(value) {
58297
+ return isNonNullObject(value) && !isSpecial(value);
58298
+ };
58299
+ function isNonNullObject(value) {
58300
+ return !!value && typeof value === "object";
58301
+ }
58302
+ function isSpecial(value) {
58303
+ var stringValue = Object.prototype.toString.call(value);
58304
+ return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
58305
+ }
58306
+ var canUseSymbol = typeof Symbol === "function" && Symbol.for;
58307
+ var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
58308
+ function isReactElement(value) {
58309
+ return value.$$typeof === REACT_ELEMENT_TYPE;
58310
+ }
58311
+ function emptyTarget(val) {
58312
+ return Array.isArray(val) ? [] : {};
58313
+ }
58314
+ function cloneUnlessOtherwiseSpecified(value, options) {
58315
+ return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
58316
+ }
58317
+ function defaultArrayMerge(target, source, options) {
58318
+ return target.concat(source).map(function(element) {
58319
+ return cloneUnlessOtherwiseSpecified(element, options);
58320
+ });
58321
+ }
58322
+ function getMergeFunction(key, options) {
58323
+ if (!options.customMerge) {
58324
+ return deepmerge;
58325
+ }
58326
+ var customMerge = options.customMerge(key);
58327
+ return typeof customMerge === "function" ? customMerge : deepmerge;
58328
+ }
58329
+ function getEnumerableOwnPropertySymbols(target) {
58330
+ return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
58331
+ return target.propertyIsEnumerable(symbol);
58332
+ }) : [];
58333
+ }
58334
+ function getKeys(target) {
58335
+ return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
58336
+ }
58337
+ function propertyIsOnObject(object, property) {
58338
+ try {
58339
+ return property in object;
58340
+ } catch (_) {
58341
+ return false;
58342
+ }
58343
+ }
58344
+ function propertyIsUnsafe(target, key) {
58345
+ return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
58346
+ }
58347
+ function mergeObject(target, source, options) {
58348
+ var destination = {};
58349
+ if (options.isMergeableObject(target)) {
58350
+ getKeys(target).forEach(function(key) {
58351
+ destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
58352
+ });
58353
+ }
58354
+ getKeys(source).forEach(function(key) {
58355
+ if (propertyIsUnsafe(target, key)) {
58356
+ return;
58357
+ }
58358
+ if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
58359
+ destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
58360
+ } else {
58361
+ destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
58362
+ }
58363
+ });
58364
+ return destination;
58365
+ }
58366
+ function deepmerge(target, source, options) {
58367
+ options = options || {};
58368
+ options.arrayMerge = options.arrayMerge || defaultArrayMerge;
58369
+ options.isMergeableObject = options.isMergeableObject || isMergeableObject;
58370
+ options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
58371
+ var sourceIsArray = Array.isArray(source);
58372
+ var targetIsArray = Array.isArray(target);
58373
+ var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
58374
+ if (!sourceAndTargetTypesMatch) {
58375
+ return cloneUnlessOtherwiseSpecified(source, options);
58376
+ } else if (sourceIsArray) {
58377
+ return options.arrayMerge(target, source, options);
58378
+ } else {
58379
+ return mergeObject(target, source, options);
58380
+ }
58381
+ }
58382
+ deepmerge.all = function deepmergeAll(array, options) {
58383
+ if (!Array.isArray(array)) {
58384
+ throw new Error("first argument should be an array");
58385
+ }
58386
+ return array.reduce(function(prev, next) {
58387
+ return deepmerge(prev, next, options);
58388
+ }, {});
58389
+ };
58390
+ var deepmerge_1 = deepmerge;
58391
+ module.exports = deepmerge_1;
58392
+ }
58393
+ });
58394
+
58395
58395
  // src/lib/pipeline.ts
58396
58396
  async function runPipeline(config, pipeline2, target) {
58397
58397
  for (const transform of pipeline2) {
@@ -61849,9 +61849,6 @@ var houdini_mode = {
61849
61849
  }
61850
61850
  };
61851
61851
 
61852
- // src/lib/deepMerge.ts
61853
- var import_deepmerge = __toESM(require_cjs(), 1);
61854
-
61855
61852
  // src/lib/error.ts
61856
61853
  var HoudiniError = class extends Error {
61857
61854
  filepath = null;
@@ -61871,20 +61868,6 @@ var HoudiniError = class extends Error {
61871
61868
  }
61872
61869
  };
61873
61870
 
61874
- // src/lib/deepMerge.ts
61875
- function deepMerge(filepath, ...targets) {
61876
- try {
61877
- if (targets.length === 1) {
61878
- return targets[0];
61879
- } else if (targets.length === 2) {
61880
- return (0, import_deepmerge.default)(targets[0], targets[1]);
61881
- }
61882
- return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
61883
- } catch (e2) {
61884
- throw new HoudiniError({ filepath, message: "could not merge: " + targets });
61885
- }
61886
- }
61887
-
61888
61871
  // src/lib/fs.ts
61889
61872
  var fs_exports = {};
61890
61873
  __export(fs_exports, {
@@ -65782,9 +65765,7 @@ var DocumentStore = class extends Writable {
65782
65765
  super(initialState, () => {
65783
65766
  return () => {
65784
65767
  this.#lastVariables = null;
65785
- for (const plugin2 of this.#plugins) {
65786
- plugin2.cleanup?.(this.#lastContext);
65787
- }
65768
+ this.cleanup();
65788
65769
  };
65789
65770
  });
65790
65771
  this.#artifact = artifact;
@@ -65850,6 +65831,11 @@ var DocumentStore = class extends Writable {
65850
65831
  this.#step("forward", state);
65851
65832
  });
65852
65833
  }
65834
+ async cleanup() {
65835
+ for (const plugin2 of this.#plugins) {
65836
+ plugin2.cleanup?.(this.#lastContext);
65837
+ }
65838
+ }
65853
65839
  #step(direction, ctx, value) {
65854
65840
  const hook = direction === "error" ? "catch" : steps[direction][ctx.currentStep];
65855
65841
  let valid = (i2) => i2 <= this.#plugins.length;
@@ -66699,11 +66685,12 @@ async function getConfig({
66699
66685
  for (const plugin2 of plugins2) {
66700
66686
  if (plugin2.config) {
66701
66687
  try {
66702
- const configFactory = await import(plugin2.config);
66703
- const newValue = typeof configFactory === "function" ? configFactory(configFile) : configFactory;
66704
- configFile = deepMerge(configPath, configFile, newValue);
66688
+ const configFactory = (await import(plugin2.config)).default;
66689
+ if (configFactory) {
66690
+ configFile = typeof configFactory === "function" ? configFactory(configFile) : configFactory;
66691
+ }
66705
66692
  } catch {
66706
- console.log("could not load config file" + plugin2.config);
66693
+ console.log("could not load config file " + plugin2.config);
66707
66694
  }
66708
66695
  }
66709
66696
  }
@@ -67111,6 +67098,21 @@ async function cleanupFiles(pathFolder, listOfObj) {
67111
67098
  return allFilesNotInList;
67112
67099
  }
67113
67100
 
67101
+ // src/lib/deepMerge.ts
67102
+ var import_deepmerge = __toESM(require_cjs(), 1);
67103
+ function deepMerge(filepath, ...targets) {
67104
+ try {
67105
+ if (targets.length === 1) {
67106
+ return targets[0];
67107
+ } else if (targets.length === 2) {
67108
+ return (0, import_deepmerge.default)(targets[0], targets[1]);
67109
+ }
67110
+ return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
67111
+ } catch (e2) {
67112
+ throw new HoudiniError({ filepath, message: "could not merge: " + targets });
67113
+ }
67114
+ }
67115
+
67114
67116
  // ../../node_modules/.pnpm/estree-walker@3.0.1/node_modules/estree-walker/src/walker.js
67115
67117
  var WalkerBase = class {
67116
67118
  constructor() {
@@ -15,6 +15,7 @@ export declare class DocumentStore<_Data extends GraphQLObject, _Input extends R
15
15
  fetching?: boolean;
16
16
  });
17
17
  send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
18
+ cleanup(): Promise<void>;
18
19
  }
19
20
  declare function marshalVariables<_Data extends GraphQLObject, _Input extends {}>(ctx: ClientPluginContext): Record<string, any>;
20
21
  export type ClientPlugin = () => ClientHooks | null | (ClientHooks | ClientPlugin | null)[];
@@ -15,6 +15,7 @@ export declare class DocumentStore<_Data extends GraphQLObject, _Input extends R
15
15
  fetching?: boolean;
16
16
  });
17
17
  send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
18
+ cleanup(): Promise<void>;
18
19
  }
19
20
  declare function marshalVariables<_Data extends GraphQLObject, _Input extends {}>(ctx: ClientPluginContext): Record<string, any>;
20
21
  export type ClientPlugin = () => ClientHooks | null | (ClientHooks | ClientPlugin | null)[];
@@ -60,9 +60,7 @@ class DocumentStore extends import_store.Writable {
60
60
  super(initialState, () => {
61
61
  return () => {
62
62
  this.#lastVariables = null;
63
- for (const plugin of this.#plugins) {
64
- plugin.cleanup?.(this.#lastContext);
65
- }
63
+ this.cleanup();
66
64
  };
67
65
  });
68
66
  this.#artifact = artifact;
@@ -128,6 +126,11 @@ class DocumentStore extends import_store.Writable {
128
126
  this.#step("forward", state);
129
127
  });
130
128
  }
129
+ async cleanup() {
130
+ for (const plugin of this.#plugins) {
131
+ plugin.cleanup?.(this.#lastContext);
132
+ }
133
+ }
131
134
  #step(direction, ctx, value) {
132
135
  const hook = direction === "error" ? "catch" : steps[direction][ctx.currentStep];
133
136
  let valid = (i) => i <= this.#plugins.length;
@@ -15,6 +15,7 @@ export declare class DocumentStore<_Data extends GraphQLObject, _Input extends R
15
15
  fetching?: boolean;
16
16
  });
17
17
  send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
18
+ cleanup(): Promise<void>;
18
19
  }
19
20
  declare function marshalVariables<_Data extends GraphQLObject, _Input extends {}>(ctx: ClientPluginContext): Record<string, any>;
20
21
  export type ClientPlugin = () => ClientHooks | null | (ClientHooks | ClientPlugin | null)[];