patronum/interval/index.js

☄️ Effector utility library delivering modularity and convenience

import { createEvent, createStore, sample, attach, is } from 'effector';
export function interval(_ref) {
  var {
    timeout,
    start,
    stop,
    leading = false,
    trailing = false
  } = _ref;
  var setup = createEvent({
    name: "setup",
    sid: "-ajee8b"
  });
  if (start) {
    sample({
      and: [{
        clock: start,
        target: setup
      }],
      or: {
        sid: "-wq30tc"
      }
    });
  }
  var teardown = createEvent({
    name: "teardown",
    sid: "-on6wf8"
  });
  if (stop) {
    sample({
      and: [{
        clock: stop,
        target: teardown
      }],
      or: {
        sid: "-wloo2g"
      }
    });
  }
  var tick = createEvent({
    name: "tick",
    sid: "37avek"
  });
  var $isRunning = createStore(false, {
    name: "$isRunning",
    sid: "amqfro"
  });
  var $timeout = toStoreNumber(timeout);
  var $notRunning = $isRunning.map(running => !running, {
    skipVoid: false
  });
  var saveTimeout = createEvent({
    name: "saveTimeout",
    sid: "-goth3o"
  });
  var $timeoutId = createStore(null, {
    name: "$timeoutId",
    sid: "xi134t"
  }).on(saveTimeout, (_, _ref2) => {
    var {
      timeoutId
    } = _ref2;
    return timeoutId;
  });
  // eslint-disable-next-line @typescript-eslint/no-empty-function
  var $rejecter = createStore(() => {}, {
    name: "$rejecter",
    sid: "-2am6sk"
  }).on(saveTimeout, (_, _ref3) => {
    var {
      reject
    } = _ref3;
    return reject;
  });
  var timeoutFx = attach({
    and: {
      source: {
        timeout: $timeout,
        running: $isRunning
      },
      effect: _ref4 => {
        var {
          timeout,
          running
        } = _ref4;
        if (!running) {
          return Promise.reject();
        }
        return new Promise((resolve, reject) => {
          var timeoutId = setTimeout(resolve, timeout);
          saveTimeout({
            timeoutId,
            reject
          });
        });
      }
    },
    or: {
      name: "timeoutFx",
      sid: "-hiem3q"
    }
  });
  var cleanupFx = attach({
    and: {
      source: {
        timeoutId: $timeoutId,
        rejecter: $rejecter
      },
      effect: _ref5 => {
        var {
          timeoutId,
          rejecter
        } = _ref5;
        rejecter();
        if (timeoutId) clearTimeout(timeoutId);
      }
    },
    or: {
      name: "cleanupFx",
      sid: "d148gq"
    }
  });
  sample({
    and: [{
      clock: setup,
      source: $timeout,
      filter: $notRunning,
      target: timeoutFx
    }],
    or: {
      sid: "-u9k5bx"
    }
  });
  if (leading) {
    var onReady = sample({
      and: [{
        clock: setup,
        filter: $notRunning
      }],
      or: {
        name: "onReady",
        sid: "5o8c6v"
      }
    });
    sample({
      and: [{
        clock: onReady,
        target: tick
      }],
      or: {
        sid: "6njtce"
      }
    });
  }
  sample({
    and: [{
      clock: setup,
      fn: () => true,
      target: $isRunning
    }],
    or: {
      sid: "6p772r"
    }
  });
  sample({
    and: [{
      clock: timeoutFx.done,
      source: $timeout,
      filter: $isRunning,
      target: timeoutFx
    }],
    or: {
      sid: "741n3i"
    }
  });
  sample({
    and: [{
      clock: timeoutFx.done,
      filter: $isRunning,
      target: tick.prepend(() => {
        /* to be sure, nothing passed to tick */
      })
    }],
    or: {
      sid: "7jfvpm"
    }
  });
  if (trailing) {
    sample({
      and: [{
        clock: teardown,
        target: tick
      }],
      or: {
        sid: "7zxpk6"
      }
    });
  }
  $isRunning.on(teardown, () => false);
  sample({
    and: [{
      clock: teardown,
      target: cleanupFx
    }],
    or: {
      sid: "84c29c"
    }
  });
  return {
    tick,
    isRunning: $isRunning,
    '@@trigger': () => ({
      setup,
      teardown,
      fired: tick
    })
  };
}
function toStoreNumber(value) {
  if (is.store(value, {
    sid: "90rxd3"
  })) return value;
  if (typeof value === 'number') {
    return createStore(value, {
      and: {
        name: '$timeout'
      },
      sid: "-3ibdj9"
    });
  }
  throw new TypeError("timeout parameter in interval method should be number or Store. \"".concat(typeof value, "\" was passed"));
}

/**
 * @see {@link https://withease.pages.dev/protocols/trigger.html}
 */