ol-stac 0.0.0

package/src/ol/layer/stacUtil.js

@@ -0,0 +1,169 @@
+import VectorLayer from 'ol/layer/Vector.js';
+import {Fill, Stroke, Style} from 'ol/style.js';
+import {STAC} from 'stac-js';
+import {WMTSCapabilities} from 'ol/format.js';
+import {
+  fromEPSGCode,
+  isRegistered as isProj4Registered,
+} from 'ol/proj/proj4.js';
+
+export const defaultBoundsStyle = new Style({
+  fill: new Fill({
+    color: 'rgba(255,255,255,0.4)',
+  }),
+  stroke: new Stroke({
+    color: '#3399CC',
+    width: 3,
+  }),
+});
+
+export const defaultCollectionStyle = new Style({
+  stroke: new Stroke({
+    color: '#ff9933',
+    width: 1,
+  }),
+});
+
+/**
+ * Get the STAC objects associated with this event, if any. Excludes API Collections.
+ * @param {import('ol/MapBrowserEvent.js').default} event The asset to read the information from.
+ * @return {Promise<Array<STAC>>} A list of STAC objects
+ */
+export async function getStacObjectsForEvent(event) {
+  const objects = event.map
+    .getAllLayers()
+    .filter((layer) => {
+      if (
+        layer instanceof VectorLayer &&
+        layer.get('bounds') === true &&
+        layer.get('stac') instanceof STAC
+      ) {
+        const features = layer
+          .getSource()
+          .getFeaturesAtCoordinate(event.coordinate);
+        return features.length > 0;
+      }
+      return false;
+    })
+    .map((layer) => layer.get('stac'));
+  // Make sure we return no duplicates
+  return [...new Set(objects)];
+}
+
+/**
+ * Get the source info for the GeoTiff from the asset.
+ * @param {import('stac-js').Asset} asset The asset to read the information from.
+ * @param {Array<number>} bands The (one-based) bands to show.
+ * @return {import('ol/source/GeoTIFF.js').SourceInfo} The source info for the GeoTiff asset
+ */
+export function getGeoTiffSourceInfoFromAsset(asset, bands) {
+  const sourceInfo = {
+    url: asset.getAbsoluteUrl(),
+  };
+
+  let band = null;
+  // If there's just one band, we can also read the information from there.
+  if (asset.getBands().length === 1) {
+    band = 0;
+  }
+
+  // TODO: It would be useful if OL would allow min/max values per band
+  const {minimum, maximum} = asset.getMinMaxValues(band);
+  if (typeof minimum === 'number') {
+    sourceInfo.min = minimum;
+  }
+  if (typeof maximum === 'number') {
+    sourceInfo.max = maximum;
+  }
+
+  // TODO: It would be useful if OL would allow multiple no-data values
+  const nodata = asset.getNoDataValues(band);
+  if (nodata.length > 0) {
+    sourceInfo.nodata = nodata[0];
+  } else {
+    sourceInfo.nodata = NaN; // NaN is usually a reasonable default if nothing is provided
+  }
+
+  if (bands.length > 0) {
+    sourceInfo.bands = bands;
+  }
+
+  return sourceInfo;
+}
+
+/**
+ * Gets the projection from the asset or link.
+ * @param {import('stac-js').STACReference} reference The asset or link to read the information from.
+ * @param {import('ol/proj.js').ProjectionLike} defaultProjection A default projection to use.
+ * @return {Promise<import('ol/proj.js').ProjectionLike>} The projection, if any.
+ */
+export async function getProjection(reference, defaultProjection = undefined) {
+  let projection = defaultProjection;
+  if (isProj4Registered()) {
+    // TODO: It would be great to handle WKT2 and PROJJSON, but is not supported yet by proj4js.
+    const epsgCode = reference.getMetadata('proj:epsg');
+    if (epsgCode) {
+      try {
+        projection = await fromEPSGCode(epsgCode);
+      } catch (_) {
+        // pass
+      }
+    }
+  }
+  return projection;
+}
+
+/**
+ * Returns the style for the footprint.
+ * Removes the fill if anything is meant to be shown in the bounds.
+ *
+ * @param {Style} [originalStyle] The original style for the footprint.
+ * @param {import('./STAC.js').default} [layerGroup] The associated STAC layergroup to check.
+ * @return {Style} The adapted style for the footprint.
+ */
+export function getBoundsStyle(originalStyle, layerGroup) {
+  const style = originalStyle.clone();
+  if (!layerGroup.hasOnlyBounds()) {
+    style.setFill(null);
+  }
+  return style;
+}
+
+/**
+ * Get a URL from a web-map-link that is specific enough, i.e.
+ * replaces any occurances of {s} if possible, otherwise returns null.
+ * @param {import('./STAC.js').Link} link The web map link.
+ * @return {string|null} Specific URL
+ */
+export function getSpecificWebMapUrl(link) {
+  let url = link.href;
+  if (url.includes('{s}')) {
+    if (
+      Array.isArray(link['href:servers']) &&
+      link['href:servers'].length > 0
+    ) {
+      const i = (Math.random() * link['href:servers'].length) | 0;
+      url = url.replace('{s}', link['href:servers'][i]);
+    } else {
+      return null;
+    }
+  }
+  return url;
+}
+
+/**
+ * Gets the WMTS capabilities from the given web-map-links URL.
+ * @param {string} url Base URL for the WMTS
+ * @return {Promise<Object|null>} Resolves with the WMTS Capabilities object
+ */
+export async function getWmtsCapabilities(url) {
+  try {
+    const urlObj = new URL(url);
+    urlObj.searchParams.set('service', 'wmts');
+    urlObj.searchParams.set('request', 'GetCapabilities');
+    const response = await fetch(urlObj);
+    return new WMTSCapabilities().read(await response.text());
+  } catch (error) {
+    return null;
+  }
+}

