ol-stac 0.0.0

package/tasks/generate-info.js

@@ -0,0 +1,189 @@
+import esMain from 'es-main';
+import fse from 'fs-extra';
+import path, {dirname} from 'path';
+import {fileURLToPath} from 'url';
+import {spawn} from 'child_process';
+import {walk} from 'walk';
+
+const isWindows = process.platform.startsWith('win');
+const baseDir = dirname(fileURLToPath(import.meta.url));
+
+const sourceDir = path.join(baseDir, '..', 'src');
+const infoPath = path.join(baseDir, '..', 'build', 'info.json');
+
+/**
+ * Get checked path of a binary.
+ * @param {string} binaryName Binary name of the binary path to find.
+ * @return {string} Path.
+ */
+function getBinaryPath(binaryName) {
+  if (isWindows) {
+    binaryName += '.cmd';
+  }
+
+  const jsdocResolved = path.join(
+    baseDir,
+    '..',
+    'node_modules',
+    'jsdoc',
+    'jsdoc.js'
+  );
+  const expectedPaths = [
+    path.join(baseDir, '..', 'node_modules', '.bin', binaryName),
+    path.resolve(
+      path.join(path.dirname(jsdocResolved), '..', '.bin', binaryName)
+    ),
+  ];
+
+  for (let i = 0; i < expectedPaths.length; i++) {
+    const expectedPath = expectedPaths[i];
+    if (fse.existsSync(expectedPath)) {
+      return expectedPath;
+    }
+  }
+
+  throw Error(
+    'JsDoc binary was not found in any of the expected paths: ' + expectedPaths
+  );
+}
+
+const jsdoc = getBinaryPath('jsdoc');
+
+const jsdocConfig = path.join(
+  baseDir,
+  '..',
+  'config',
+  'jsdoc',
+  'info',
+  'conf.json'
+);
+
+/**
+ * Generate a list of all .js paths in the source directory.
+ * @return {Promise<Array>} Resolves to an array of source paths.
+ */
+function getPaths() {
+  return new Promise((resolve, reject) => {
+    let paths = [];
+
+    const walker = walk(sourceDir);
+    walker.on('file', (root, stats, next) => {
+      const sourcePath = path.join(root, stats.name);
+      if (sourcePath.endsWith('.js')) {
+        paths.push(sourcePath);
+      }
+      next();
+    });
+    walker.on('errors', () => {
+      reject(new Error(`Trouble walking ${sourceDir}`));
+    });
+
+    walker.on('end', () => {
+      /**
+       * Windows has restrictions on length of command line, so passing all the
+       * changed paths to a task will fail if this limit is exceeded.
+       * To get round this, if this is Windows and there are newer files, just
+       * pass the sourceDir to the task so it can do the walking.
+       */
+      if (isWindows) {
+        paths = [sourceDir];
+      }
+
+      resolve(paths);
+    });
+  });
+}
+
+/**
+ * Parse the JSDoc output.
+ * @param {string} output JSDoc output
+ * @return {Object} Symbol and define info.
+ */
+function parseOutput(output) {
+  if (!output) {
+    throw new Error('Expected JSON output');
+  }
+
+  let info;
+  try {
+    info = JSON.parse(String(output));
+  } catch (err) {
+    throw new Error('Failed to parse output as JSON: ' + output);
+  }
+  if (!Array.isArray(info.symbols)) {
+    throw new Error('Expected symbols array: ' + output);
+  }
+  if (!Array.isArray(info.defines)) {
+    throw new Error('Expected defines array: ' + output);
+  }
+
+  return info;
+}
+
+/**
+ * Spawn JSDoc.
+ * @param {Array<string>} paths Paths to source files.
+ * @return {Promise<string>} Resolves with the JSDoc output (new metadata).
+ *     If provided with an empty list of paths, resolves with null.
+ */
+function spawnJSDoc(paths) {
+  return new Promise((resolve, reject) => {
+    let output = '';
+    let errors = '';
+    const cwd = path.join(baseDir, '..');
+    const child = spawn(jsdoc, ['-c', jsdocConfig].concat(paths), {cwd: cwd});
+
+    child.stdout.on('data', (data) => {
+      output += String(data);
+    });
+
+    child.stderr.on('data', (data) => {
+      errors += String(data);
+    });
+
+    child.on('exit', (code) => {
+      if (code) {
+        reject(new Error(errors || 'JSDoc failed with no output'));
+        return;
+      }
+
+      let info;
+      try {
+        info = parseOutput(output);
+      } catch (err) {
+        reject(err);
+        return;
+      }
+      resolve(info);
+    });
+  });
+}
+
+/**
+ * Writes the info.json file.
+ * @param {Object} info The info.
+ * @return {Promise} Resolves on completion.
+ */
+async function write(info) {
+  await fse.outputJson(infoPath, info, {spaces: 2});
+}
+
+/**
+ * Generate info from the sources.
+ * @return {Promise<Error>} Resolves with the info object.
+ */
+export default async function main() {
+  const paths = await getPaths();
+  return await spawnJSDoc(paths);
+}
+
+/**
+ * If running this module directly, generate and write out the info.json file.
+ */
+if (esMain(import.meta)) {
+  main()
+    .then(write)
+    .catch((err) => {
+      process.stderr.write(`${err.message}\n`, () => process.exit(1));
+    });
+}

