sintfacilis 1.0.0

package/packages/arcgis-rest-types/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "es2015",
+    "declaration": true,
+    "declarationDir": "./dist/types",
+    "emitDeclarationOnly": true
+  },
+  "include": ["src/**/*.ts"],
+  "extends": "../../tsconfig.json"
+}

package/support/changelog.js

@@ -0,0 +1,393 @@
+const { spawn, exec, execSync } = require("child_process");
+const { inspect } = require("util");
+const { resolve } = require("path");
+const { writeFile } = require("fs");
+const { stripIndents } = require("common-tags");
+const { format } = require("date-fns");
+const parseChangelog = require("changelog-parser");
+const parseCommit = require("conventional-commits-parser").sync;
+const nunjucks = require("nunjucks");
+const _ = require("lodash");
+
+/**
+ * The purpose of this file is to parse all commits since the last release tag
+ * v*.*.* and update the contents of CHANGELOG.md to prepare for a new release.
+ */
+
+const repo = "https://github.com/Esri/arcgis-rest-js";
+
+function getTags() {
+  return new Promise((resolve, reject) => {
+    let tags = [];
+    const log = spawn("git", ["tag", "-l", "v*", "--sort", "v:refname"]);
+
+    log.stdout.on("data", data => {
+      tags = tags.concat(data.toString().split("\n"));
+    });
+
+    log.on("close", code => {
+      resolve(_.compact(tags));
+    });
+  });
+}
+
+function getFirstCommit() {
+  return new Promise((resolve, reject) => {
+    let commits = [];
+    const log = spawn("git", [
+      "rev-list",
+      "--max-parents=0",
+      "HEAD",
+      "--reverse"
+    ]);
+
+    log.stdout.on("data", data => {
+      commits = commits.concat(data.toString().split("\n"));
+    });
+
+    log.on("close", code => {
+      resolve(commits[0]);
+    });
+  });
+}
+
+function getCommitData(from, to) {
+  return new Promise((resolve, reject) => {
+    const hash = "%H";
+    const shortHash = "%h";
+    const authorName = "%an";
+    const authorEmail = "%ae";
+    const date = "%aI";
+    const subject = "%s";
+    const defaultFormat = {
+      hash,
+      shortHash,
+      date,
+      subject,
+      author: { name: authorName, email: authorEmail }
+    };
+
+    const cmd = `git log ${from}..${to} --pretty=format:'${JSON.stringify(
+      defaultFormat
+    )},'`;
+
+    exec(cmd, (err, stdout, stderr) => {
+      if (err) return reject(err);
+      if (stderr) return reject(stderr);
+      /*
+       NOTE: you will get parsing errors on the next step if your commit messages have special chars like "
+       so you may need to uncomment the call to .replace() in the next line w/ something like:
+       .replace(/"returns"/g, "returns")
+       .replace(/\\/g, "\\\\")
+       */
+      // order commits from most recent to least recent
+      const commits = JSON.parse("[" + stdout.slice(0, -1).replace(/"duration"/g, "duration").replace(/"expiration"/g, "expiration") + "]").reverse();
+      const today = new Date();
+      resolve({
+        previousVersion: /v\d\.\d\.\d/.test(from)
+          ? from.replace("v", "")
+          : from,
+        version: to === "HEAD" ? getPackageVersion() : to.replace("v", ""),
+        date: format(today, "MMMM Do YYYY"),
+        commits
+      });
+    });
+  });
+}
+
+function getPackageVersion() {
+  return require(resolve(process.cwd(), "./lerna.json")).version;
+}
+
+function pairReleases(releases) {
+  return Promise.all(
+    releases.reduce((pairs, release, idx, allReleases) => {
+      const nextRelease = allReleases[idx + 1];
+      if (nextRelease) {
+        pairs.push([release, nextRelease]);
+      }
+
+      return pairs;
+    }, [])
+  );
+}
+
+function processCommitMessages(releaseData) {
+  return releaseData.map(release => {
+    release.commits = _(release.commits)
+      .map(commit => {
+        const parsedCommit = parseCommit(
+          execSync(
+            `git log ${commit.hash} -n1 --pretty=format:'%B'`
+          ).toString(),
+          {
+            mergePattern: /^Merge pull request #(\d+) from (.*)$/,
+            mergeCorrespondence: ["id", "source"],
+            noteKeywords: [
+              "BREAKING CHANGE",
+              "ISSUES CLOSED",
+              "AFFECTS PACKAGES"
+            ]
+          }
+        );
+        if (!parsedCommit.type || !parsedCommit.scope) {
+          return;
+        }
+
+        Object.assign(commit, parsedCommit);
+
+        const breaking = commit.notes.findIndex(
+          n => n.title === "BREAKING CHANGE"
+        );
+
+        if (breaking >= 0) {
+          commit.breakingChanges = commit.notes[breaking].text;
+        }
+
+        const issues = commit.notes.findIndex(n => n.title === "ISSUES CLOSED");
+
+        if (issues >= 0) {
+          const issuesClosed = commit.notes[issues].text
+            .replace(/\n.*/gm, "")
+            .replace(/\s/g, "")
+            .split(",")
+            .map(i => i.replace("#", ""));
+
+          const issuesReferenced = commit.references.map(r => r.issue);
+
+          commit.relatedIssues = _.uniq(
+            issuesClosed.concat(issuesReferenced)
+          ).map(i => {
+            return {
+              issue: i,
+              url: `${repo}/issues/${i}`
+            };
+          });
+        }
+        return commit;
+      })
+      .compact()
+      .sortBy("type")
+      .value();
+
+    return release;
+  });
+}
+
+function getPackagesForCommit(commit) {
+  const idx = commit.notes.findIndex(note => note.title === "AFFECTS PACKAGES");
+  if (idx >= 0) {
+    const affectedPackages = commit.notes[idx].text.split("\n");
+    return affectedPackages;
+  }
+  return ["Other Changes"];
+}
+
+function findReleasedPackages(releases) {
+  return releases.map(release => {
+    release.packages = release.commits.reduce((packages, commit) => {
+      packages = packages.concat(getPackagesForCommit(commit));
+      return _(packages).compact().uniq().sortBy(p => p).value();
+    }, []);
+    return release;
+  });
+}
+
+function hasBreakingChanges(commit) {
+  return commit.notes.find(n => n.title === "BREAKING CHANGE");
+}
+
+function groupCommitsByPackage(releases) {
+  return releases.map(release => {
+    release.groups = release.packages.reduce((groups, package) => {
+      const commitsForPackage = release.commits.filter(commit => {
+        return getPackagesForCommit(commit).some(
+          commitPackage => commitPackage === package
+        );
+      });
+
+      const [breaking, nonBreaking] = _.partition(
+        commitsForPackage,
+        hasBreakingChanges
+      );
+
+      if (breaking.length === 0) {
+        groups[package] = Object.assign(
+          {},
+          _.groupBy(_.sortBy(nonBreaking, "type"), "type")
+        );
+      } else {
+        groups[package] = Object.assign(
+          { breaking },
+          _.groupBy(nonBreaking, "type")
+        );
+      }
+
+      return groups;
+    }, {});
+    delete release.commits;
+    return release;
+  });
+}
+
+function getTypeName(type) {
+  switch (type) {
+    case "feat":
+      return "New Features";
+    case "fix":
+      return "Bug Fixes";
+    case "docs":
+      return "Documentation";
+    case "style":
+      return "Code Style";
+    case "Refactor":
+      return "Refactoring";
+    case "perf":
+      return "Performance";
+    case "test":
+      return "Tests";
+    case "chore":
+      return "Chores";
+    case "revert":
+      return "Reverts";
+    case "breaking":
+      return "Breaking Changes";
+    case "WIP":
+      return "Work In Progress";
+    default:
+      return "Misc.";
+  }
+}
+
+const template = stripIndents`
+  {%- macro link(repo, shortHash, hash) -%}
+    [\`{{ shortHash }}\`]({{repo}}/commit/{{ hash }})
+  {%- endmacro %}
+
+  {%- macro relatedIssues(issues) -%}
+    {%- for i in issues -%}
+    {{" "}}[#{{i.issue}}]({{i.url}})
+    {%- endfor -%}
+  {%- endmacro %}
+
+  {%- for release in releases %}
+    ## [{{ release.version }}] - {{ release.date }}
+    {% for package, groups in release.groups %}
+      ### {{ package }}
+
+      {% for type, commits in groups -%}
+        * {{ getTypeName(type) }}
+        {% for c in commits -%}
+        {{"   "}}* **{{ c.scope }}**: {{ c.subject }} {{link(repo, c.shortHash, c.hash)}}{{relatedIssues(c.relatedIssues)}}
+        {% endfor %}
+      {%- endfor %}
+    {%- endfor %}
+  {%- endfor %}
+`;
+
+function buildMarkdown(releases) {
+  return nunjucks.renderString(template, { releases, getTypeName, repo });
+}
+
+logStep = v => {
+  console.log(inspect(v, { depth: 7 }));
+  return v;
+};
+
+const changeLogTemplate = stripIndents`
+  # {{title}}
+
+  {{description}}
+  {{newVersion}}
+
+  {%- for version in oldVersions %}
+  ## {{version.title}}
+
+  {{version.body}}
+  {% endfor %}
+  {% for link in links -%}
+  [{{link.ref}}]: {{link.href}} "{{link.title}}"
+  {% endfor -%}
+`;
+
+function getReleases() {
+  return Promise.all([
+    getTags(),
+    getFirstCommit()
+  ]).then(([releases, firstCommit]) => {
+    if (releases.length === 0) {
+      return [];
+    }
+
+    releases.unshift(firstCommit);
+    releases.push("HEAD");
+    return releases;
+  });
+}
+
+function getChangelogData() {
+  return new Promise((resolve, reject) => {
+    parseChangelog("CHANGELOG.md", function(error, changelog) {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      resolve(changelog);
+    });
+  });
+}
+
+function filterReleases(releases) {
+  return releases.slice(-2);
+}
+
+getReleases()
+  .then(releases => filterReleases(releases))
+  .then(releases => pairReleases(releases))
+  .then(pairs =>
+    Promise.all(pairs.map(([from, to]) => getCommitData(from, to)))
+  )
+  .then(releaseData => processCommitMessages(releaseData))
+  .then(releaseData => findReleasedPackages(releaseData))
+  .then(releaseData => groupCommitsByPackage(releaseData))
+  .then(releaseData => buildMarkdown(releaseData))
+  .then(newVersion => {
+    return Promise.all([
+      getReleases().then(pairReleases),
+      getChangelogData(),
+      Promise.resolve(newVersion)
+    ]);
+  })
+  .then(([pairs, changelog, newVersion]) => {
+    const links = pairs.map(([from, to]) => {
+      to = to === "HEAD" ? "v" + getPackageVersion() : to;
+      return {
+        ref: to.replace("v", ""),
+        title: to,
+        href: `${repo}/compare/${from}...${to}`
+      };
+    });
+
+    if (links.length) {
+      links.push({
+        ref: "HEAD",
+        title: "Unreleased Changes",
+        href: `${repo}/compare/${_.last(links).title}...HEAD`
+      });
+    }
+
+    const rendered = nunjucks.renderString(changeLogTemplate, {
+      title: changelog.title,
+      description: changelog.description,
+      oldVersions: changelog.versions,
+      newVersion: newVersion,
+      links,
+      repo
+    });
+
+    writeFile("CHANGELOG.md", rendered, function(e) {});
+  })
+  .catch(error => {
+    console.error(error.stack);
+  });

