houdini 1.0.2 → 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.
@@ -18975,109 +18975,6 @@ var require_minimatch = __commonJS({
18975
18975
  }
18976
18976
  });
18977
18977
 
18978
- // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
18979
- var require_cjs = __commonJS({
18980
- "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module2) {
18981
- "use strict";
18982
- var isMergeableObject = function isMergeableObject2(value) {
18983
- return isNonNullObject(value) && !isSpecial(value);
18984
- };
18985
- function isNonNullObject(value) {
18986
- return !!value && typeof value === "object";
18987
- }
18988
- function isSpecial(value) {
18989
- var stringValue = Object.prototype.toString.call(value);
18990
- return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
18991
- }
18992
- var canUseSymbol = typeof Symbol === "function" && Symbol.for;
18993
- var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
18994
- function isReactElement(value) {
18995
- return value.$$typeof === REACT_ELEMENT_TYPE;
18996
- }
18997
- function emptyTarget(val) {
18998
- return Array.isArray(val) ? [] : {};
18999
- }
19000
- function cloneUnlessOtherwiseSpecified(value, options) {
19001
- return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
19002
- }
19003
- function defaultArrayMerge(target, source, options) {
19004
- return target.concat(source).map(function(element) {
19005
- return cloneUnlessOtherwiseSpecified(element, options);
19006
- });
19007
- }
19008
- function getMergeFunction(key, options) {
19009
- if (!options.customMerge) {
19010
- return deepmerge;
19011
- }
19012
- var customMerge = options.customMerge(key);
19013
- return typeof customMerge === "function" ? customMerge : deepmerge;
19014
- }
19015
- function getEnumerableOwnPropertySymbols(target) {
19016
- return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
19017
- return target.propertyIsEnumerable(symbol);
19018
- }) : [];
19019
- }
19020
- function getKeys(target) {
19021
- return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
19022
- }
19023
- function propertyIsOnObject(object, property) {
19024
- try {
19025
- return property in object;
19026
- } catch (_) {
19027
- return false;
19028
- }
19029
- }
19030
- function propertyIsUnsafe(target, key) {
19031
- return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
19032
- }
19033
- function mergeObject(target, source, options) {
19034
- var destination = {};
19035
- if (options.isMergeableObject(target)) {
19036
- getKeys(target).forEach(function(key) {
19037
- destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
19038
- });
19039
- }
19040
- getKeys(source).forEach(function(key) {
19041
- if (propertyIsUnsafe(target, key)) {
19042
- return;
19043
- }
19044
- if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
19045
- destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
19046
- } else {
19047
- destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
19048
- }
19049
- });
19050
- return destination;
19051
- }
19052
- function deepmerge(target, source, options) {
19053
- options = options || {};
19054
- options.arrayMerge = options.arrayMerge || defaultArrayMerge;
19055
- options.isMergeableObject = options.isMergeableObject || isMergeableObject;
19056
- options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
19057
- var sourceIsArray = Array.isArray(source);
19058
- var targetIsArray = Array.isArray(target);
19059
- var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
19060
- if (!sourceAndTargetTypesMatch) {
19061
- return cloneUnlessOtherwiseSpecified(source, options);
19062
- } else if (sourceIsArray) {
19063
- return options.arrayMerge(target, source, options);
19064
- } else {
19065
- return mergeObject(target, source, options);
19066
- }
19067
- }
19068
- deepmerge.all = function deepmergeAll(array, options) {
19069
- if (!Array.isArray(array)) {
19070
- throw new Error("first argument should be an array");
19071
- }
19072
- return array.reduce(function(prev, next) {
19073
- return deepmerge(prev, next, options);
19074
- }, {});
19075
- };
19076
- var deepmerge_1 = deepmerge;
19077
- module2.exports = deepmerge_1;
19078
- }
19079
- });
19080
-
19081
18978
  // ../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js