package/tasks/get-latest-release.js

@@ -0,0 +1,36 @@
+import esMain from 'es-main';
+import semver from 'semver';
+import {Octokit} from '@octokit/rest';
+
+export async function getLatestRelease() {
+  const client = new Octokit();
+
+  let latest = '0.0.0';
+  await client.paginate(
+    client.rest.repos.listReleases,
+    {
+      owner: 'm-mohr',
+      repo: 'ol-stac',
+    },
+    (response) => {
+      for (const release of response.data) {
+        const version = semver.valid(release.name);
+        if (version && semver.gt(version, latest)) {
+          latest = version;
+        }
+      }
+    }
+  );
+
+  return latest;
+}
+
+if (esMain(import.meta)) {
+  getLatestRelease()
+    .then((latest) => {
+      process.stdout.write(`v${latest}\n`, () => process.exit(0));
+    })
+    .catch((err) => {
+      process.stderr.write(`${err.message}\n`, () => process.exit(1));
+    });
+}

package/tasks/newest-tag.js

@@ -0,0 +1,52 @@
+import esMain from 'es-main';
+import semver from 'semver';
+import yargs from 'yargs';
+import {getLatestRelease} from './get-latest-release.js';
+import {hideBin} from 'yargs/helpers';
+
+/**
+ * @typedef {Object} Options
+ * @property {string} tag The tag.
+ */
+
+/**
+ * Check if a tag is ahead of the latest release.
+ * @param {Options} options The options.
+ * @return {boolean} The provided tag is ahead of or equal to the latest release.
+ */
+async function main(options) {
+  const version = semver.valid(options.tag);
+  if (!version) {
+    return false;
+  }
+
+  const parsed = semver.parse(version);
+  if (parsed.prerelease.length) {
+    return false;
+  }
+
+  const latest = await getLatestRelease();
+  return semver.gte(version, latest);
+}
+
+if (esMain(import.meta)) {
+  const options = yargs(hideBin(process.argv))
+    .option('tag', {
+      describe: 'The tag to test (e.g. v1.2.3)',
+      type: 'string',
+    })
+    .demandOption('tag')
+    .parse();
+
+  main(options)
+    .then((newest) => {
+      if (newest) {
+        process.stdout.write('true\n', () => process.exit(0));
+      } else {
+        process.stderr.write('false\n', () => process.exit(1));
+      }
+    })
+    .catch((err) => {
+      process.stderr.write(`${err.stack}\n`, () => process.exit(1));
+    });
+}

package/tasks/prepare-package.js