package/support/deploy-doc-site.js

@@ -0,0 +1,16 @@
+const ghpages = require("gh-pages");
+
+ghpages.publish(
+  "docs/build",
+  {
+    branch: "gh-pages",
+    repo: "https://github.com/Esri/arcgis-rest-js.git"
+  },
+  function(err) {
+    if (err) {
+      console.log("uh oh", err);
+    } else {
+      console.log("Deployed docs site!");
+    }
+  }
+);

package/support/dev.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# extract build type and scope from the command line args
+BUILD_TYPE=$1
+SCOPE=$2
+ # run the dev script for that build type in the scoped packages
+lerna run --scope "$SCOPE" dev:$BUILD_TYPE --parallel

package/support/publish.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+# Make sure user is logged in to npm
+npm whoami || exit 1
+
+# Extract the version from lerna.json (this was updated by `npm run release:prepare`)
+VERSION=$(node --eval "console.log(require('./lerna.json').version);")
+
+# publish each package on npm
+lerna publish --skip-git --yes --repo-version $VERSION --force-publish=*
+
+# generate `docs/src/srihashes.json` after release and before committing
+npm run docs:srihash
+
+# commit the changes from `npm run release:prepare`
+git add --all
+git commit -am "v$VERSION" --no-verify
+
+# increment the package.json version to the lerna version so gh-release works
+npm version $VERSION --allow-same-version --no-git-tag-version
+
+# amend the changes from `npm version` to the release commit
+git add --all
+git commit -am "v$VERSION" --no-verify --amend
+
+# tag this version
+git tag v$VERSION
+
+# push everything up to this point to master
+git push https://github.com/Esri/arcgis-rest-js.git master
+
+# push the new tag, not the old tags
+git push https://github.com/Esri/arcgis-rest-js.git v$VERSION
+
+
+# create a ZIP archive of the dist files
+TEMP_FOLDER=arcgis-rest-js-v$VERSION;
+mkdir $TEMP_FOLDER
+cp packages/*/dist/umd/* $TEMP_FOLDER
+zip -r $TEMP_FOLDER.zip $TEMP_FOLDER
+rm -rf $TEMP_FOLDER
+
+# Run gh-release to create a new release with our changelog changes and ZIP archive
+gh-release --t v$VERSION --repo arcgis-rest-js --owner Esri -a $TEMP_FOLDER.zip
+
+# Delete the ZIP archive
+rm $TEMP_FOLDER.zip

package/support/test-helpers.js

@@ -0,0 +1,9 @@
+// ensures node-fetch is available as a global
+require('cross-fetch/polyfill');
+require("isomorphic-form-data");
+
+require("ts-node").register({
+  compilerOptions: {
+    module: "commonjs"
+  }
+});

package/tsconfig.json

@@ -0,0 +1,63 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "target": "es5" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */,
+    "module": "es2015" /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
+    "lib": [
+      "dom",
+      "es2015"
+    ] /* Specify library files to be included in the compilation:  */,
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    "declaration": false /* Generates corresponding '.d.ts' file. */,
+    "sourceMap": true /* Generates corresponding '.map' file. */,
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    // "outDir": "./",                        /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    "importHelpers": true /* Import emit helpers from 'tslib'. */,
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    "noImplicitAny": true /* Raise error on expressions and declarations with an implied 'any' type. */,
+    "strictNullChecks": false /* Enable strict null checks. */,
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    "alwaysStrict": true /* Parse in strict mode and emit "use strict" for each source file. */,
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    "typeRoots": [
+      "./node_modules/@types"
+    ] /* List of folders to include type definitions from. */,
+    "types": [
+      "node",
+      "jasmine"
+    ] /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+
+    /* Source Map Options */
+    // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+  },
+  "exclude": ["node_modules"],
+  "include": ["./node_modules/@types", "packages", "support"]
+}

