Merge pull request #13 from sandstreamdev/enable_typescript

Enable TypeScript

Author: przemyslawzalewski

.eslintignore

@@ -0,0 +1,2 @@
+index.cjs.js
+index.umd.js

.eslintrc.js

@@ -0,0 +1,52 @@
+module.exports = {
+  env: {
+    es6: true
+  },
+  extends: ["eslint:recommended"],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: "module"
+  },
+  plugins: ["@typescript-eslint", "import"],
+  rules: {
+    "arrow-parens": ["error", "as-needed"],
+    "no-sparse-arrays": 0,
+    "padding-line-between-statements": [
+      "error",
+      { blankLine: "always", prev: "*", next: "export" },
+      {
+        blankLine: "always",
+        prev: ["const", "let", "var"],
+        next: "block-like"
+      },
+      {
+        blankLine: "always",
+        next: ["const", "let", "var", "multiline-expression", "expression"],
+        prev: "import"
+      },
+      { blankLine: "always", prev: "block-like", next: "*" },
+      { blankLine: "always", prev: "import", next: "export" },
+      {
+        blankLine: "always",
+        prev: "export",
+        next: ["const", "let", "var", "multiline-expression", "expression"]
+      },
+      {
+        blankLine: "always",
+        next: ["multiline-const", "multiline-let", "multiline-var"],
+        prev: "*"
+      },
+      {
+        blankLine: "always",
+        prev: "*",
+        next: "return"
+      },
+      {
+        blankLine: "always",
+        prev: ["multiline-const", "multiline-let", "multiline-var"],
+        next: "*"
+      }
+    ]
+  }
+};

.gitignore

@@ -62,3 +62,4 @@ typings/
 
 index.cjs.js
 index.umd.js
+**/*.d.ts

addExtensions.js

@@ -0,0 +1,82 @@
+/* eslint-env node */
+// eslint-disable console
+import { promises } from "fs";
+import path from "path";
+import os from "os";
+import pQueue from "p-queue";
+
+const CONCURRENCY = Math.max(1, os.cpus().length - 1);
+
+const { default: PQueue } = pQueue;
+
+import ignored from "./ignore.js";
+
+const [sourceIgnoredFiles, ignoredDirectories] = ignored;
+
+const ignoredFiles = sourceIgnoredFiles.filter(x => x !== "index.js");
+
+const {
+  readdir: readDirectoryAsync,
+  readFile: readFileAsync,
+  writeFile: writeFileAsync
+} = promises;
+
+const [, , cwd = process.cwd()] = process.argv;
+const root = cwd;
+
+const extension = /\.js$/i;
+
+const main = async cwd => {
+  console.log(`Fixing files in ${cwd}...`);
+
+  const entries = await readDirectoryAsync(cwd, { withFileTypes: true });
+
+  const files = entries
+    .filter(x => x.isFile())
+    .map(x => x.name)
+    .filter(x => extension.test(x))
+    .filter(x => !ignoredFiles.includes(x));
+
+  const directories = entries
+    .filter(x => x.isDirectory())
+    .map(x => x.name)
+    .filter(x => !ignoredDirectories.includes(x));
+
+  for (const directory of directories) {
+    await main(path.join(cwd, directory));
+  }
+
+  const processFile = async file => {
+    const filePath = path.join(cwd, file);
+    const relativeFilePath = path.relative(root, filePath);
+
+    try {
+      console.log(`Fixing ${relativeFilePath}...`);
+
+      const contents = await readFileAsync(filePath, "utf-8");
+
+      const withExtensions = contents
+        .replace(/from ["'](.*?)\/["']/gm, 'from "$1/index"')
+        .replace(/from ["'](.*?)["']/gm, 'from "$1.js"')
+        .replace(/(\.js)+/g, ".js");
+
+      await writeFileAsync(filePath, withExtensions);
+
+      console.log(`Fixed ${relativeFilePath}`);
+    } catch (error) {
+      console.error(error);
+
+      process.exit(1);
+    }
+  };
+
+  const queue = new PQueue({ concurrency: CONCURRENCY });
+
+  for (const file of files) {
+    queue.add(() => processFile(file));
+  }
+
+  await queue.onIdle();
+};
+
+main(cwd);

array/any.ts

@@ -0,0 +1 @@
+export default xs => xs && xs.length > 0;

array/are.ts

@@ -0,0 +1,3 @@
+import is from "./is";
+
+export default (...xs) => xs.every(is);

array/difference.ts

@@ -0,0 +1,5 @@
+export default (xs, ys) => {
+  const zs = new Set(ys);
+
+  return xs.filter(x => !zs.has(x));
+};

array/differs.ts

@@ -0,0 +1,5 @@
+export default (xs, ys) =>
+  (!xs && ys) ||
+  (!ys && xs) ||
+  xs.length !== ys.length ||
+  xs.some((x, index) => x !== ys[index]);

array/duplicates.ts

@@ -0,0 +1,2 @@
+export default xs =>
+  xs.filter((value, index, self) => self.indexOf(value) !== index);

array/empty.ts

@@ -0,0 +1 @@
+export default [];