@@ -0,0 +1,46 @@
+import esMain from 'es-main';
+import fse from 'fs-extra';
+import path, {dirname} from 'path';
+import {fileURLToPath} from 'url';
+
+const baseDir = dirname(fileURLToPath(import.meta.url));
+const buildDir = path.resolve(baseDir, '../build/ol');
+
+async function main() {
+  const pkg = await fse.readJSON(path.resolve(baseDir, '../package.json'));
+
+  // write out simplified package.json
+  pkg.main = 'index.js';
+  delete pkg.scripts;
+  delete pkg.devDependencies;
+  delete pkg.style;
+  delete pkg.eslintConfig;
+  delete pkg.private;
+  await fse.writeJSON(path.join(buildDir, 'package.json'), pkg, {spaces: 2});
+
+  // copy in readme and license files
+  await fse.copyFile(
+    path.resolve(baseDir, '../README.md'),
+    path.join(buildDir, 'README.md')
+  );
+
+  await fse.copyFile(
+    path.resolve(baseDir, '../LICENSE.md'),
+    path.join(buildDir, 'LICENSE.md')
+  );
+
+  await fse.copy(
+    path.resolve(baseDir, '../build/full/'),
+    path.join(buildDir, 'dist')
+  );
+}
+
+/**
+ * If running this module directly, read the config file, call the main
+ * function, and write the output file.
+ */
+if (esMain(import.meta)) {
+  main().catch((err) => {
+    process.stderr.write(`${err.message}\n`, () => process.exit(1));
+  });
+}

