@vcmap/ui 5.0.0-rc.10

package/build/determineHost.js

@@ -0,0 +1,46 @@
+/* eslint import/no-extraneous-dependencies: ["error", { "devDependencies": false }] */
+import os from 'os';
+
+/**
+ * Determine the host based on the _first_ non internal interface. Used if server is started with an empty "--host" flag.
+ * @returns {string|null}
+ */
+export function determineHostIpFromInterfaces() {
+  const interFace = Object.values(os.networkInterfaces())
+    .flatMap(nInterface => nInterface ?? [])
+    .find(detail => detail && detail.address && !detail.internal && detail.family === 'IPv4');
+  return interFace?.address ?? null;
+}
+
+/**
+ * @param {number} [defaultPort=8080]
+ * @param {boolean} [defaultHttps=false]
+ * @param {string} [defaultHost='127.0.0.1']
+ * @returns {string}
+ */
+export function determineHostFromArgv(defaultPort = 8080, defaultHttps = false, defaultHost = '127.0.0.1') {
+  let port = defaultPort;
+  const portIndex = process.argv.indexOf('--port');
+  if (portIndex > -1 && process.argv.length > portIndex + 1) {
+    const portNumber = Number(process.argv[portIndex + 1]);
+    if (Number.isFinite(portNumber)) {
+      port = portNumber;
+    }
+  }
+
+  let protocol = defaultHttps ? 'https' : 'http';
+  if (process.argv.includes('--https')) {
+    protocol = 'https';
+  }
+
+  const hostIndex = process.argv.indexOf('--host');
+  let host = defaultHost;
+  if (hostIndex > -1) {
+    if (process.argv.length > hostIndex + 1 && !process.argv[hostIndex + 1].startsWith('-')) {
+      host = process.argv[hostIndex + 1];
+    } else {
+      host = determineHostIpFromInterfaces() ?? host;
+    }
+  }
+  return `${protocol}://${host}:${port}`;
+}

package/build/generateOLLib.js

