eslint-svelte3-preprocess/dist-node/index.js

svelte preprocess for eslint-plugin-svelte3

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var debug = _interopDefault(require('debug'));
var tty = _interopDefault(require('tty'));
var worker_threads = require('worker_threads');
var module$1 = require('module');
var esTree = _interopDefault(require('@typescript-eslint/typescript-estree'));
var svelteCompiler = _interopDefault(require('svelte/compiler'));

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

const preprocess = async (src, filename, preprocessors) => {
  let markup;
  let module;
  let instance;
  let style;
  const result = await svelteCompiler.preprocess(src, [{
    markup: ({
      content
    }) => {
      markup = {
        original: content
      };
      return {
        code: content
      };
    },
    script: ({
      content,
      attributes
    }) => {
      // Supported scenarios
      // type="text/typescript"
      // lang="typescript"
      // lang="ts"
      if (attributes.lang === "ts" || attributes.lang === "typescript" || attributes.type === "text/typescript") {
        const ast = esTree.parse(content, {
          loc: true
        });
        const obj = {
          ast,
          original: content,
          ext: "ts"
        };

        if (attributes.context) {
          module = obj;
        } else {
          instance = obj;
        }
      }

      return {
        code: content
      };
    },
    style: ({
      content
    }) => {
      style = {
        original: content
      };
      return {
        code: content
      };
    }
  }, ...(Array.isArray(preprocessors) ? preprocessors : [preprocessors]), {
    markup: ({
      content
    }) => {
      if (markup) {
        markup.result = content;
        markup.diff = markup.original.length - content.length;
      }

      return {
        code: content
      };
    },
    script: ({
      content,
      attributes
    }) => {
      const obj = attributes.context ? module : instance;

      if (obj) {
        obj.result = content;
        obj.diff = obj.original.length - content.length;
      }

      return {
        code: content
      };
    },
    style: ({
      content
    }) => {
      if (style) {
        style.result = content;
        style.diff = style.original.length - content.length;
      }

      return {
        code: content
      };
    }
  }], {
    filename: filename || "unknown"
  });
  return _objectSpread2(_objectSpread2({}, result), {}, {
    instance,
    markup,
    module,
    style
  });
};

const loadFile = module$1.createRequire(__dirname);
const debugWorker = debug("eslint:svelte-preprocess:worker");

if (!worker_threads.isMainThread) {
  worker_threads.parentPort === null || worker_threads.parentPort === void 0 ? void 0 : worker_threads.parentPort.on("message", async ({
    src,
    filename
  }) => {
    const {
      isDoneView,
      dataView,
      dataLengthView,
      svelteConfigPath
    } = worker_threads.workerData;
    const svelteConfig = loadFile(svelteConfigPath);
    debugWorker(`Preprocessing ${filename}`);
    let result = null;

    try {
      result = await preprocess(src, filename, svelteConfig.preprocess);
      debugWorker(`Preprocessed ${filename}`);
    } catch (error) {
      debugWorker("Failed to preprocess:", error);
    }

    const textEncoder = new TextEncoder();
    const encodedResult = textEncoder.encode(result ? JSON.stringify(result) : ''); // prettier-ignore

    dataView.set(encodedResult, 0);
    dataLengthView[0] = encodedResult.length;
    Atomics.store(isDoneView, 0, 1);
    Atomics.notify(isDoneView, 0, Infinity);
  });
}

const path = __filename;
var workerFile = {
  path
};

const debugMain = debug("eslint:svelte-preprocess:main");

function eslintSveltePreprocess(svelteConfigPath) {
  if (tty.isatty(process.stderr.fd)) {
    process.env.DEBUG_COLORS = "true";
  }

  const isRunningWithinCli = !process.argv.includes("--node-ipc");
  const isDoneBuffer = new SharedArrayBuffer(4);
  const isDoneView = new Int32Array(isDoneBuffer);
  const dataBuffer = new SharedArrayBuffer(50 * 1024 * 1024);
  const dataView = new Uint8Array(dataBuffer);
  const dataLengthBuffer = new SharedArrayBuffer(4);
  const dataLengthView = new Uint32Array(dataLengthBuffer);
  const worker = new worker_threads.Worker(workerFile.path, {
    env: worker_threads.SHARE_ENV,
    workerData: {
      isDoneView,
      dataView,
      dataLengthView,
      svelteConfigPath
    }
  });
  let lastResult;
  return (src, filename) => {
    debugMain(`Asking worker to preprocess ${filename}`);

    try {
      worker.postMessage({
        src,
        filename
      });
      debugMain("Locking thread to wait for worker");
      const waitResult = Atomics.wait(isDoneView, 0, 0, 5000);
      Atomics.store(isDoneView, 0, 0);
      debugMain(`Unlocked: ${waitResult}`);
    } catch (error) {
      debugMain(`error: ${error}`);
    }

    try {
      const textDecoder = new TextDecoder();
      const decoded = textDecoder.decode(dataView.subarray(0, dataLengthView[0]));
      const result = JSON.parse(decoded);
      debugMain("Finished");
      lastResult = result;
      return result;
    } catch (_unused) {
      debugMain("No result obtained; finished with last result");
      return lastResult;
    } finally {
      if (isRunningWithinCli) {
        setTimeout(async () => {
          debugMain("Terminating worker");
          await worker.terminate();
        });
      }
    }
  };
}

module.exports = eslintSveltePreprocess;
var index = module.exports;

exports.default = index;
//# sourceMappingURL=index.js.map