package/tasks/publish.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+#
+# Run this script to publish a new version of the library to npm.  This requires
+# that you have a clean working directory and have created a tag that matches
+# the version number in package.json.
+#
+set -o errexit
+
+#
+# Destination directory for the package.
+#
+BUILT_PACKAGE=build/ol
+
+#
+# URL for canonical repo.
+#
+REMOTE=https://github.com/m-mohr/ol-stac.git
+
+#
+# Display usage and exit.
+#
+display_usage() {
+  cat <<-EOF
+
+  Usage: ${1} <version> [options]
+
+  To publish a new release, update the version number in package.json and
+  create a tag for the release.
+
+  The tag name must match the version number prefixed by a "v" (for example,
+  version 3.2.1 would be tagged v3.2.1).
+
+  The tag must be pushed to ${REMOTE} before the release can be published.
+
+  Additional args after <version> will be passed to "npm publish" (e.g. "--tag beta").
+
+EOF
+}
+
+#
+# Exit if the current working tree is not clean.
+#
+assert_clean() {
+  source `git --exec-path`/git-sh-setup && \
+      require_clean_work_tree "publish" "Please commit or stash them."
+}
+
+#
+# Exit if the requested version doesn't match package.json.
+#
+assert_version_match() {
+  v=`grep -o '"version":.*' package.json | sed 's/"version": *"\(.*\)",/\1/'`
+  if test "${1}" != "${v}"; then
+    echo "Version mismatch: requested '${1}', but package.json specifies '${v}'"
+    exit 1
+  fi
+}
+
+#
+# Check out the provided tag.  This ensures that the tag has been pushed to
+# the canonical remote.
+#
+checkout_tag() {
+  git fetch ${REMOTE} refs/tags/v${1}:refs/tags/v${1}
+  git checkout refs/tags/v${1}
+}
+
+#
+# Build the package and publish.
+#
+main() {
+  root=$(cd -P -- "$(dirname -- "${0}")" && pwd -P)/..
+  cd ${root}
+  assert_clean
+  checkout_tag ${1}
+  assert_version_match ${1}
+  npm install
+  npm run build-package
+  cd ${BUILT_PACKAGE}
+  shift
+  npm publish ${@}
+}
+
+if test ${#} -lt 1; then
+  display_usage ${0}
+  exit 1
+else
+  main ${@}
+fi

package/test/README.md

@@ -0,0 +1,56 @@
+## Included in this directory
+
+- browser - Unit/integration tests run in a browser
+- node - Unit tests run with Node.js
+- rendering - Tests that make assertions about rendered map output
+
+
+## Run the test suite
+
+Install the test dependencies (from the root of the repository):
+
+    npm install
+
+Run the tests once:
+
+    npm test
+
+This will run tests in (headless) Chrome.  If you do not have Chrome installed, you can run tests on Firefox instead:
+
+    npm test -- --browsers Firefox
+
+To run tests in other browsers, you need to install [additional Karma launchers](https://karma-runner.github.io/1.0/config/browsers.html).
+
+To run the tests continuously:
+
+    npm run karma
+
+After this, you can attach any browser and debug the tests like this:
+
+ * open http://localhost:9876/debug.html
+ * open the developer tools
+ * add a breakpoint
+ * refresh the page
+
+# Rendering tests
+
+The `test/rendering` directory contains rendering tests which compare a rendered map with a
+reference image using [pixelmatch](https://github.com/mapbox/pixelmatch).
+
+To run the tests in the browser, make sure the development server is running
+(`make serve`) and open the URL
+[http://localhost:3000/test_rendering/index.html](http://localhost:3000/test_rendering/index.html).
+
+From the command-line the tests can be run with the build target `make test-rendering`.
+
+## Adding new tests
+When creating a new test case, a reference image has to be created. By appending `?generate`
+to the URL, a canvas with the rendered map will be shown on the page when calling
+`expectResemble`. Then the reference image can simply be created with a right-click
+and "Save image as".
+
+It is recommended to only run a single test case when generating the reference image.
+
+## Image difference
+When a test fails, an image showing the difference between the reference image and the
+rendered map can be displayed by appending `?showdiff` to the URL.

package/test/browser/.eslintrc

@@ -0,0 +1,14 @@
+{
+  "env": {
+    "mocha": true
+  },
+  "globals": {
+    "afterLoadText": false,
+    "createMapDiv": true,
+    "disposeMap": true,
+    "expect": false,
+    "proj4": false,
+    "sinon": false,
+    "where": false
+  }
+}

package/test/browser/karma.config.cjs

@@ -0,0 +1,94 @@
+/* eslint-disable import/no-commonjs */
+
+const path = require('path');
+
+module.exports = function (karma) {
+  karma.set({
+    browsers: ['ChromeHeadlessLauncher'],
+    customLaunchers: {
+      ChromeHeadlessLauncher: {
+        base: 'Chrome',
+        flags: ['--headless=new'],
+      },
+    },
+    browserDisconnectTolerance: 2,
+    frameworks: ['webpack', 'mocha', 'source-map-support'],
+    client: {
+      runInParent: true,
+      mocha: {
+        timeout: 2500,
+      },
+    },
+    files: [
+      {
+        pattern: path.resolve(__dirname, require.resolve('expect.js/index.js')),
+        watched: false,
+      },
+      {
+        pattern: path.resolve(
+          __dirname,
+          require.resolve('../../node_modules/sinon/pkg/sinon.js')
+        ),
+        watched: false,
+      },
+      {
+        pattern: path.resolve(
+          __dirname,
+          require.resolve('ol/dist/ol.js')
+        ),
+        watched: false,
+      },
+      {
+        pattern: path.resolve(
+          __dirname,
+          require.resolve('proj4/dist/proj4.js')
+        ),
+        watched: false,
+      },
+      {
+        pattern: path.resolve(__dirname, './test-extensions.js'),
+      },
+      {
+        pattern: 'spec/**/*.test.js',
+        watched: false,
+      },
+      {
+        pattern: '**/*',
+        included: false,
+        watched: false,
+      },
+    ],
+    proxies: {
+      '/spec/': '/base/spec/'
+    },
+    preprocessors: {
+      '**/*.js': ['webpack'], //, 'sourcemap'],
+    },
+    reporters: ['dots'],
+    webpack: {
+      devtool: 'inline-source-map',
+      mode: 'development',
+      resolve: {
+        fallback: {
+          fs: false,
+          http: false,
+          https: false,
+        },
+      },
+      module: {
+        rules: [
+          {
+            test: /\.js$/,
+            enforce: 'pre',
+            use: ['source-map-loader'],
+          },
+        ],
+      },
+    },
+    webpackMiddleware: {
+      noInfo: true,
+    },
+  });
+
+  process.env.CHROME_BIN = require('puppeteer').executablePath();
+};

package/test/browser/spec/ol/layer/STAC.test.js

@@ -0,0 +1,18 @@
+import STAC from '../../../../../src/ol/layer/STAC.js';
+
+describe('ol/layer/STAC', function () {
+  describe('constructor (defaults)', function () {
+    /** @type {STAC} */
+    let group;
+
+    beforeEach(function () {
+      group = new STAC({
+        url: 'https://s3.us-west-2.amazonaws.com/sentinel-cogs/sentinel-s2-l2a-cogs/10/T/ES/2022/7/S2A_10TES_20220726_0_L2A/S2A_10TES_20220726_0_L2A.json',
+      });
+    });
+
+    it('creates an instance', function () {
+      expect(group).to.be.a(STAC);
+    });
+  });
+});