19082
18979
  var require_universalify = __commonJS({
19083
18980
  "../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js"(exports) {
@@ -54035,6 +53932,109 @@ var require_main2 = __commonJS({
54035
53932
  }
54036
53933
  });
54037
53934
 
53935
+ // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
53936
+ var require_cjs = __commonJS({
53937
+ "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module2) {
53938
+ "use strict";
53939
+ var isMergeableObject = function isMergeableObject2(value) {
53940
+ return isNonNullObject(value) && !isSpecial(value);
53941
+ };
53942
+ function isNonNullObject(value) {
53943
+ return !!value && typeof value === "object";
53944
+ }
53945
+ function isSpecial(value) {
53946
+ var stringValue = Object.prototype.toString.call(value);
53947
+ return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
53948
+ }
53949
+ var canUseSymbol = typeof Symbol === "function" && Symbol.for;
53950
+ var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
53951
+ function isReactElement(value) {
53952
+ return value.$$typeof === REACT_ELEMENT_TYPE;
53953
+ }
53954
+ function emptyTarget(val) {
53955
+ return Array.isArray(val) ? [] : {};
53956
+ }
53957
+ function cloneUnlessOtherwiseSpecified(value, options) {
53958
+ return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
53959
+ }
53960
+ function defaultArrayMerge(target, source, options) {
53961
+ return target.concat(source).map(function(element) {
53962
+ return cloneUnlessOtherwiseSpecified(element, options);
53963
+ });
53964
+ }
53965
+ function getMergeFunction(key, options) {
53966
+ if (!options.customMerge) {
53967
+ return deepmerge;
53968
+ }
53969
+ var customMerge = options.customMerge(key);
53970
+ return typeof customMerge === "function" ? customMerge : deepmerge;
53971
+ }
53972
+ function getEnumerableOwnPropertySymbols(target) {
53973
+ return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
53974
+ return target.propertyIsEnumerable(symbol);
53975
+ }) : [];
53976
+ }
53977
+ function getKeys(target) {
53978
+ return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
53979
+ }
53980
+ function propertyIsOnObject(object, property) {
53981
+ try {
53982
+ return property in object;
53983
+ } catch (_) {
53984
+ return false;
53985
+ }
53986
+ }
53987
+ function propertyIsUnsafe(target, key) {
53988
+ return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
53989
+ }
53990
+ function mergeObject(target, source, options) {
53991
+ var destination = {};
53992
+ if (options.isMergeableObject(target)) {
53993
+ getKeys(target).forEach(function(key) {
53994
+ destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
53995
+ });
53996
+ }
53997
+ getKeys(source).forEach(function(key) {
53998
+ if (propertyIsUnsafe(target, key)) {
53999
+ return;
54000
+ }
54001
+ if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
54002
+ destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
54003
+ } else {
54004
+ destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
54005
+ }
54006
+ });
54007
+ return destination;
54008
+ }
54009
+ function deepmerge(target, source, options) {
54010
+ options = options || {};
54011
+ options.arrayMerge = options.arrayMerge || defaultArrayMerge;
54012
+ options.isMergeableObject = options.isMergeableObject || isMergeableObject;
54013
+ options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
54014
+ var sourceIsArray = Array.isArray(source);
54015
+ var targetIsArray = Array.isArray(target);
54016
+ var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
54017
+ if (!sourceAndTargetTypesMatch) {
54018
+ return cloneUnlessOtherwiseSpecified(source, options);
54019
+ } else if (sourceIsArray) {
54020
+ return options.arrayMerge(target, source, options);
54021
+ } else {
54022
+ return mergeObject(target, source, options);
54023
+ }
54024
+ }
54025
+ deepmerge.all = function deepmergeAll(array, options) {
54026
+ if (!Array.isArray(array)) {
54027
+ throw new Error("first argument should be an array");
54028
+ }
54029
+ return array.reduce(function(prev, next) {
54030
+ return deepmerge(prev, next, options);
54031
+ }, {});
54032
+ };
54033
+ var deepmerge_1 = deepmerge;
54034
+ module2.exports = deepmerge_1;
54035
+ }
54036
+ });
54037
+
54038
54038
  // src/test/index.ts
54039
54039
  var test_exports = {};