@@ -0,0 +1,196 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+
+const isWindows = process.platform.indexOf('win') === 0;
+const sourceDir = path.join('node_modules', 'ol', 'src');
+
+/**
+ * Parse the JSDoc output.
+ * @param {string} output JSDoc output
+ * @returns {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;
+}
+
+/**
+ * Get checked path of a binary.
+ * @param {string} binaryName Binary name of the binary path to find.
+ * @returns {string} Path.
+ */
+function getBinaryPath(binaryName) {
+  const binary = isWindows ? `${binaryName}.cmd` : binaryName;
+
+  const expectedPaths = [
+    path.join('node_modules', '.bin', binary),
+    path.resolve(
+      path.join('node_modules', 'jsdoc', '.bin', binary),
+    ),
+  ];
+
+  for (let i = 0; i < expectedPaths.length; i++) {
+    const expectedPath = expectedPaths[i];
+    if (fs.existsSync(expectedPath)) {
+      return expectedPath;
+    }
+  }
+
+  throw Error(
+    `JsDoc binary was not found in any of the expected paths: ${ expectedPaths}`,
+  );
+}
+
+/**
+ * Spawn JSDoc.
+ * @returns {Promise<Object>} Resolves with the JSDoc output (new metadata).
+ *     If provided with an empty list of paths, resolves with null.
+ */
+function spawnJSDoc() {
+  const jsdocConfig = path.join(
+    'build',
+    'info',
+    'conf.json',
+  );
+
+  return new Promise((resolve, reject) => {
+    let output = '';
+    let errors = '';
+    const child = spawn(getBinaryPath('jsdoc'), ['-c', jsdocConfig, sourceDir]);
+
+    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);
+    });
+  });
+}
+
+/**
+ * Read the symbols from info file.
+ * @returns {Promise<Array>} Resolves with an array of symbol objects.
+ */
+async function getSymbols() {
+  const info = await spawnJSDoc();
+  return info.symbols.filter(
+    symbol => symbol.kind !== 'member' || symbol.exports,
+  );
+}
+
+const exported = new Set();
+
+/**
+ * Generate an import statement.
+ * @param {Object} symbol Symbol.
+ * @param {string} member Member.
+ * @returns {string|null} An import statement.
+ */
+function getImport(symbol, member) {
+  const defaultExport = symbol.name.split('~');
+  const namedExport = symbol.name.split('.');
+  let importName;
+  let exportName;
+  let from;
+
+  if (defaultExport.length > 1 || symbol.exports === 'default') {
+    from = defaultExport[0].replace(/^module:/, '');
+    importName = 'default';
+    exportName = from.replace(/[./]+/g, '$');
+  } else if (namedExport.length > 1 && (member || (symbol.exports && symbol.exports !== 'default'))) {
+    from = namedExport[0].replace(/^module:/, '');
+    importName = member || symbol.exports;
+    exportName = `${from.replace(/[./]+/g, '$')}$${importName}`;
+  }
+  if (exportName && !exported.has(exportName)) {
+    exported.add(exportName);
+    return `export {${importName} as ${exportName}} from '${from}';`;
+  }
+  return null;
+}
+
+/**
+ * Generate code to export a named symbol.
+ * @param {Object} symbol Symbol.
+ * @param {Object<string, string>} namespaces Already defined namespaces.
+ * @param {Object} imports Imports.
+ */
+function formatSymbolExport(symbol, namespaces, imports) {
+  const { name } = symbol;
+  const parts = name.split('~');
+  const nsParts = parts[0].replace(/^module:/, '').split(/[/.]/);
+  const imp = getImport(symbol, nsParts.pop());
+  if (imp) {
+    imports[imp] = true;
+  }
+}
+
+/**
+ * Generate export code given a list symbol names.
+ * @param {Array<Object>} symbols List of symbols.
+ * @returns {string} Export code.
+ */
+function generateExports(symbols) {
+  const namespaces = {};
+  const imports = [];
+  symbols.forEach((symbol) => {
+    const { name } = symbol;
+    if (name.indexOf('#') === -1) {
+      const imp = getImport(symbol);
+      if (imp) {
+        imports[imp] = true;
+      }
+      formatSymbolExport(symbol, namespaces, imports);
+    }
+  });
+  const source = Object.keys(imports)
+    .map(line => line.replace('from \'ol/', 'from \'ol/'))
+    .map(line => line.replace('from \'ol\'', 'from \'ol/index.js\''))
+    .join('\n');
+  return `${source}\nexport * from 'ol/index.js';\n`;
+}
+
+/**
+ * Generate the exports code.
+ * @returns {Promise<string>} Resolves with the exports code.
+ */
+export default async function main() {
+  const symbols = await getSymbols();
+  const code = generateExports(symbols);
+  const filepath = path.join('lib', 'olLib.js');
+  await fs.promises.writeFile(filepath, `/* eslint-disable */\n${code}`);
+}

package/build/getPluginProxies.js

@@ -0,0 +1,29 @@
+/* eslint import/no-extraneous-dependencies: ["error", { "devDependencies": false }] */
+import path from 'path';
+import { getPluginDirectory, getPluginNames } from './buildHelpers.js';
+
+/**
+ * Determines the proxy setting to serve plugins referrenced in the package.json in the plugins directory
+ * @param {string} [target=http://localhost:8080]
+ * @param {boolean} [production=false]
+ * @returns {Promise<Record<string, string | import("vite").ProxyOptions>>}
+ */
+export default async function getPluginProxies(target = 'http://localhost:8080', production = false) {
+  const root = process.cwd();
+  const pluginsDir = getPluginDirectory();
+  const plugins = await getPluginNames();
+  const proxies = {};
+
+  plugins.forEach((plugin) => {
+    proxies[`^/plugins/${plugin}/.*`] = {
+      target,
+      rewrite: (route) => {
+        const rest = route.replace(new RegExp(`^/plugins/${plugin}/`), '');
+        const file = rest || 'index.js';
+        return path.posix.join(path.relative(root, pluginsDir), 'node_modules', plugin, production ? 'dist' : 'src', file);
+      },
+    };
+  });
+
+  return proxies;
+}

package/build/info/api-plugin.js

