@vizhub/runtime 0.0.1

package/src/v2Runtime/bundle/bubleJSXOnly.ts

@@ -0,0 +1,34 @@
+// Derived from https://github.com/rollup/rollup-plugin-buble/blob/master/src/index.js
+// import { transform } from 'buble-jsx-only';
+
+import { transform } from 'buble';
+// import { createFilter } from 'rollup-pluginutils';
+
+export default function buble(options) {
+  if (!options) options = {};
+  // var filter = createFilter(
+  //   options.include,
+  //   options.exclude,
+  // );
+
+  if (!options.transforms) options.transforms = {};
+  options.transforms.modules = false;
+
+  return {
+    name: 'buble',
+
+    transform: function (code, id) {
+      // if (!filter(id)) return null;
+
+      try {
+        return transform(code, options);
+      } catch (e) {
+        e.plugin = 'buble';
+        if (!e.loc) e.loc = {};
+        e.loc.file = id;
+        e.frame = e.snippet;
+        throw e;
+      }
+    },
+  };
+}

package/src/v2Runtime/bundle/getLibraries.js

@@ -0,0 +1,31 @@
+import vizhubLibraries from 'vizhub-libraries';
+import { getConfiguredLibraries } from './packageJson';
+
+export const getLibraries = (files) => {
+  const configuredLibraries = getConfiguredLibraries(files);
+  const userLibrariesNames = configuredLibraries
+    ? Object.keys(configuredLibraries)
+    : [];
+
+  const userLibraries = userLibrariesNames.reduce(
+    (globals, packageName) => {
+      // in case if user created settings but not provide global, stub global with vizhub known global name
+      const globalName =
+        configuredLibraries[packageName].global ||
+        vizhubLibraries[packageName];
+
+      if (globalName) {
+        globals[packageName] = globalName;
+      } else {
+        console.warn(
+          `There is no global name for ${packageName}.\n Please add it to "vizhub.${packageName}.global" section in package.json.`,
+        );
+      }
+
+      return globals;
+    },
+    {},
+  );
+
+  return { ...vizhubLibraries, ...userLibraries };
+};

package/src/v2Runtime/bundle/hypothetical.js

