cnhis-design-vue 3.3.1-beta.9 → 3.3.1-release.4

package/es/shared/utils/tapable/HookCodeFactory.js

@@ -1 +1,456 @@
-class t{constructor(t){this.config=t,this.options=void 0,this._args=void 0}create(t){let n;switch(this.init(t),this.options.type){case"sync":n=new Function(this.args(),'"use strict";\n'+this.header()+this.contentWithInterceptors({onError:t=>`throw ${t};\n`,onResult:t=>`return ${t};\n`,resultReturns:!0,onDone:()=>"",rethrowIfPossible:!0}));break;case"async":n=new Function(this.args({after:"_callback"}),'"use strict";\n'+this.header()+this.contentWithInterceptors({onError:t=>`_callback(${t});\n`,onResult:t=>`_callback(null, ${t});\n`,onDone:()=>"_callback();\n"}));break;case"promise":{let t=!1;const e=this.contentWithInterceptors({onError:n=>(t=!0,`_error(${n});\n`),onResult:t=>`_resolve(${t});\n`,onDone:()=>"_resolve();\n"});let r="";r+='"use strict";\n',r+=this.header(),r+="return new Promise((function(_resolve, _reject) {\n",t&&(r+="var _sync = true;\n",r+="function _error(_err) {\n",r+="if(_sync)\n",r+="_resolve(Promise.resolve().then((function() { throw _err; })));\n",r+="else\n",r+="_reject(_err);\n",r+="};\n"),r+=e,t&&(r+="_sync = false;\n"),r+="}));\n",n=new Function(this.args(),r);break}}return this.deinit(),n}setup(t,n){t._x=n.taps.map((t=>t.fn))}init(t){this.options=t,this._args=t.args.slice()}deinit(){this.options=void 0,this._args=void 0}contentWithInterceptors(t){if(this.options.interceptors.length>0){const n=t.onError,e=t.onResult,r=t.onDone;let o="";for(let t=0;t<this.options.interceptors.length;t++){const n=this.options.interceptors[t];n.call&&(o+=`${this.getInterceptor(t)}.call(${this.args({before:n.context?"_context":void 0})});\n`)}return o+=this.content(Object.assign(t,{onError:n&&(t=>{let e="";for(let n=0;n<this.options.interceptors.length;n++){this.options.interceptors[n].error&&(e+=`${this.getInterceptor(n)}.error(${t});\n`)}return e+=n(t),e}),onResult:e&&(t=>{let n="";for(let e=0;e<this.options.interceptors.length;e++){this.options.interceptors[e].result&&(n+=`${this.getInterceptor(e)}.result(${t});\n`)}return n+=e(t),n}),onDone:r&&(()=>{let t="";for(let n=0;n<this.options.interceptors.length;n++){this.options.interceptors[n].done&&(t+=`${this.getInterceptor(n)}.done();\n`)}return t+=r(),t})})),o}return this.content(t)}header(){let t="";return this.needContext()?t+="var _context = {};\n":t+="var _context;\n",t+="var _x = this._x;\n",this.options.interceptors.length>0&&(t+="var _taps = this.taps;\n",t+="var _interceptors = this.interceptors;\n"),t}needContext(){for(const t of this.options.taps)if(t.context)return!0;return!1}callTap(t,{onError:n,onResult:e,onDone:r,rethrowIfPossible:o}){let s="",i=!1;for(let n=0;n<this.options.interceptors.length;n++){const e=this.options.interceptors[n];e.tap&&(i||(s+=`var _tap${t} = ${this.getTap(t)};\n`,i=!0),s+=`${this.getInterceptor(n)}.tap(${e.context?"_context, ":""}_tap${t});\n`)}s+=`var _fn${t} = ${this.getTapFn(t)};\n`;const c=this.options.taps[t];switch(c.type){case"sync":o||(s+=`var _hasError${t} = false;\n`,s+="try {\n"),s+=e?`var _result${t} = _fn${t}(${this.args({before:c.context?"_context":void 0})});\n`:`_fn${t}(${this.args({before:c.context?"_context":void 0})});\n`,o||(s+="} catch(_err) {\n",s+=`_hasError${t} = true;\n`,s+=n("_err"),s+="}\n",s+=`if(!_hasError${t}) {\n`),e&&(s+=e(`_result${t}`)),r&&(s+=r()),o||(s+="}\n");break;case"async":{let o="";o+=e?`(function(_err${t}, _result${t}) {\n`:`(function(_err${t}) {\n`,o+=`if(_err${t}) {\n`,o+=n(`_err${t}`),o+="} else {\n",e&&(o+=e(`_result${t}`)),r&&(o+=r()),o+="}\n",o+="})",s+=`_fn${t}(${this.args({before:c.context?"_context":void 0,after:o})});\n`;break}case"promise":s+=`var _hasResult${t} = false;\n`,s+=`var _promise${t} = _fn${t}(${this.args({before:c.context?"_context":void 0})});\n`,s+=`if (!_promise${t} || !_promise${t}.then)\n`,s+=`  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${t} + ')');\n`,s+=`_promise${t}.then((function(_result${t}) {\n`,s+=`_hasResult${t} = true;\n`,e&&(s+=e(`_result${t}`)),r&&(s+=r()),s+=`}), function(_err${t}) {\n`,s+=`if(_hasResult${t}) throw _err${t};\n`,s+=n(`_err${t}`),s+="});\n"}return s}callTapsSeries({onError:t,onResult:n,resultReturns:e,onDone:r,doneReturns:o,rethrowIfPossible:s}){if(0===this.options.taps.length)return r();const i=this.options.taps.findIndex((t=>"sync"!==t.type)),c=e||o;let l="",a=r,p=0;for(let e=this.options.taps.length-1;e>=0;e--){const o=e;a!==r&&("sync"!==this.options.taps[o].type||p++>20)&&(p=0,l+=`function _next${o}() {\n`,l+=a(),l+="}\n",a=()=>`${c?"return ":""}_next${o}();\n`);const h=a,_=t=>t?"":r(),u=this.callTap(o,{onError:n=>t(o,n,h,_),onResult:n&&(t=>n(o,t,h,_)),onDone:!n&&h,rethrowIfPossible:s&&(i<0||o<i)});a=()=>u}return l+=a(),l}callTapsLooping({onError:t,onDone:n,rethrowIfPossible:e}){if(0===this.options.taps.length)return n();const r=this.options.taps.every((t=>"sync"===t.type));let o="";r||(o+="var _looper = (function() {\n",o+="var _loopAsync = false;\n"),o+="var _loop;\n",o+="do {\n",o+="_loop = false;\n";for(let t=0;t<this.options.interceptors.length;t++){const n=this.options.interceptors[t];n.loop&&(o+=`${this.getInterceptor(t)}.loop(${this.args({before:n.context?"_context":void 0})});\n`)}return o+=this.callTapsSeries({onError:t,onResult:(t,n,e,o)=>{let s="";return s+=`if(${n} !== undefined) {\n`,s+="_loop = true;\n",r||(s+="if(_loopAsync) _looper();\n"),s+=o(!0),s+="} else {\n",s+=e(),s+="}\n",s},onDone:n&&(()=>{let t="";return t+="if(!_loop) {\n",t+=n(),t+="}\n",t}),rethrowIfPossible:e&&r}),o+="} while(_loop);\n",r||(o+="_loopAsync = true;\n",o+="});\n",o+="_looper();\n"),o}callTapsParallel({onError:t,onResult:n,onDone:e,rethrowIfPossible:r,onTap:o=((t,n)=>n())}){if(this.options.taps.length<=1)return this.callTapsSeries({onError:t,onResult:n,onDone:e,rethrowIfPossible:r});let s="";s+="do {\n",s+=`var _counter = ${this.options.taps.length};\n`,e&&(s+="var _done = (function() {\n",s+=e(),s+="});\n");for(let i=0;i<this.options.taps.length;i++){const c=()=>e?"if(--_counter === 0) _done();\n":"--_counter;",l=t=>t||!e?"_counter = 0;\n":"_counter = 0;\n_done();\n";s+="if(_counter <= 0) break;\n",s+=o(i,(()=>this.callTap(i,{onError:n=>{let e="";return e+="if(_counter > 0) {\n",e+=t(i,n,c,l),e+="}\n",e},onResult:n&&(t=>{let e="";return e+="if(_counter > 0) {\n",e+=n(i,t,c,l),e+="}\n",e}),onDone:!n&&(()=>c()),rethrowIfPossible:r})),c,l)}return s+="} while(false);\n",s}args({before:t,after:n}={}){let e=this._args;return t&&(e=[t].concat(e)),n&&(e=e.concat(n)),0===e.length?"":e.join(", ")}getTapFn(t){return`_x[${t}]`}getTap(t){return`_taps[${t}]`}getInterceptor(t){return`_interceptors[${t}]`}}export{t as default};
+class HookCodeFactory {
+  constructor(config) {
+    this.config = config;
+    this.options = void 0;
+    this._args = void 0;
+  }
+  create(options) {
+    this.init(options);
+    let fn;
+    switch (this.options.type) {
+      case "sync":
+        fn = new Function(
+          this.args(),
+          '"use strict";\n' + this.header() + this.contentWithInterceptors({
+            onError: (err) => `throw ${err};
+`,
+            onResult: (result) => `return ${result};
+`,
+            resultReturns: true,
+            onDone: () => "",
+            rethrowIfPossible: true
+          })
+        );
+        break;
+      case "async":
+        fn = new Function(
+          this.args({
+            after: "_callback"
+          }),
+          '"use strict";\n' + this.header() + this.contentWithInterceptors({
+            onError: (err) => `_callback(${err});
+`,
+            onResult: (result) => `_callback(null, ${result});
+`,
+            onDone: () => "_callback();\n"
+          })
+        );
+        break;
+      case "promise": {
+        let errorHelperUsed = false;
+        const content = this.contentWithInterceptors({
+          onError: (err) => {
+            errorHelperUsed = true;
+            return `_error(${err});
+`;
+          },
+          onResult: (result) => `_resolve(${result});
+`,
+          onDone: () => "_resolve();\n"
+        });
+        let code = "";
+        code += '"use strict";\n';
+        code += this.header();
+        code += "return new Promise((function(_resolve, _reject) {\n";
+        if (errorHelperUsed) {
+          code += "var _sync = true;\n";
+          code += "function _error(_err) {\n";
+          code += "if(_sync)\n";
+          code += "_resolve(Promise.resolve().then((function() { throw _err; })));\n";
+          code += "else\n";
+          code += "_reject(_err);\n";
+          code += "};\n";
+        }
+        code += content;
+        if (errorHelperUsed) {
+          code += "_sync = false;\n";
+        }
+        code += "}));\n";
+        fn = new Function(this.args(), code);
+        break;
+      }
+    }
+    this.deinit();
+    return fn;
+  }
+  setup(instance, options) {
+    instance._x = options.taps.map((t) => t.fn);
+  }
+  init(options) {
+    this.options = options;
+    this._args = options.args.slice();
+  }
+  deinit() {
+    this.options = void 0;
+    this._args = void 0;
+  }
+  contentWithInterceptors(options) {
+    if (this.options.interceptors.length > 0) {
+      const onError = options.onError;
+      const onResult = options.onResult;
+      const onDone = options.onDone;
+      let code = "";
+      for (let i = 0; i < this.options.interceptors.length; i++) {
+        const interceptor = this.options.interceptors[i];
+        if (interceptor.call) {
+          code += `${this.getInterceptor(i)}.call(${this.args({
+            before: interceptor.context ? "_context" : void 0
+          })});
+`;
+        }
+      }
+      code += this.content(
+        Object.assign(options, {
+          onError: onError && ((err) => {
+            let code2 = "";
+            for (let i = 0; i < this.options.interceptors.length; i++) {
+              const interceptor = this.options.interceptors[i];
+              if (interceptor.error) {
+                code2 += `${this.getInterceptor(i)}.error(${err});
+`;
+              }
+            }
+            code2 += onError(err);
+            return code2;
+          }),
+          onResult: onResult && ((result) => {
+            let code2 = "";
+            for (let i = 0; i < this.options.interceptors.length; i++) {
+              const interceptor = this.options.interceptors[i];
+              if (interceptor.result) {
+                code2 += `${this.getInterceptor(i)}.result(${result});
+`;
+              }
+            }
+            code2 += onResult(result);
+            return code2;
+          }),
+          onDone: onDone && (() => {
+            let code2 = "";
+            for (let i = 0; i < this.options.interceptors.length; i++) {
+              const interceptor = this.options.interceptors[i];
+              if (interceptor.done) {
+                code2 += `${this.getInterceptor(i)}.done();
+`;
+              }
+            }
+            code2 += onDone();
+            return code2;
+          })
+        })
+      );
+      return code;
+    } else {
+      return this.content(options);
+    }
+  }
+  header() {
+    let code = "";
+    if (this.needContext()) {
+      code += "var _context = {};\n";
+    } else {
+      code += "var _context;\n";
+    }
+    code += "var _x = this._x;\n";
+    if (this.options.interceptors.length > 0) {
+      code += "var _taps = this.taps;\n";
+      code += "var _interceptors = this.interceptors;\n";
+    }
+    return code;
+  }
+  needContext() {
+    for (const tap of this.options.taps)
+      if (tap.context)
+        return true;
+    return false;
+  }
+  callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
+    let code = "";
+    let hasTapCached = false;
+    for (let i = 0; i < this.options.interceptors.length; i++) {
+      const interceptor = this.options.interceptors[i];
+      if (interceptor.tap) {
+        if (!hasTapCached) {
+          code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};
+`;
+          hasTapCached = true;
+        }
+        code += `${this.getInterceptor(i)}.tap(${interceptor.context ? "_context, " : ""}_tap${tapIndex});
+`;
+      }
+    }
+    code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};
+`;
+    const tap = this.options.taps[tapIndex];
+    switch (tap.type) {
+      case "sync":
+        if (!rethrowIfPossible) {
+          code += `var _hasError${tapIndex} = false;
+`;
+          code += "try {\n";
+        }
+        if (onResult) {
+          code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
+            before: tap.context ? "_context" : void 0
+          })});
+`;
+        } else {
+          code += `_fn${tapIndex}(${this.args({
+            before: tap.context ? "_context" : void 0
+          })});
+`;
+        }
+        if (!rethrowIfPossible) {
+          code += "} catch(_err) {\n";
+          code += `_hasError${tapIndex} = true;
+`;
+          code += onError("_err");
+          code += "}\n";
+          code += `if(!_hasError${tapIndex}) {
+`;
+        }
+        if (onResult) {
+          code += onResult(`_result${tapIndex}`);
+        }
+        if (onDone) {
+          code += onDone();
+        }
+        if (!rethrowIfPossible) {
+          code += "}\n";
+        }
+        break;
+      case "async": {
+        let cbCode = "";
+        if (onResult)
+          cbCode += `(function(_err${tapIndex}, _result${tapIndex}) {
+`;
+        else
+          cbCode += `(function(_err${tapIndex}) {
+`;
+        cbCode += `if(_err${tapIndex}) {
+`;
+        cbCode += onError(`_err${tapIndex}`);
+        cbCode += "} else {\n";
+        if (onResult) {
+          cbCode += onResult(`_result${tapIndex}`);
+        }
+        if (onDone) {
+          cbCode += onDone();
+        }
+        cbCode += "}\n";
+        cbCode += "})";
+        code += `_fn${tapIndex}(${this.args({
+          before: tap.context ? "_context" : void 0,
+          after: cbCode
+        })});
+`;
+        break;
+      }
+      case "promise":
+        code += `var _hasResult${tapIndex} = false;
+`;
+        code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
+          before: tap.context ? "_context" : void 0
+        })});
+`;
+        code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)
+`;
+        code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');
+`;
+        code += `_promise${tapIndex}.then((function(_result${tapIndex}) {
+`;
+        code += `_hasResult${tapIndex} = true;
+`;
+        if (onResult) {
+          code += onResult(`_result${tapIndex}`);
+        }
+        if (onDone) {
+          code += onDone();
+        }
+        code += `}), function(_err${tapIndex}) {
+`;
+        code += `if(_hasResult${tapIndex}) throw _err${tapIndex};
+`;
+        code += onError(`_err${tapIndex}`);
+        code += "});\n";
+        break;
+    }
+    return code;
+  }
+  callTapsSeries({ onError, onResult, resultReturns, onDone, doneReturns, rethrowIfPossible }) {
+    if (this.options.taps.length === 0)
+      return onDone();
+    const firstAsync = this.options.taps.findIndex((t) => t.type !== "sync");
+    const somethingReturns = resultReturns || doneReturns;
+    let code = "";
+    let current = onDone;
+    let unrollCounter = 0;
+    for (let j = this.options.taps.length - 1; j >= 0; j--) {
+      const i = j;
+      const unroll = current !== onDone && (this.options.taps[i].type !== "sync" || unrollCounter++ > 20);
+      if (unroll) {
+        unrollCounter = 0;
+        code += `function _next${i}() {
+`;
+        code += current();
+        code += "}\n";
+        current = () => `${somethingReturns ? "return " : ""}_next${i}();
+`;
+      }
+      const done = current;
+      const doneBreak = (skipDone) => {
+        if (skipDone)
+          return "";
+        return onDone();
+      };
+      const content = this.callTap(i, {
+        onError: (error) => onError(i, error, done, doneBreak),
+        onResult: onResult && ((result) => {
+          return onResult(i, result, done, doneBreak);
+        }),
+        onDone: !onResult && done,
+        rethrowIfPossible: rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
+      });
+      current = () => content;
+    }
+    code += current();
+    return code;
+  }
+  callTapsLooping({ onError, onDone, rethrowIfPossible }) {
+    if (this.options.taps.length === 0)
+      return onDone();
+    const syncOnly = this.options.taps.every((t) => t.type === "sync");
+    let code = "";
+    if (!syncOnly) {
+      code += "var _looper = (function() {\n";
+      code += "var _loopAsync = false;\n";
+    }
+    code += "var _loop;\n";
+    code += "do {\n";
+    code += "_loop = false;\n";
+    for (let i = 0; i < this.options.interceptors.length; i++) {
+      const interceptor = this.options.interceptors[i];
+      if (interceptor.loop) {
+        code += `${this.getInterceptor(i)}.loop(${this.args({
+          before: interceptor.context ? "_context" : void 0
+        })});
+`;
+      }
+    }
+    code += this.callTapsSeries({
+      onError,
+      onResult: (i, result, next, doneBreak) => {
+        let code2 = "";
+        code2 += `if(${result} !== undefined) {
+`;
+        code2 += "_loop = true;\n";
+        if (!syncOnly)
+          code2 += "if(_loopAsync) _looper();\n";
+        code2 += doneBreak(true);
+        code2 += "} else {\n";
+        code2 += next();
+        code2 += "}\n";
+        return code2;
+      },
+      onDone: onDone && (() => {
+        let code2 = "";
+        code2 += "if(!_loop) {\n";
+        code2 += onDone();
+        code2 += "}\n";
+        return code2;
+      }),
+      rethrowIfPossible: rethrowIfPossible && syncOnly
+    });
+    code += "} while(_loop);\n";
+    if (!syncOnly) {
+      code += "_loopAsync = true;\n";
+      code += "});\n";
+      code += "_looper();\n";
+    }
+    return code;
+  }
+  callTapsParallel({ onError, onResult, onDone, rethrowIfPossible, onTap = (i, run) => run() }) {
+    if (this.options.taps.length <= 1) {
+      return this.callTapsSeries({
+        onError,
+        onResult,
+        onDone,
+        rethrowIfPossible
+      });
+    }
+    let code = "";
+    code += "do {\n";
+    code += `var _counter = ${this.options.taps.length};
+`;
+    if (onDone) {
+      code += "var _done = (function() {\n";
+      code += onDone();
+      code += "});\n";
+    }
+    for (let i = 0; i < this.options.taps.length; i++) {
+      const done = () => {
+        if (onDone)
+          return "if(--_counter === 0) _done();\n";
+        else
+          return "--_counter;";
+      };
+      const doneBreak = (skipDone) => {
+        if (skipDone || !onDone)
+          return "_counter = 0;\n";
+        else
+          return "_counter = 0;\n_done();\n";
+      };
+      code += "if(_counter <= 0) break;\n";
+      code += onTap(
+        i,
+        () => this.callTap(i, {
+          onError: (error) => {
+            let code2 = "";
+            code2 += "if(_counter > 0) {\n";
+            code2 += onError(i, error, done, doneBreak);
+            code2 += "}\n";
+            return code2;
+          },
+          onResult: onResult && ((result) => {
+            let code2 = "";
+            code2 += "if(_counter > 0) {\n";
+            code2 += onResult(i, result, done, doneBreak);
+            code2 += "}\n";
+            return code2;
+          }),
+          onDone: !onResult && (() => {
+            return done();
+          }),
+          rethrowIfPossible
+        }),
+        done,
+        doneBreak
+      );
+    }
+    code += "} while(false);\n";
+    return code;
+  }
+  args({ before, after } = {}) {
+    let allArgs = this._args;
+    if (before)
+      allArgs = [before].concat(allArgs);
+    if (after)
+      allArgs = allArgs.concat(after);
+    if (allArgs.length === 0) {
+      return "";
+    } else {
+      return allArgs.join(", ");
+    }
+  }
+  getTapFn(idx) {
+    return `_x[${idx}]`;
+  }
+  getTap(idx) {
+    return `_taps[${idx}]`;
+  }
+  getInterceptor(idx) {
+    return `_interceptors[${idx}]`;
+  }
+}
+
+export { HookCodeFactory as default };

package/es/shared/utils/tapable/SyncBailHook.js

@@ -1 +1,19 @@
-import"./Hook.js";import e from"./HookCodeFactory.js";new class extends e{content({onError:e,onResult:o,resultReturns:n,onDone:r,rethrowIfPossible:s}){return this.callTapsSeries({onError:(o,n)=>e(n),onResult:(e,n,r)=>`if(${n} !== undefined) {\n${o(n)};\n} else {\n${r()}}\n`,resultReturns:n,onDone:r,rethrowIfPossible:s})}};
+import './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class SyncBailHookCodeFactory extends HookCodeFactory {
+  content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
+    return this.callTapsSeries({
+      onError: (i, err) => onError(err),
+      onResult: (i, result, next) => `if(${result} !== undefined) {
+${onResult(result)};
+} else {
+${next()}}
+`,
+      resultReturns,
+      onDone,
+      rethrowIfPossible
+    });
+  }
+}
+new SyncBailHookCodeFactory();

package/es/shared/utils/tapable/SyncHook.js

@@ -1 +1,34 @@
-import o from"./Hook.js";import r from"./HookCodeFactory.js";const t=new class extends r{content({onError:o,onDone:r,rethrowIfPossible:t}){return this.callTapsSeries({onError:(r,t)=>o(t),onDone:r,rethrowIfPossible:t})}},n=()=>{throw new Error("tapAsync is not supported on a SyncHook")},e=()=>{throw new Error("tapPromise is not supported on a SyncHook")},s=function(o){return t.setup(this,o),t.create(o)};function c(r=[],t){const p=new o(r,t);return p.constructor=c,p.tapAsync=n,p.tapPromise=e,p.compile=s,p}c.prototype=null;export{c as default};
+import Hook from './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class SyncHookCodeFactory extends HookCodeFactory {
+  content({ onError, onDone, rethrowIfPossible }) {
+    return this.callTapsSeries({
+      onError: (i, err) => onError(err),
+      onDone,
+      rethrowIfPossible
+    });
+  }
+}
+const factory = new SyncHookCodeFactory();
+const TAP_ASYNC = () => {
+  throw new Error("tapAsync is not supported on a SyncHook");
+};
+const TAP_PROMISE = () => {
+  throw new Error("tapPromise is not supported on a SyncHook");
+};
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function SyncHook(args = [], name = void 0) {
+  const hook = new Hook(args, name);
+  hook.constructor = SyncHook;
+  hook.tapAsync = TAP_ASYNC;
+  hook.tapPromise = TAP_PROMISE;
+  hook.compile = COMPILE;
+  return hook;
+}
+SyncHook.prototype = null;
+
+export { SyncHook as default };