@@ -0,0 +1,11 @@
+/**
+ * Handle the api annotation.
+ * @param {Object} dictionary The tag dictionary.
+ */
+exports.defineTags = function defineTags(dictionary) {
+  dictionary.defineTag('api', {
+    onTagged(doclet) {
+      doclet.api = true;
+    },
+  });
+};

package/build/info/conf.json

@@ -0,0 +1,21 @@
+{
+    "opts": {
+        "recurse": true,
+        "template": "build/info"
+    },
+    "tags": {
+        "allowUnknownTags": true
+    },
+    "source": {
+        "includePattern": "\\.js$"
+    },
+    "plugins": [
+        "jsdoc-plugin-typescript",
+        "build/info/api-plugin",
+        "build/info/define-plugin",
+        "build/info/virtual-plugin"
+    ],
+    "typescript": {
+      "moduleRoot": "node_modules/ol/src"
+    }
+}

package/build/info/define-plugin.js

@@ -0,0 +1,31 @@
+/**
+ * @file  This plugin extracts info from boolean defines.  This only
+ * handles boolean defines with the default value in the description.  Default
+ * is assumed to be provided with something like "default is `true`" (case
+ * insensitive, with or without ticks).
+ */
+
+const DEFAULT_VALUE = /default\s+is\s+`?(true|false)`?/i;
+
+/**
+ * Hook to define new tags.
+ * @param {Object} dictionary The tag dictionary.
+ */
+exports.defineTags = function defineTags(dictionary) {
+  dictionary.defineTag('define', {
+    canHaveType: true,
+    mustHaveValue: true,
+    onTagged(doclet, tag) {
+      const types = tag.value.type.names;
+      if (types.length === 1 && types[0] === 'boolean') {
+        const match = tag.value.description.match(DEFAULT_VALUE);
+        if (match) {
+          doclet.define = {
+            default: match[1] === 'true',
+          };
+          doclet.description = tag.value.description;
+        }
+      }
+    },
+  });
+};

package/build/info/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/build/info/publish.js