54040
54040
  __export(test_exports, {
@@ -54252,9 +54252,6 @@ var houdini_mode = {
54252
54252
  }
54253
54253
  };
54254
54254
 
54255
- // src/lib/deepMerge.ts
54256
- var import_deepmerge = __toESM(require_cjs(), 1);
54257
-
54258
54255
  // src/lib/error.ts
54259
54256
  var HoudiniError = class extends Error {
54260
54257
  filepath = null;
@@ -54274,20 +54271,6 @@ var HoudiniError = class extends Error {
54274
54271
  }
54275
54272
  };
54276
54273
 
54277
- // src/lib/deepMerge.ts
54278
- function deepMerge(filepath, ...targets) {
54279
- try {
54280
- if (targets.length === 1) {
54281
- return targets[0];
54282
- } else if (targets.length === 2) {
54283
- return (0, import_deepmerge.default)(targets[0], targets[1]);
54284
- }
54285
- return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
54286
- } catch (e) {
54287
- throw new HoudiniError({ filepath, message: "could not merge: " + targets });
54288
- }
54289
- }
54290
-
54291
54274
  // src/lib/fs.ts
54292
54275
  var fs_exports = {};
54293
54276
  __export(fs_exports, {
@@ -57273,6 +57256,21 @@ async function cleanupFiles(pathFolder, listOfObj) {
57273
57256
  return allFilesNotInList;
57274
57257
  }
57275
57258
 
57259
+ // src/lib/deepMerge.ts
57260
+ var import_deepmerge = __toESM(require_cjs(), 1);
57261
+ function deepMerge(filepath, ...targets) {
57262
+ try {
57263
+ if (targets.length === 1) {
57264
+ return targets[0];
57265
+ } else if (targets.length === 2) {
57266
+ return (0, import_deepmerge.default)(targets[0], targets[1]);
57267
+ }
57268
+ return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
57269
+ } catch (e) {
57270
+ throw new HoudiniError({ filepath, message: "could not merge: " + targets });
57271
+ }
57272
+ }
57273
+
57276
57274
  // src/codegen/generators/artifacts/index.ts
57277
57275
  var graphql12 = __toESM(require_graphql2(), 1);
57278
57276
  var recast5 = __toESM(require_main2(), 1);
@@ -18980,109 +18980,6 @@ var require_minimatch = __commonJS({
18980
18980
  }
18981
18981
  });
18982
18982
 
18983
- // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
18984
- var require_cjs = __commonJS({
18985
- "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module) {
18986
- "use strict";
18987
- var isMergeableObject = function isMergeableObject2(value) {
18988
- return isNonNullObject(value) && !isSpecial(value);
18989
- };
18990
- function isNonNullObject(value) {
18991
- return !!value && typeof value === "object";
18992
- }
18993
- function isSpecial(value) {
18994
- var stringValue = Object.prototype.toString.call(value);
18995
- return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
18996
- }
18997
- var canUseSymbol = typeof Symbol === "function" && Symbol.for;
18998
- var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
18999
- function isReactElement(value) {
19000
- return value.$$typeof === REACT_ELEMENT_TYPE;
19001
- }
19002
- function emptyTarget(val) {
19003
- return Array.isArray(val) ? [] : {};
19004
- }
19005
- function cloneUnlessOtherwiseSpecified(value, options) {
19006
- return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
19007
- }
19008
- function defaultArrayMerge(target, source, options) {
19009
- return target.concat(source).map(function(element) {
19010
- return cloneUnlessOtherwiseSpecified(element, options);
19011
- });
19012
- }
19013
- function getMergeFunction(key, options) {
19014
- if (!options.customMerge) {
19015
- return deepmerge;
19016
- }
19017
- var customMerge = options.customMerge(key);
19018
- return typeof customMerge === "function" ? customMerge : deepmerge;
19019
- }
19020
- function getEnumerableOwnPropertySymbols(target) {
19021
- return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
19022
- return target.propertyIsEnumerable(symbol);
19023
- }) : [];
19024
- }
19025
- function getKeys(target) {
19026
- return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
19027
- }
19028
- function propertyIsOnObject(object, property) {
19029
- try {
19030
- return property in object;
19031
- } catch (_) {
19032
- return false;
19033
- }
19034
- }
19035
- function propertyIsUnsafe(target, key) {
19036
- return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
19037
- }
19038
- function mergeObject(target, source, options) {
19039
- var destination = {};
19040
- if (options.isMergeableObject(target)) {
19041
- getKeys(target).forEach(function(key) {
19042
- destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
19043
- });
19044
- }
19045
- getKeys(source).forEach(function(key) {
19046
- if (propertyIsUnsafe(target, key)) {
19047
- return;
19048
- }
19049
- if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
19050
- destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
19051
- } else {
19052
- destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
19053
- }
19054
- });
19055
- return destination;
19056
- }
19057
- function deepmerge(target, source, options) {
19058
- options = options || {};
19059
- options.arrayMerge = options.arrayMerge || defaultArrayMerge;
19060
- options.isMergeableObject = options.isMergeableObject || isMergeableObject;
19061
- options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
19062
- var sourceIsArray = Array.isArray(source);
19063
- var targetIsArray = Array.isArray(target);
19064
- var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
19065
- if (!sourceAndTargetTypesMatch) {
19066
- return cloneUnlessOtherwiseSpecified(source, options);
19067
- } else if (sourceIsArray) {
19068
- return options.arrayMerge(target, source, options);
19069
- } else {
19070
- return mergeObject(target, source, options);
19071
- }
19072
- }
19073
- deepmerge.all = function deepmergeAll(array, options) {
19074
- if (!Array.isArray(array)) {
19075
- throw new Error("first argument should be an array");
19076
- }
19077
- return array.reduce(function(prev, next) {
19078
- return deepmerge(prev, next, options);
19079
- }, {});
19080
- };
19081
- var deepmerge_1 = deepmerge;
19082
- module.exports = deepmerge_1;
19083
- }
19084
- });
19085
-
19086
18983
  // ../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js