package/umd-base-profile.js

@@ -0,0 +1,81 @@
+import typescript2 from "rollup-plugin-typescript2";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import json from "@rollup/plugin-json";
+
+const path = require("path");
+const fs = require("fs");
+const _ = require("lodash");
+
+/**
+ * Since Rollup runs inside each package we can just get the current
+ * package we are bundling.
+ */
+const pkg = require(path.join(process.cwd(), "package.json"));
+
+/**
+ * and dig out its name.
+ */
+const { name } = pkg;
+
+/**
+ * to construct a copyright banner
+ */
+
+const copyright = `/* @preserve
+* ${pkg.name} - v${pkg.version} - ${pkg.license}
+* Copyright (c) 2017-${new Date().getFullYear()} Esri, Inc.
+* ${new Date().toString()}
+*/`;
+
+/**
+ * The module name will be the name of the global variable used in UMD builds.
+ * All exported members of each package will be attached to this global.
+ */
+const moduleName = "arcgisRest";
+
+/**
+ * Now we need to discover all the `@esri/arcgis-rest-*` package names so we can create
+ * the `globals` and `externals` to pass to Rollup.
+ */
+const packageNames = fs
+  .readdirSync(path.join(__dirname, "packages"))
+  .filter(p => p[0] !== ".")
+  .map(p => {
+    return require(path.join(__dirname, "packages", p, "package.json")).name;
+  }, {});
+
+/**
+ * Rollup will use this map to determine where to lookup modules on the global
+ * window object when neither AMD or CommonJS is being used. This configuration
+ * will cause Rollup to lookup all imports from our packages on a single global
+ * `arcgisRest` object.
+ */
+const globals = packageNames.reduce((globals, p) => {
+  globals[p] = moduleName;
+  return globals;
+}, {});
+
+/**
+ * Now we can export the Rollup config!
+ */
+export default {
+  input: "./src/index.ts",
+  output: {
+    file: `./dist/umd/${name.replace("@esri/arcgis-rest-", "")}.umd.js`,
+    sourcemap: true,
+    banner: copyright,
+    format: "umd",
+    name: moduleName,
+    globals,
+    extend: true // causes this module to extend the global specified by `moduleName`
+  },
+  context: "window",
+  external: packageNames,
+  plugins: [
+    typescript2(),
+    json(),
+    nodeResolve(),
+    commonjs()
+  ]
+};

package/umd-production-profile.js

@@ -0,0 +1,13 @@
+import config from './umd-base-profile.js';
+import { uglify } from "rollup-plugin-uglify";
+import filesize from "rollup-plugin-filesize";
+
+// use umd.min.js
+config.output.file = config.output.file.replace(".umd.", ".umd.min.");
+
+config.plugins.push(filesize())
+config.plugins.push(uglify({
+  output: { comments: /@preserve/ }
+}))
+
+export default config;