@@ -0,0 +1,232 @@
+// Temporary file (fingers crossed)
+// See https://github.com/Permutatrix/rollup-plugin-hypothetical/pull/9
+import path from 'path-posix';
+
+function isAbsolute(p) {
+  return path.isAbsolute(p) || /^[A-Za-z]:\//.test(p);
+}
+
+function isExternal(p) {
+  return !/^(\.?\.?|[A-Za-z]:)\//.test(p);
+}
+
+function absolutify(p, cwd) {
+  if (cwd) {
+    return path.join(cwd, p);
+  } else {
+    return './' + p;
+  }
+}
+
+function forEachInObjectOrMap(object, map, callback) {
+  if (object && map) {
+    throw Error('Both an Object and a Map were supplied!');
+  }
+
+  if (map) {
+    map.forEach(callback);
+  } else if (object) {
+    for (var key in object) {
+      callback(object[key], key);
+    }
+  }
+  // if neither was supplied, do nothing.
+}
+
+export default function rollupPluginHypothetical(options) {
+  options = options || {};
+  var files0 = options.files;
+  var files0AsMap = options.filesMap;
+  var allowFallthrough = options.allowFallthrough || false;
+  var allowRelativeExternalFallthrough =
+    options.allowRelativeExternalFallthrough || false;
+  var allowExternalFallthrough =
+    options.allowExternalFallthrough;
+  if (allowExternalFallthrough === undefined) {
+    allowExternalFallthrough = true;
+  }
+  var leaveIdsAlone = options.leaveIdsAlone || false;
+  var impliedExtensions = options.impliedExtensions;
+  if (impliedExtensions === undefined) {
+    impliedExtensions = ['.js', '/'];
+  } else {
+    impliedExtensions = Array.prototype.slice.call(
+      impliedExtensions,
+    );
+  }
+  var cwd = options.cwd;
+  if (cwd !== false) {
+    if (cwd === undefined) {
+      cwd = process.cwd();
+    }
+    cwd = unixStylePath(cwd);
+  }
+
+  var files = new Map();
+  if (leaveIdsAlone) {
+    forEachInObjectOrMap(
+      files0,
+      files0AsMap,
+      function (contents, f) {
+        files.set(f, contents);
+      },
+    );
+  } else {
+    forEachInObjectOrMap(
+      files0,
+      files0AsMap,
+      function (contents, f) {
+        var unixStyleF = unixStylePath(f);
+        var pathIsExternal = isExternal(unixStyleF);
+        var p = path.normalize(unixStyleF);
+        if (pathIsExternal && !isExternal(p)) {
+          throw Error(
+            'Supplied external file path "' +
+              unixStyleF +
+              '" normalized to "' +
+              p +
+              '"!',
+          );
+        }
+        if (!isAbsolute(p) && !pathIsExternal) {
+          p = absolutify(p, cwd);
+        }
+        files.set(p, contents);
+      },
+    );
+  }
+
+  function basicResolve(importee) {
+    if (files.has(importee)) {
+      return importee;
+    } else if (!allowFallthrough) {
+      throw Error(dneMessage(importee));
+    }
+  }
+
+  var resolveId = leaveIdsAlone
+    ? basicResolve
+    : function (importee, importer) {
+        importee = unixStylePath(importee);
+
+        // the entry file is never external.
+        var importeeIsExternal =
+          Boolean(importer) && isExternal(importee);
+
+        var importeeIsRelativeToExternal =
+          importer &&
+          !importeeIsExternal &&
+          isExternal(importer) &&
+          !isAbsolute(importee);
+
+        if (importeeIsExternal) {
+          var normalizedImportee = path.normalize(importee);
+          if (!isExternal(normalizedImportee)) {
+            throw Error(
+              'External import "' +
+                importee +
+                '" normalized to "' +
+                normalizedImportee +
+                '"!',
+            );
+          }
+          importee = normalizedImportee;
+        } else if (importeeIsRelativeToExternal) {
+          var joinedImportee = path.join(
+            path.dirname(importer),
+            importee,
+          );
+          if (!isExternal(joinedImportee)) {
+            throw Error(
+              'Import "' +
+                importee +
+                '" relative to external import "' +
+                importer +
+                '" results in "' +
+                joinedImportee +
+                '"!',
+            );
+          }
+          importee = joinedImportee;
+        } else {
+          if (!isAbsolute(importee) && importer) {
+            importee = path.join(
+              path.dirname(importer),
+              importee,
+            );
+          } else {
+            importee = path.normalize(importee);
+          }
+          if (!isAbsolute(importee)) {
+            importee = absolutify(importee, cwd);
+          }
+        }
+
+        if (files.has(importee)) {
+          return importee;
+        } else if (impliedExtensions) {
+          for (
+            var i = 0, len = impliedExtensions.length;
+            i < len;
+            ++i
+          ) {
+            var extended = importee + impliedExtensions[i];
+            if (files.has(extended)) {
+              return extended;
+            }
+          }
+        }
+        if (
+          importeeIsExternal &&
+          !allowExternalFallthrough
+        ) {
+          throw Error(dneMessage(importee));
+        }
+        if (
+          importeeIsRelativeToExternal &&
+          !allowRelativeExternalFallthrough
+        ) {
+          throw Error(dneMessage(importee));
+        }
+        if (
+          !importeeIsExternal &&
+          !importeeIsRelativeToExternal &&
+          !allowFallthrough
+        ) {
+          throw Error(dneMessage(importee));
+        }
+        if (importeeIsRelativeToExternal) {
+          // we have to resolve this case specially because Rollup won't
+          // treat it as external if we don't.
+          // we have to trust that the user has informed Rollup that this import
+          // is supposed to be external... ugh.
+          return importee;
+        }
+      };
+
+  return {
+    resolveId: resolveId,
+    load: function (id) {
+      if (files.has(id)) {
+        return files.get(id);
+      } else {
+        id = resolveId(id);
+        return id && files.get(id);
+      }
+    },
+  };
+}
+
+function unixStylePath(p) {
+  return p.split('\\').join('/');
+}
+
+function dneMessage(id) {
+  return (
+    'Import failed: `' +
+    id +
+    '` not found. Double check that the file `' +
+    id +
+    '` exists.'
+  );
+}

package/src/v2Runtime/bundle/index.js