package/src/ol/source/GeoTIFF2.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+// to avoid: error TS8022: JSDoc '@extends' is not attached to a class.
+
+/**
+ * @module ol/source/GeoTIFF2
+ */
+
+import GeoTIFF from 'ol/source/GeoTIFF.js';
+
+/**
+ * @typedef {import("ol/source/GeoTIFF.js").Options} GeoTIFFSourceOptions
+ */
+
+/**
+ * @typedef {import("ol/source/GeoTIFF.js").SourceInfo} SourceInfo
+ */
+
+/**
+ * @typedef {import("ol/source/GeoTIFF.js").Options} Options
+ */
+
+/**
+ * @typedef {Object} Options2
+ * @extends Options
+ * @property {import("ol/proj.js").ProjectionLike} [projection] Source projection.  If not provided, the GeoTIFF metadata
+ */
+
+/**
+ * @classdesc
+ * A source for working with GeoTIFF data.
+ *
+ * Available for backward compatibility with ol <= 7.5.1
+ *
+ * @api
+ */
+export default class GeoTIFF2 extends GeoTIFF {
+  /**
+   * @param {Options2} options Data tile options.
+   */
+  constructor(options) {
+    super(options);
+
+    if (options.projection) {
+      this.projection = options.projection;
+    }
+  }
+}

package/tasks/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "env": {
+    "node": true
+  }
+}