19087
18984
  var require_universalify = __commonJS({
19088
18985
  "../../node_modules/.pnpm/universalify@2.0.0/node_modules/universalify/index.js"(exports) {
@@ -54040,6 +53937,109 @@ var require_main2 = __commonJS({
54040
53937
  }
54041
53938
  });
54042
53939
 
53940
+ // ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
53941
+ var require_cjs = __commonJS({
53942
+ "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports, module) {
53943
+ "use strict";
53944
+ var isMergeableObject = function isMergeableObject2(value) {
53945
+ return isNonNullObject(value) && !isSpecial(value);
53946
+ };
53947
+ function isNonNullObject(value) {
53948
+ return !!value && typeof value === "object";
53949
+ }
53950
+ function isSpecial(value) {
53951
+ var stringValue = Object.prototype.toString.call(value);
53952
+ return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
53953
+ }
53954
+ var canUseSymbol = typeof Symbol === "function" && Symbol.for;
53955
+ var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
53956
+ function isReactElement(value) {
53957
+ return value.$$typeof === REACT_ELEMENT_TYPE;
53958
+ }
53959
+ function emptyTarget(val) {
53960
+ return Array.isArray(val) ? [] : {};
53961
+ }
53962
+ function cloneUnlessOtherwiseSpecified(value, options) {
53963
+ return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
53964
+ }
53965
+ function defaultArrayMerge(target, source, options) {
53966
+ return target.concat(source).map(function(element) {
53967
+ return cloneUnlessOtherwiseSpecified(element, options);
53968
+ });
53969
+ }
53970
+ function getMergeFunction(key, options) {
53971
+ if (!options.customMerge) {
53972
+ return deepmerge;
53973
+ }
53974
+ var customMerge = options.customMerge(key);
53975
+ return typeof customMerge === "function" ? customMerge : deepmerge;
53976
+ }
53977
+ function getEnumerableOwnPropertySymbols(target) {
53978
+ return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
53979
+ return target.propertyIsEnumerable(symbol);
53980
+ }) : [];
53981
+ }
53982
+ function getKeys(target) {
53983
+ return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
53984
+ }
53985
+ function propertyIsOnObject(object, property) {
53986
+ try {
53987
+ return property in object;
53988
+ } catch (_) {
53989
+ return false;
53990
+ }
53991
+ }
53992
+ function propertyIsUnsafe(target, key) {
53993
+ return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
53994
+ }
53995
+ function mergeObject(target, source, options) {
53996
+ var destination = {};
53997
+ if (options.isMergeableObject(target)) {
53998
+ getKeys(target).forEach(function(key) {
53999
+ destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
54000
+ });
54001
+ }
54002
+ getKeys(source).forEach(function(key) {
54003
+ if (propertyIsUnsafe(target, key)) {
54004
+ return;
54005
+ }
54006
+ if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
54007
+ destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
54008
+ } else {
54009
+ destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
54010
+ }
54011
+ });
54012
+ return destination;
54013
+ }
54014
+ function deepmerge(target, source, options) {
54015
+ options = options || {};
54016
+ options.arrayMerge = options.arrayMerge || defaultArrayMerge;
54017
+ options.isMergeableObject = options.isMergeableObject || isMergeableObject;
54018
+ options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
54019
+ var sourceIsArray = Array.isArray(source);
54020
+ var targetIsArray = Array.isArray(target);
54021
+ var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
54022
+ if (!sourceAndTargetTypesMatch) {
54023
+ return cloneUnlessOtherwiseSpecified(source, options);
54024
+ } else if (sourceIsArray) {
54025
+ return options.arrayMerge(target, source, options);
54026
+ } else {
54027
+ return mergeObject(target, source, options);
54028
+ }
54029
+ }
54030
+ deepmerge.all = function deepmergeAll(array, options) {
54031
+ if (!Array.isArray(array)) {
54032
+ throw new Error("first argument should be an array");
54033
+ }
54034
+ return array.reduce(function(prev, next) {
54035
+ return deepmerge(prev, next, options);
54036
+ }, {});
54037
+ };
54038
+ var deepmerge_1 = deepmerge;
54039
+ module.exports = deepmerge_1;
54040
+ }
54041
+ });
54042
+
54043
54043
  // src/test/index.ts