package/es/shared/utils/tapable/SyncLoopHook.js

@@ -1 +1,13 @@
-import"./Hook.js";import o from"./HookCodeFactory.js";new class extends o{content({onError:o,onDone:r,rethrowIfPossible:e}){return this.callTapsLooping({onError:(r,e)=>o(e),onDone:r,rethrowIfPossible:e})}};
+import './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class SyncLoopHookCodeFactory extends HookCodeFactory {
+  content({ onError, onDone, rethrowIfPossible }) {
+    return this.callTapsLooping({
+      onError: (i, err) => onError(err),
+      onDone,
+      rethrowIfPossible
+    });
+  }
+}
+new SyncLoopHookCodeFactory();

package/es/shared/utils/tapable/SyncWaterfallHook.js

@@ -1 +1,47 @@
-import o from"./Hook.js";import r from"./HookCodeFactory.js";const t=new class extends r{content({onError:o,onResult:r,resultReturns:t,rethrowIfPossible:e}){return this.callTapsSeries({onError:(r,t)=>o(t),onResult:(o,r,t)=>{let e="";return e+=`if(${r} !== undefined) {\n`,e+=`${this._args[0]} = ${r};\n`,e+="}\n",e+=t(),e},onDone:()=>r(this._args[0]),doneReturns:t,rethrowIfPossible:e})}},e=()=>{throw new Error("tapAsync is not supported on a SyncWaterfallHook")},n=()=>{throw new Error("tapPromise is not supported on a SyncWaterfallHook")},s=function(o){return t.setup(this,o),t.create(o)};function a(r=[],t){if(r.length<1)throw new Error("Waterfall hooks must have at least one argument");const l=new o(r,t);return l.constructor=a,l.tapAsync=e,l.tapPromise=n,l.compile=s,l}a.prototype=null;export{a as default};
+import Hook from './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class SyncWaterfallHookCodeFactory extends HookCodeFactory {
+  content({ onError, onResult, resultReturns, rethrowIfPossible }) {
+    return this.callTapsSeries({
+      onError: (i, err) => onError(err),
+      onResult: (i, result, next) => {
+        let code = "";
+        code += `if(${result} !== undefined) {
+`;
+        code += `${this._args[0]} = ${result};
+`;
+        code += "}\n";
+        code += next();
+        return code;
+      },
+      onDone: () => onResult(this._args[0]),
+      doneReturns: resultReturns,
+      rethrowIfPossible
+    });
+  }
+}
+const factory = new SyncWaterfallHookCodeFactory();
+const TAP_ASYNC = () => {
+  throw new Error("tapAsync is not supported on a SyncWaterfallHook");
+};
+const TAP_PROMISE = () => {
+  throw new Error("tapPromise is not supported on a SyncWaterfallHook");
+};
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function SyncWaterfallHook(args = [], name = void 0) {
+  if (args.length < 1)
+    throw new Error("Waterfall hooks must have at least one argument");
+  const hook = new Hook(args, name);
+  hook.constructor = SyncWaterfallHook;
+  hook.tapAsync = TAP_ASYNC;
+  hook.tapPromise = TAP_PROMISE;
+  hook.compile = COMPILE;
+  return hook;
+}
+SyncWaterfallHook.prototype = null;
+
+export { SyncWaterfallHook as default };