package/tasks/build-website.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+#
+# Run this script to build the website.
+#
+set -o errexit
+
+#
+# Destination directory for the website.
+#
+build=build/site
+
+usage() {
+  cat <<-EOF
+
+  Usage: ${1} [options]
+
+  Options:
+    -v <version>
+      Version identifier.  If omitted, the current branch name will be used.
+    
+    -l <version>
+      The latest release version.  If provided, the root of the website will be
+      rebuilt using this version identifier.  If the -l value matches the -v value,
+      the examples and API docs will be copied to en/latest.  If the -l option
+      is omitted, only the examples and API docs will be rebuilt (not the root of the site).
+EOF
+  exit 1;
+}
+
+root=false
+
+while getopts ":v:l:" o; do
+  case "${o}" in
+    v)
+      version=${OPTARG}
+      ;;
+    l)
+      latest=${OPTARG}
+      ;;
+    *)
+      usage
+      ;;
+  esac
+done
+shift $((OPTIND-1))
+
+if [ -z "${version}" ]; then
+  version=$(git branch --show-current)
+fi
+
+root=$(cd -P -- "$(dirname -- "${0}")" && pwd -P)/..
+cd ${root}
+
+rm -rf ${build}
+
+if [ -n "${latest}" ] ; then
+  echo "Building the website root with ${latest}"
+  mkdir -p ${build}
+  OL_VERSION=${latest} node site/build.js
+  cp -r site/build/* ${build}/
+fi
+
+mkdir -p ${build}/en/${version}/
+
+echo "Building examples for ${version}"
+npm run build-examples
+mv build/examples ${build}/en/${version}/
+
+echo "Building API docs for ${version}"
+npm run apidoc
+mv build/apidoc ${build}/en/${version}/
+
+echo "Building the package ${version}"
+npm run build-package
+mv build/ol ${build}/en/${version}/
+
+if [[ "${latest}" == "${version}" ]] ; then
+  echo "Copying to en/latest"
+  cp -r ${build}/en/${version} ${build}/en/latest
+
+  echo "Building release artifacts"
+  pushd ${build}
+  zip -r ${OLDPWD}/build/${version}-site.zip . -x "en/${version}/*"
+  popd
+
+  pushd ${build}/en/${version}/ol
+  zip -r ${OLDPWD}/build/${version}-package.zip .
+  popd
+fi

package/tasks/create-release.js

@@ -0,0 +1,107 @@
+import esMain from 'es-main';
+import yargs from 'yargs';
+import {Octokit} from '@octokit/rest';
+import {basename} from 'node:path';
+import {hideBin} from 'yargs/helpers';
+import {readFile, stat} from 'node:fs/promises';
+
+/**
+ * @typedef {Object} Options
+ * @property {string} token The bearer token.
+ * @property {string} tag The tag.
+ * @property {boolean} draft Create a draft release.
+ * @property {boolean} notes Generate release notes.
+ * @property {string} site Path to zip archive with site contents.
+ * @property {string} package Path to zip archive with source and full build.
+ */
+
+const owner = 'm-mohr';
+const repo = 'ol-stac';
+
+/**
+ * Create a release.
+ * @param {Options} options The release options.
+ */
+async function createRelease(options) {
+  const client = new Octokit({
+    auth: options.token,
+  });
+
+  const response = await client.rest.repos.createRelease({
+    owner,
+    repo,
+    tag_name: options.tag,
+    generate_release_notes: options.notes,
+    draft: options.draft,
+  });
+
+  await uploadAsset(
+    client,
+    response.data,
+    options.site,
+    'Examples and docs (zip)'
+  );
+
+  await uploadAsset(
+    client,
+    response.data,
+    options.package,
+    'Package archive (zip)'
+  );
+}
+
+async function uploadAsset(client, release, assetPath, label) {
+  const name = basename(assetPath);
+  const stats = await stat(assetPath);
+  const data = await readFile(assetPath);
+
+  await client.rest.repos.uploadReleaseAsset({
+    url: release.upload_url,
+    name,
+    label,
+    headers: {
+      'content-type': 'application/zip',
+      'content-length': stats.size,
+    },
+    data,
+  });
+}
+
+if (esMain(import.meta)) {
+  const options = yargs(hideBin(process.argv))
+    .option('token', {
+      describe: 'The token for auth',
+      type: 'string',
+    })
+    .demandOption('token')
+    .option('tag', {
+      describe: 'The release tag (e.g. v7.0.0)',
+      type: 'string',
+    })
+    .demandOption('tag')
+    .option('package', {
+      describe: 'Path to the archive with the source package',
+      type: 'string',
+    })
+    .demandOption('package')
+    .option('site', {
+      describe: 'Path to the archive with the site contents',
+      type: 'string',
+    })
+    .demandOption('site')
+    .option('draft', {
+      describe: 'Create a draft release',
+      type: 'boolean',
+      default: true,
+    })
+    .option('notes', {
+      describe: 'Generate release notes',
+      type: 'boolean',
+      default: true,
+    })
+    .parse();
+
+  createRelease(options).catch((err) => {
+    process.stderr.write(`${err.stack}\n`, () => process.exit(1));
+  });
+}

package/tasks/generate-index.js