@@ -0,0 +1,88 @@
+import { rollup } from './rollup.browser';
+import bubleJSXOnly from './bubleJSXOnly';
+import hypothetical from './hypothetical';
+import { getLibraries } from './getLibraries';
+
+// if HTML parser encounter </script> it stops parsing current script
+// in order to avoid that, </script> should be split into parts.
+const escapeClosingScriptTag = (code) =>
+  code.split('</script>').join('" + "<" + "/script>" + "');
+
+const transformFilesToObject = (files) =>
+  files
+    .filter(
+      (file) => file.name.endsWith('.js'),
+      // TODO: add support for other file types
+      // file.name.endsWith('.svelte') ||
+      // file.name.endsWith('.jsx') ||
+      // file.name.endsWith('.ts') ||
+      // file.name.endsWith('.tsx') ||
+      // file.name.endsWith('.vue')
+    )
+    .reduce((accumulator, file) => {
+      accumulator['./' + file.name] = file.text;
+      return accumulator;
+    }, {});
+
+export const bundle = async (files) => {
+  const libraries = getLibraries(files);
+
+  const outputOptions = {
+    format: 'iife',
+    name: 'bundle',
+    sourcemap: 'inline',
+    globals: libraries,
+  };
+
+  const inputOptions = {
+    input: './index.js',
+    plugins: [
+      hypothetical({
+        files: transformFilesToObject(files),
+        cwd: false,
+      }),
+      bubleJSXOnly({
+        target: {
+          chrome: 71,
+        },
+      }),
+    ],
+    external: Object.keys(libraries),
+    // Suppress Rollup warnings
+    onwarn: () => {},
+  };
+  const rollupBundle = await rollup(inputOptions);
+  const { output } =
+    await rollupBundle.generate(outputOptions);
+
+  // Monkey patch magic-string internals
+  // to support characters outside of the Latin1 range, e.g. Cyrillic.
+  //
+  // Related reading:
+  //  - https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/btoa#Unicode_strings
+  //  - https://github.com/Rich-Harris/magic-string/blob/3466b0230dddc95eb378ed3e0d199e36fbd1f572/src/SourceMap.js#L3
+  //
+  if (output.length !== 1) {
+    throw new Error(
+      'Expected Rollup output length to be 1. This Error is a VizHub bug if it happens.',
+    );
+  }
+  const { code, map } = output[0];
+
+  const escapedCode = escapeClosingScriptTag(code);
+
+  const toString = map.toString.bind(map);
+  map.toString = () =>
+    unescape(encodeURIComponent(toString()));
+
+  // Inspired by https://github.com/rollup/rollup/issues/121
+  const codeWithSourceMap =
+    escapedCode + '\n//# sourceMappingURL=' + map.toUrl();
+
+  return [
+    {
+      name: 'bundle.js',
+      text: codeWithSourceMap,
+    },
+  ];
+};

package/src/v2Runtime/bundle/packageJson.ts

@@ -0,0 +1,49 @@
+import { FilesV2 } from 'entities';
+
+const EMPTY_PKG_JSON = {
+  dependencies: {},
+  vizhub: {},
+  license: 'MIT',
+};
+
+export const packageJSON = (files: FilesV2) => {
+  const packageJsonFile = files.find(
+    (file) => file.name === 'package.json',
+  );
+  if (!packageJsonFile) {
+    return EMPTY_PKG_JSON;
+  }
+  const packageJsonText = packageJsonFile.text;
+
+  try {
+    const pkg = packageJsonText
+      ? JSON.parse(packageJsonText)
+      : EMPTY_PKG_JSON;
+    return pkg;
+  } catch (error) {
+    console.log(error);
+    return EMPTY_PKG_JSON;
+  }
+};
+
+export const dependencies = (files: FilesV2) =>
+  packageJSON(files).dependencies || {};
+
+export const getConfiguredLibraries = (files: FilesV2) => {
+  const vizhubConfig = packageJSON(files).vizhub;
+  return vizhubConfig ? vizhubConfig.libraries : {};
+};
+
+export const dependencySource = (
+  { name, version },
+  libraries,
+) => {
+  const path = libraries[name]
+    ? libraries[name].path || ''
+    : '';
+  // unpkg uses file from unpkg or main field when no file specifid in url
+  return `https://unpkg.com/${name}@${version}${path}`;
+};
+
+export const getLicense = (files) =>
+  packageJSON(files).license || EMPTY_PKG_JSON.license;