@@ -0,0 +1,190 @@
+/**
+ * @file Generates JSON output based on exportable symbols.
+ */
+const assert = require('assert');
+const path = require('path');
+
+/**
+ * Publish hook for the JSDoc template.  Writes to JSON stdout.
+ * @param {Function} data The root of the Taffy DB containing doclet records.
+ * @returns {Promise} A promise that resolves when writing is complete.
+ */
+exports.publish = function publish(data) {
+  function getTypes(typeData) {
+    const types = [];
+    typeData.forEach((name) => {
+      types.push(name.replace(/^function$/, 'Function'));
+    });
+    return types;
+  }
+
+  // get all doclets that have exports
+  const classes = {};
+  const docs = data(
+    [
+      { define: { isObject: true } },
+      function someKindOfExportsTransformer() {
+        if (this?.meta?.code?.name) {
+          if (this.meta.code.name === 'module.exports') {
+            this.exports = 'default';
+          } else if (this.meta.code.name.startsWith('exports.')) {
+            this.exports = this.meta.code.name.replace(/exports./, '');
+          }
+        }
+        if (this.kind === 'class') {
+          if (!('extends' in this) || typeof this.api === 'boolean' || this.exports) {
+            classes[this.longname] = this;
+            return true;
+          }
+        }
+        return (
+          typeof this.api === 'boolean' ||
+          this.exports ||
+          (this.meta && /[\\/]externs$/.test(this.meta.path))
+        );
+      },
+    ],
+    { kind: { '!is': 'file' } },
+    { kind: { '!is': 'event' } },
+  ).get();
+
+  // get symbols data, filter out those that are members of private classes
+  const symbols = [];
+  const defines = [];
+  const typedefs = [];
+  const externs = [];
+  let base = [];
+  const augments = {};
+  const symbolsByName = {};
+  docs
+    .filter((doc) => {
+      let include = true;
+      const constructor = doc.memberof;
+      if (
+        constructor &&
+        constructor.substr(-1) === '_' &&
+        constructor.indexOf('module:') === -1
+      ) {
+        assert.strictEqual(
+          doc.inherited,
+          true,
+          `Unexpected export on private class: ${ doc.longname}`,
+        );
+        include = false;
+      }
+      return include;
+    })
+    .forEach((doc) => {
+      const isExterns = /[\\/]externs$/.test(doc.meta.path);
+      if (doc.define) {
+        defines.push({
+          name: doc.longname,
+          description: doc.description,
+          path: path.join(doc.meta.path, doc.meta.filename),
+          default: doc.define.default,
+        });
+      } else if (doc.kind === 'typedef' || (doc.isEnum === true && !doc.exports)) {
+        typedefs.push({
+          name: doc.longname,
+          types: getTypes(doc.type.names),
+        });
+      } else {
+        const symbol = {
+          exports: doc.exports,
+          name: doc.longname,
+          kind: doc.kind,
+          description: doc.classdesc || doc.description,
+          path: path.join(doc.meta.path, doc.meta.filename),
+        };
+        if (doc.augments) {
+          symbol.extends = doc.augments[0];
+        }
+        if (doc.virtual) {
+          symbol.virtual = true;
+        }
+        if (doc.type) {
+          symbol.types = getTypes(doc.type.names);
+        }
+        if (doc.params) {
+          const params = [];
+          doc.params.forEach((param) => {
+            const paramInfo = {
+              name: param.name,
+            };
+            params.push(paramInfo);
+            paramInfo.types = getTypes(param.type.names);
+            if (typeof param.variable === 'boolean') {
+              paramInfo.variable = param.variable;
+            }
+            if (typeof param.optional === 'boolean') {
+              paramInfo.optional = param.optional;
+            }
+            if (typeof param.nullable === 'boolean') {
+              paramInfo.nullable = param.nullable;
+            }
+          });
+          symbol.params = params;
+        }
+        if (doc.returns) {
+          symbol.returns = {
+            types: getTypes(doc.returns[0].type.names),
+          };
+          if (typeof doc.returns[0].nullable === 'boolean') {
+            symbol.returns.nullable = doc.returns[0].nullable;
+          }
+        }
+        if (doc.tags) {
+          doc.tags.every((tag) => {
+            if (tag.title === 'template') {
+              symbol.template = tag.value;
+              return false;
+            }
+            return true;
+          });
+        }
+
+        // eslint-disable-next-line no-nested-ternary
+        const target = isExterns ? externs : (doc.api || doc.exports) ? symbols : base;
+        const existingSymbol = symbolsByName[symbol.name];
+        if (existingSymbol) {
+          const idx = target.indexOf(existingSymbol);
+          target.splice(idx, 1);
+        }
+        target.push(symbol);
+        symbolsByName[symbol.name] = symbol;
+
+        if (doc.api && symbol.extends) {
+          while (
+            symbol.extends in classes &&
+            !classes[symbol.extends].api &&
+            classes[symbol.extends].augments
+          ) {
+            symbol.extends = classes[symbol.extends].augments[0];
+          }
+          if (symbol.extends) {
+            augments[symbol.extends] = true;
+          }
+        }
+      }
+    });
+
+  base = base.filter((symbol) => {
+    return symbol.name in augments || symbol.virtual;
+  });
+
+  return new Promise(() => {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          symbols,
+          defines,
+          typedefs,
+          externs,
+          base,
+        },
+        null,
+        2,
+      ),
+    );
+  });
+};

package/build/info/virtual-plugin.js

@@ -0,0 +1,15 @@
+/**
+ * Handle the interface and abstract annotations.
+ * @param {Object} dictionary The tag dictionary.
+ */
+exports.defineTags = function defineTags(dictionary) {
+  const classTag = dictionary.lookUp('class');
+  dictionary.defineTag('interface', {
+    mustNotHaveValue: true,
+    onTagged(doclet) {
+      // eslint-disable-next-line prefer-rest-params
+      classTag.onTagged.apply(this, arguments);
+      doclet.virtual = true;
+    },
+  });
+};

package/build/staging/Dockerfile

@@ -0,0 +1,2 @@
+FROM httpd:2-buster
+COPY * /usr/local/apache2/htdocs/