@@ -0,0 +1,125 @@
+import esMain from 'es-main';
+import fse from 'fs-extra';
+import generateInfo from './generate-info.js';
+import path, {dirname} from 'path';
+import {fileURLToPath} from 'url';
+
+/**
+ * Read the symbols from info file.
+ * @return {Promise<Array>} Resolves with an array of symbol objects.
+ */
+async function getSymbols() {
+  const info = await generateInfo();
+  return info.symbols.filter((symbol) => symbol.kind != 'member');
+}
+
+/**
+ * Generate an import statement.
+ * @param {Object} symbol Symbol.
+ * @param {string} member Member.
+ * @return {string} An import statement.
+ */
+function getImport(symbol, member) {
+  const defaultExport = symbol.name.split('~');
+  if (symbol.isDefaultExport) {
+    const from = defaultExport[0].replace(/^module\:/, './');
+    const importName = from.replace(/[.\/]+/g, '$');
+    return `import ${importName} from '${from}.js';`;
+  }
+  const namedExport = symbol.name.split('.');
+  if (
+    member &&
+    namedExport.length > 1 &&
+    (defaultExport.length <= 1 || defaultExport[0].includes('.'))
+  ) {
+    const from = namedExport[0].replace(/^module\:/, './');
+    const importName = from.replace(/[.\/]+/g, '_');
+    return `import {${member} as ${importName}$${member}} from '${from}.js';`;
+  }
+  return '';
+}
+
+/**
+ * Generate code to export a named symbol.
+ * @param {Object} symbol Symbol.
+ * @param {Object<string, string>} namespaces Already defined namespaces.
+ * @param {Object} imports Imports.
+ * @return {string} Export code.
+ */
+function formatSymbolExport(symbol, namespaces, imports) {
+  const name = symbol.name;
+  const parts = name.split('~');
+  const nsParts = parts[0].replace(/^module\:/, '').split(/[\/\.]/);
+  const last = nsParts.length - 1;
+  const imp = getImport(symbol, nsParts[last]);
+  if (imp) {
+    const isNamed = parts[0].includes('.');
+    const importName = isNamed
+      ? '_' + nsParts.slice(0, last).join('_') + '$' + nsParts[last]
+      : '$' + nsParts.join('$');
+    let line = nsParts[0];
+    for (let i = 1, ii = nsParts.length; i < ii; ++i) {
+      line += `.${nsParts[i]}`;
+      namespaces[line] =
+        (line in namespaces ? namespaces[line] : true) && i < ii - 1;
+    }
+    line += ` = ${importName};`;
+    imports[imp] = true;
+    return line;
+  }
+  return '';
+}
+
+/**
+ * Generate export code given a list symbol names.
+ * @param {Array<Object>} symbols List of symbols.
+ * @return {string} Export code.
+ */
+function generateExports(symbols) {
+  const namespaces = {};
+  const imports = {};
+  const blocks = [];
+  symbols.forEach(function (symbol) {
+    const name = symbol.name;
+    if (!name.includes('#')) {
+      const imp = getImport(symbol);
+      if (imp) {
+        imports[imp] = true;
+      }
+      const line = formatSymbolExport(symbol, namespaces, imports);
+      if (line) {
+        blocks.push(line);
+      }
+    }
+  });
+  const defs = [...new Set(blocks)];
+  const lines = Object.keys(imports).concat(defs.sort());
+  lines.push('', 'export default ol;');
+  return lines.join('\n');
+}
+
+/**
+ * Generate the exports code.
+ * @return {Promise<string>} Resolves with the exports code.
+ */
+export default async function main() {
+  const symbols = await getSymbols();
+  return generateExports(symbols);
+}
+
+/**
+ * If running this module directly, read the config file, call the main
+ * function, and write the output file.
+ */
+if (esMain(import.meta)) {
+  const baseDir = dirname(fileURLToPath(import.meta.url));
+
+  main()
+    .then(async (code) => {
+      const filepath = path.join(baseDir, '..', 'build', 'index.js');
+      await fse.outputFile(filepath, code);
+    })
+    .catch((err) => {
+      process.stderr.write(`${err.message}\n`, () => process.exit(1));
+    });
+}