54044
54044
  var graphql25 = __toESM(require_graphql2(), 1);
54045
54045
  var import_memfs2 = __toESM(require_lib(), 1);
@@ -54248,9 +54248,6 @@ var houdini_mode = {
54248
54248
  }
54249
54249
  };
54250
54250
 
54251
- // src/lib/deepMerge.ts
54252
- var import_deepmerge = __toESM(require_cjs(), 1);
54253
-
54254
54251
  // src/lib/error.ts
54255
54252
  var HoudiniError = class extends Error {
54256
54253
  filepath = null;
@@ -54270,20 +54267,6 @@ var HoudiniError = class extends Error {
54270
54267
  }
54271
54268
  };
54272
54269
 
54273
- // src/lib/deepMerge.ts
54274
- function deepMerge(filepath, ...targets) {
54275
- try {
54276
- if (targets.length === 1) {
54277
- return targets[0];
54278
- } else if (targets.length === 2) {
54279
- return (0, import_deepmerge.default)(targets[0], targets[1]);
54280
- }
54281
- return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
54282
- } catch (e) {
54283
- throw new HoudiniError({ filepath, message: "could not merge: " + targets });
54284
- }
54285
- }
54286
-
54287
54270
  // src/lib/fs.ts
54288
54271
  var fs_exports = {};
54289
54272
  __export(fs_exports, {
@@ -57268,6 +57251,21 @@ async function cleanupFiles(pathFolder, listOfObj) {
57268
57251
  return allFilesNotInList;
57269
57252
  }
57270
57253
 
57254
+ // src/lib/deepMerge.ts
57255
+ var import_deepmerge = __toESM(require_cjs(), 1);
57256
+ function deepMerge(filepath, ...targets) {
57257
+ try {
57258
+ if (targets.length === 1) {
57259
+ return targets[0];
57260
+ } else if (targets.length === 2) {
57261
+ return (0, import_deepmerge.default)(targets[0], targets[1]);
57262
+ }
57263
+ return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
57264
+ } catch (e) {
57265
+ throw new HoudiniError({ filepath, message: "could not merge: " + targets });
57266
+ }
57267
+ }
57268
+
57271
57269
  // src/codegen/generators/artifacts/index.ts
57272
57270
  var graphql12 = __toESM(require_graphql2(), 1);
57273
57271
  var recast5 = __toESM(require_main2(), 1);