RubyGems - importmap-rails - Versions diffs - 0.1.0 - Mend

importmap-rails 0.1.0

Files changed (15) hide show

checksums.yaml +7 -0
data/MIT-LICENSE +20 -0
data/README.md +49 -0
data/Rakefile +19 -0
data/app/assets/javascripts/es-module-shims.js +1 -0
data/app/assets/javascripts/es-module-shims@0.12.2.js +633 -0
data/app/helpers/importmap/importmap_tags_helper.rb +26 -0
data/lib/importmap-rails.rb +5 -0
data/lib/importmap/engine.rb +22 -0
data/lib/importmap/paths.rb +56 -0
data/lib/importmap/version.rb +3 -0
data/lib/install/install.rb +37 -0
data/lib/shim.js +1 -0
data/lib/tasks/importmap_tasks.rake +6 -0
metadata +72 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 58fefa79a892e0017e46e2b1b1f6298e16938ddce9f947e9570bb5e01b6f92ce
+  data.tar.gz: f86494f7134a6bfb2263709e1ee672b295a8211707c46458819707e2252c5315
+SHA512:
+  metadata.gz: c18ac3eea56dd8ede9b26ef69ded67a7ced18a16870a9c666d4dd78c7307883e494961c7ea9fa5425671bfa1ae1e52def91ed1dbb14135ef2c310643bb06cad3
+  data.tar.gz: 949b018e0ad949d018dbec735d265eda311271d2ffaaf389263b28609c63dc6c2da154bd9f9694783008e3bc2aea310239e3a0b2b4632b0185c9159b8f8460a8

data/MIT-LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2021 Basecamp
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,49 @@
+# Importmap for Rails
+[Import maps](https://github.com/WICG/import-maps) let you import JavaScript modules using logical names that map to versioned/digested files – directly from the browser. So you can build modern JavaScript applications using JavaScript libraries made for ESM without the need for transpiling or bundling. Without the need for such preprocessing, you can build advanced Rails applications without Webpack, Yarn, NPM, or any other part of the JavaScript toolchain. All you need is the asset pipeline that's already included in Rails.
+With this approach you'll ship many small JavaScript files instead of one big JavaScript file. Thanks to HTTP2 that no longer carries a material performance penalty during the initial transport, and in fact offers substantial benefits over the long run due to better caching dynamics. Whereas before, any change to any JavaScript file included in your big bundle would invalidate the cache for the the whole bundle, now only the cache for that single file is invalidated.
+There's [native support for import maps in Chrome/Edge 89+](https://caniuse.com/?search=importmap), and [a shim available](https://github.com/guybedford/es-module-shims) for any browser with basic ESM support. So your app will be able to work with all the evergreen browsers.
+## Installation
+1. Add `importmap-rails` to your Gemfile with `gem 'importmap-rails'` (make sure it's included before any gems using it!)
+2. Run `./bin/bundle install`
+3. Run `./bin/rails importmap:install`
+By default, all the files in `app/assets/javascripts` and the three major Rails JavaScript libraries are already mapped. You can add more mappings in `config/initializers/assets.rb`.
+## Usage
+The import map is configured programmatically through the `Rails.application.config.importmap.paths` assignment, which by default is setup in `config/initializers/assets.rb` after running the installer. (Note that since this is a config initializer, you must restart your development server after making any changes.)
+This programmatically configured import map is inlined in the `<head>` of your application layout using `<%= javascript_importmap_tags %>`, which will setup the JSON configuration inside a `<script type="importmap">` tag. After that, the [es-module-shim](https://github.com/guybedford/es-module-shims) is loaded, and then finally the application entrypoint is imported via `<script type="module">import "application"</script>`. That logical entrypoint, `application`, is mapped in the importmap script tag to the file `app/assets/javascripts/application.js`, which is copied and digested by the asset pipeline.
+It's in `app/assets/javascripts/application.js` you setup your application by importing any of the modules that have been defined in the import map. You can use the full ESM functionality of importing any particular export of the modules or everything.
+It makes sense to use logical names that match the package names used by NPM, such that if you later want to start transpiling or bundling your code, you'll not have to change any module imports.
+## Use with Hotwire
+This gem was designed for use with [Hotwire](https://hotwired.dev) in mind. The Hotwire gems, like [turbo-rails](https://github.com/hotwired/turbo-rails) and [stimulus-rails](https://github.com/hotwired/stimulus-rails) (both bundled as [hotwire-rails](https://github.com/hotwired/hotwire-rails)), are automatically configured for use with `importmap-rails`. This means you won't have to manually setup the path mapping in `config/initializers/assets.rb`, and instead can simply refer to the logical names directly in your `app/assets/javascripts/application.js`, like so:
+```js
+import "@hotwired/turbo-rails"
+import "@hotwired/stimulus-autoloader"
+```
+## Expected errors from using the es-module-shim
+While import maps are native in Chrome and Edge, they need a shim in other browsers that'll produce a JavaScript console error like `TypeError: Module specifier, 'application' does not start with "/", "./", or "../".`. This error is normal and does not have any user-facing consequences.
+## License
+Importmap for Rails is released under the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile ADDED Viewed

@@ -0,0 +1,19 @@
+require "bundler/setup"
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+load "rails/tasks/statistics.rake"
+require "bundler/gem_tasks"
+require "rake/testtask"
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+  t.warning = false
+end
+task default: :test

data/app/assets/javascripts/es-module-shims.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ //= require ./es-module-shims@0.12.2.js

data/app/assets/javascripts/es-module-shims@0.12.2.js ADDED Viewed

@@ -0,0 +1,633 @@
+/* ES Module Shims 0.12.2 */
+(function () {
+  const resolvedPromise = Promise.resolve();
+  let baseUrl;
+  function createBlob (source, type = 'text/javascript') {
+    return URL.createObjectURL(new Blob([source], { type }));
+  }
+  const hasDocument = typeof document !== 'undefined';
+  // support browsers without dynamic import support (eg Firefox 6x)
+  let supportsDynamicImport = false;
+  let supportsJsonAssertions = false;
+  let dynamicImport;
+  try {
+    dynamicImport = (0, eval)('u=>import(u)');
+    supportsDynamicImport = true;
+  }
+  catch (e) {
+    if (hasDocument) {
+      let err;
+      self.addEventListener('error', e => err = e.error);
+      dynamicImport = blobUrl => {
+        const topLevelBlobUrl = createBlob(
+          `import*as m from'${blobUrl}';self._esmsi=m;`
+        );
+        const s = document.createElement('script');
+        s.type = 'module';
+        s.src = topLevelBlobUrl;
+        document.head.appendChild(s);
+        return new Promise((resolve, reject) => {
+          s.addEventListener('load', () => {
+            document.head.removeChild(s);
+            if (self._esmsi) {
+              resolve(self._esmsi, baseUrl);
+              self._esmsi = null;
+            }
+            else {
+              reject(err);
+            }
+          });
+        });
+      };
+    }
+  }
+  let supportsImportMeta = false;
+  let supportsImportMaps = false;
+  const featureDetectionPromise = Promise.all([
+    dynamicImport(createBlob('import"data:text/json,{}"assert{type:"json"}')).then(() => supportsJsonAssertions = true, () => {}),
+    dynamicImport(createBlob('import.meta')).then(() => supportsImportMeta = true, () => {}),
+    supportsDynamicImport && hasDocument && new Promise(resolve => {
+      self._$s = v => {
+        document.body.removeChild(iframe);
+        if (v) supportsImportMaps = true;
+        delete self._$s;
+        resolve();
+      };
+      const iframe = document.createElement('iframe');
+      iframe.style.display = 'none';
+      iframe.srcdoc = `<script type=importmap>{"imports":{"x":"data:text/javascript,"}}<${''}/script><script>import('x').then(()=>1,()=>0).then(v=>parent._$s(v))<${''}/script>`, 'text/html';
+      document.body.appendChild(iframe);
+    })
+  ]);
+  if (hasDocument) {
+    const baseEl = document.querySelector('base[href]');
+    if (baseEl)
+      baseUrl = baseEl.href;
+  }
+  if (!baseUrl && typeof location !== 'undefined') {
+    baseUrl = location.href.split('#')[0].split('?')[0];
+    const lastSepIndex = baseUrl.lastIndexOf('/');
+    if (lastSepIndex !== -1)
+      baseUrl = baseUrl.slice(0, lastSepIndex + 1);
+  }
+  const backslashRegEx = /\\/g;
+  function resolveIfNotPlainOrUrl (relUrl, parentUrl) {
+    // strip off any trailing query params or hashes
+    parentUrl = parentUrl && parentUrl.split('#')[0].split('?')[0];
+    if (relUrl.indexOf('\\') !== -1)
+      relUrl = relUrl.replace(backslashRegEx, '/');
+    // protocol-relative
+    if (relUrl[0] === '/' && relUrl[1] === '/') {
+      return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
+    }
+    // relative-url
+    else if (relUrl[0] === '.' && (relUrl[1] === '/' || relUrl[1] === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) ||
+        relUrl.length === 1  && (relUrl += '/')) ||
+        relUrl[0] === '/') {
+      const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1);
+      // Disabled, but these cases will give inconsistent results for deep backtracking
+      //if (parentUrl[parentProtocol.length] !== '/')
+      //  throw new Error('Cannot resolve');
+      // read pathname from parent URL
+      // pathname taken to be part after leading "/"
+      let pathname;
+      if (parentUrl[parentProtocol.length + 1] === '/') {
+        // resolving to a :// so we need to read out the auth and host
+        if (parentProtocol !== 'file:') {
+          pathname = parentUrl.slice(parentProtocol.length + 2);
+          pathname = pathname.slice(pathname.indexOf('/') + 1);
+        }
+        else {
+          pathname = parentUrl.slice(8);
+        }
+      }
+      else {
+        // resolving to :/ so pathname is the /... part
+        pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/'));
+      }
+      if (relUrl[0] === '/')
+        return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+      // join together and split for removal of .. and . segments
+      // looping the string instead of anything fancy for perf reasons
+      // '../../../../../z' resolved to 'x/y' is just 'z'
+      const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
+      const output = [];
+      let segmentIndex = -1;
+      for (let i = 0; i < segmented.length; i++) {
+        // busy reading a segment - only terminate on '/'
+        if (segmentIndex !== -1) {
+          if (segmented[i] === '/') {
+            output.push(segmented.slice(segmentIndex, i + 1));
+            segmentIndex = -1;
+          }
+        }
+        // new segment - check if it is relative
+        else if (segmented[i] === '.') {
+          // ../ segment
+          if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
+            output.pop();
+            i += 2;
+          }
+          // ./ segment
+          else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
+            i += 1;
+          }
+          else {
+            // the start of a new segment as below
+            segmentIndex = i;
+          }
+        }
+        // it is the start of a new segment
+        else {
+          segmentIndex = i;
+        }
+      }
+      // finish reading out the last segment
+      if (segmentIndex !== -1)
+        output.push(segmented.slice(segmentIndex));
+      return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
+    }
+  }
+  /*
+   * Import maps implementation
+   *
+   * To make lookups fast we pre-resolve the entire import map
+   * and then match based on backtracked hash lookups
+   *
+   */
+  function resolveUrl (relUrl, parentUrl) {
+    return resolveIfNotPlainOrUrl(relUrl, parentUrl) || (relUrl.indexOf(':') !== -1 ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
+  }
+  function resolveAndComposePackages (packages, outPackages, baseUrl, parentMap) {
+    for (let p in packages) {
+      const resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
+      let target = packages[p];
+      if (typeof target !== 'string')
+        continue;
+      const mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(target, baseUrl) || target, baseUrl);
+      if (mapped) {
+        outPackages[resolvedLhs] = mapped;
+        continue;
+      }
+      targetWarning(p, packages[p], 'bare specifier did not resolve');
+    }
+  }
+  function resolveAndComposeImportMap (json, baseUrl, parentMap) {
+    const outMap = { imports: Object.assign({}, parentMap.imports), scopes: Object.assign({}, parentMap.scopes) };
+    if (json.imports)
+      resolveAndComposePackages(json.imports, outMap.imports, baseUrl, parentMap);
+    if (json.scopes)
+      for (let s in json.scopes) {
+        const resolvedScope = resolveUrl(s, baseUrl);
+        resolveAndComposePackages(json.scopes[s], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, parentMap);
+      }
+    return outMap;
+  }
+  function getMatch (path, matchObj) {
+    if (matchObj[path])
+      return path;
+    let sepIndex = path.length;
+    do {
+      const segment = path.slice(0, sepIndex + 1);
+      if (segment in matchObj)
+        return segment;
+    } while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1)
+  }
+  function applyPackages (id, packages) {
+    const pkgName = getMatch(id, packages);
+    if (pkgName) {
+      const pkg = packages[pkgName];
+      if (pkg === null) return;
+      if (id.length > pkgName.length && pkg[pkg.length - 1] !== '/')
+        targetWarning(pkgName, pkg, "should have a trailing '/'");
+      else
+        return pkg + id.slice(pkgName.length);
+    }
+  }
+  function targetWarning (match, target, msg) {
+    console.warn("Package target " + msg + ", resolving target '" + target + "' for " + match);
+  }
+  function resolveImportMap (importMap, resolvedOrPlain, parentUrl) {
+    let scopeUrl = parentUrl && getMatch(parentUrl, importMap.scopes);
+    while (scopeUrl) {
+      const packageResolution = applyPackages(resolvedOrPlain, importMap.scopes[scopeUrl]);
+      if (packageResolution)
+        return packageResolution;
+      scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf('/')), importMap.scopes);
+    }
+    return applyPackages(resolvedOrPlain, importMap.imports) || resolvedOrPlain.indexOf(':') !== -1 && resolvedOrPlain;
+  }
+  /* es-module-lexer 0.7.1 */
+  const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(E,g="@"){if(!C)return init.then(()=>parse(E));const I=E.length+1,D=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;D>0&&C.memory.grow(Math.ceil(D/65536));const w=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,w,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const L=[],k=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.ai(),g=C.id(),I=C.ss(),D=C.se();let w;C.ip()&&(w=o(E.slice(-1===g?A-1:A,-1===g?Q+1:Q))),L.push({n:w,s:A,e:Q,ss:I,se:D,d:g,a:B});}for(;C.re();)k.push(E.slice(C.es(),C.ee()));function o(A){try{return (0,eval)(A)}catch{}}return [L,k,!!C.f()]}function Q(A,Q){const B=A.length;let C=0;for(;C<B;){const B=A.charCodeAt(C);Q[C++]=(255&B)<<8|B>>>8;}}function B(A,Q){const B=A.length;let C=0;for(;C<B;)Q[C]=A.charCodeAt(C++);}let C;const init=WebAssembly.compile((E="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","undefined"!=typeof Buffer?Buffer.from(E,"base64"):Uint8Array.from(atob(E),A=>A.charCodeAt(0)))).then(WebAssembly.instantiate).then(({exports:A})=>{C=A;});var E;
+  let id = 0;
+  const registry = {};
+  if (self.ESMS_DEBUG) {
+    self._esmsr = registry;
+  }
+  async function loadAll (load, seen) {
+    if (load.b || seen[load.u])
+      return;
+    seen[load.u] = 1;
+    await load.L;
+    await Promise.all(load.d.map(dep => loadAll(dep, seen)));
+    if (!load.n)
+      load.n = load.d.some(dep => dep.n);
+  }
+  let waitingForImportMapsInterval;
+  let firstTopLevelProcess = true;
+  async function topLevelLoad (url, fetchOpts, source, nativelyLoaded) {
+    // no need to even fetch if we have feature support
+    await featureDetectionPromise;
+    if (waitingForImportMapsInterval > 0) {
+      clearTimeout(waitingForImportMapsInterval);
+      waitingForImportMapsInterval = 0;
+    }
+    if (firstTopLevelProcess) {
+      firstTopLevelProcess = false;
+      processScripts();
+    }
+    await importMapPromise;
+    // early analysis opt-out
+    if (nativelyLoaded && supportsDynamicImport && supportsImportMeta && supportsImportMaps && !importMapSrcOrLazy) {
+      // dont reexec inline for polyfills -> just return null
+      return source && nativelyLoaded ? null : dynamicImport(source ? createBlob(source) : url);
+    }
+    await init;
+    const load = getOrCreateLoad(url, fetchOpts, source);
+    const seen = {};
+    await loadAll(load, seen);
+    lastLoad = undefined;
+    resolveDeps(load, seen);
+    if (source && !nativelyLoaded && !shimMode && !load.n) {
+      const module = dynamicImport(createBlob(source));
+      if (shouldRevokeBlobURLs) revokeObjectURLs(Object.keys(seen));
+      return module;
+    }
+    const module = await dynamicImport(load.b);
+    // if the top-level load is a shell, run its update function
+    if (load.s) {
+      (await dynamicImport(load.s)).u$_(module);
+    }
+    if (shouldRevokeBlobURLs) revokeObjectURLs(Object.keys(seen));
+    return module;
+  }
+  function revokeObjectURLs(registryKeys) {
+    let batch = 0;
+    const keysLength = registryKeys.length;
+    const schedule = self.requestIdleCallback ? self.requestIdleCallback : self.requestAnimationFrame;
+    schedule(cleanup);
+    function cleanup() {
+      const batchStartIndex = batch * 100;
+      if (batchStartIndex > keysLength) return
+      for (const key of registryKeys.slice(batchStartIndex, batchStartIndex + 100)) {
+        const load = registry[key];
+        if (load) URL.revokeObjectURL(load.b);
+      }
+      batch++;
+      schedule(cleanup);
+    }
+  }
+  async function importShim (id, parentUrl = baseUrl, _assertion) {
+    await featureDetectionPromise;
+    // Make sure all the "in-flight" import maps are loaded and applied.
+    await importMapPromise;
+    return topLevelLoad(resolve(id, parentUrl).r || throwUnresolved(id, parentUrl), { credentials: 'same-origin' });
+  }
+  self.importShim = importShim;
+  const meta = {};
+  const edge = navigator.userAgent.match(/Edge\/\d\d\.\d+$/);
+  async function importMetaResolve (id, parentUrl = this.url) {
+    await importMapPromise;
+    return resolve(id, `${parentUrl}`).r || throwUnresolved(id, parentUrl);
+  }
+  self._esmsm = meta;
+  const esmsInitOptions = self.esmsInitOptions || {};
+  delete self.esmsInitOptions;
+  let shimMode = typeof esmsInitOptions.shimMode === 'boolean' ? esmsInitOptions.shimMode : !!esmsInitOptions.fetch || !!document.querySelector('script[type="module-shim"],script[type="importmap-shim"]');
+  const fetchHook = esmsInitOptions.fetch || ((url, opts) => fetch(url, opts));
+  const skip = esmsInitOptions.skip || /^https?:\/\/(cdn\.skypack\.dev|jspm\.dev)\//;
+  const onerror = esmsInitOptions.onerror || ((e) => { throw e; });
+  const shouldRevokeBlobURLs = esmsInitOptions.revokeBlobURLs;
+  function urlJsString (url) {
+    return `'${url.replace(/'/g, "\\'")}'`;
+  }
+  let lastLoad;
+  function resolveDeps (load, seen) {
+    if (load.b || !seen[load.u])
+      return;
+    seen[load.u] = 0;
+    for (const dep of load.d)
+      resolveDeps(dep, seen);
+    // use direct native execution when possible
+    // load.n is therefore conservative
+    if (!shimMode && !load.n) {
+      load.b = lastLoad = load.u;
+      load.S = undefined;
+      return;
+    }
+    const [imports] = load.a;
+    // "execution"
+    const source = load.S;
+    // edge doesnt execute sibling in order, so we fix this up by ensuring all previous executions are explicit dependencies
+    let resolvedSource = edge && lastLoad ? `import '${lastLoad}';` : '';
+    if (!imports.length) {
+      resolvedSource += source;
+    }
+    else {
+      // once all deps have loaded we can inline the dependency resolution blobs
+      // and define this blob
+      let lastIndex = 0, depIndex = 0;
+      for (const { s: start, se: end, d: dynamicImportIndex } of imports) {
+        // dependency source replacements
+        if (dynamicImportIndex === -1) {
+          const depLoad = load.d[depIndex++];
+          let blobUrl = depLoad.b;
+          if (!blobUrl) {
+            // circular shell creation
+            if (!(blobUrl = depLoad.s)) {
+              blobUrl = depLoad.s = createBlob(`export function u$_(m){${
+                depLoad.a[1].map(
+                  name => name === 'default' ? `$_default=m.default` : `${name}=m.${name}`
+                ).join(',')
+              }}${
+                depLoad.a[1].map(name =>
+                  name === 'default' ? `let $_default;export{$_default as default}` : `export let ${name}`
+                ).join(';')
+              }\n//# sourceURL=${depLoad.r}?cycle`);
+            }
+          }
+          // circular shell execution
+          else if (depLoad.s) {
+            resolvedSource += `${source.slice(lastIndex, start - 1)}/*${source.slice(start - 1, end)}*/${urlJsString(blobUrl)};import*as m$_${depIndex} from'${depLoad.b}';import{u$_ as u$_${depIndex}}from'${depLoad.s}';u$_${depIndex}(m$_${depIndex})`;
+            lastIndex = end;
+            depLoad.s = undefined;
+            continue;
+          }
+          resolvedSource += `${source.slice(lastIndex, start - 1)}/*${source.slice(start - 1, end)}*/${urlJsString(blobUrl)}`;
+          lastIndex = end;
+        }
+        // import.meta
+        else if (dynamicImportIndex === -2) {
+          meta[load.r] = { url: load.r, resolve: importMetaResolve };
+          resolvedSource += `${source.slice(lastIndex, start)}self._esmsm[${urlJsString(load.r)}]`;
+          lastIndex = end;
+        }
+        // dynamic import
+        else {
+          resolvedSource += `${source.slice(lastIndex, dynamicImportIndex + 6)}Shim(${source.slice(start, end)}, ${load.r && urlJsString(load.r)}`;
+          lastIndex = end;
+        }
+      }
+      resolvedSource += source.slice(lastIndex);
+    }
+    resolvedSource = resolvedSource.replace(/\/\/# sourceMappingURL=(.*)\s*$/, (match, url) => {
+      return match.replace(url, new URL(url, load.r));
+    });
+    let hasSourceURL = false;
+    resolvedSource = resolvedSource.replace(/\/\/# sourceURL=(.*)\s*$/, (match, url) => {
+      hasSourceURL = true;
+      return match.replace(url, new URL(url, load.r));
+    });
+    if (!hasSourceURL) {
+      resolvedSource += '\n//# sourceURL=' + load.r;
+    }
+    load.b = lastLoad = createBlob(resolvedSource);
+    load.S = undefined;
+  }
+  const jsContentType = /^(text|application)\/(x-)?javascript(;|$)/;
+  const jsonContentType = /^application\/json(;|$)/;
+  const cssContentType = /^text\/css(;|$)/;
+  const wasmContentType = /^application\/wasm(;|$)/;
+  const fetchOptsMap = new Map();
+  function getOrCreateLoad (url, fetchOpts, source) {
+    let load = registry[url];
+    if (load)
+      return load;
+    load = registry[url] = {
+      // url
+      u: url,
+      // response url
+      r: undefined,
+      // fetchPromise
+      f: undefined,
+      // source
+      S: undefined,
+      // linkPromise
+      L: undefined,
+      // analysis
+      a: undefined,
+      // deps
+      d: undefined,
+      // blobUrl
+      b: undefined,
+      // shellUrl
+      s: undefined,
+      // needsShim
+      n: false
+    };
+    load.f = (async () => {
+      if (!source) {
+        // preload fetch options override fetch options (race)
+        const res = await fetchHook(url, fetchOptsMap.get(url) || fetchOpts);
+        if (!res.ok)
+          throw new Error(`${res.status} ${res.statusText} ${res.url}`);
+        load.r = res.url;
+        const contentType = res.headers.get('content-type');
+        if (jsContentType.test(contentType))
+          source = await res.text();
+        else if (jsonContentType.test(contentType))
+          source = `export default ${await res.text()}`;
+        else if (cssContentType.test(contentType))
+          throw new Error('CSS modules not yet supported');
+        else if (wasmContentType.test(contentType))
+          throw new Error('WASM modules not yet supported');
+        else
+          throw new Error(`Unknown Content-Type "${contentType}"`);
+      }
+      try {
+        load.a = parse(source, load.u);
+      }
+      catch (e) {
+        console.warn(e);
+        load.a = [[], []];
+      }
+      load.S = source;
+      return load;
+    })();
+    load.L = load.f.then(async () => {
+      let childFetchOpts = fetchOpts;
+      load.d = await Promise.all(load.a[0].map(({ n, d, a }) => {
+        if (d >= 0 && !supportsDynamicImport ||
+            d === 2 && (!supportsImportMeta || source.slice(end, end + 8) === '.resolve') ||
+            a && !supportsJsonAssertions)
+          load.n = true;
+        if (!n) return;
+        const { r, m } = resolve(n, load.r || load.u);
+        if (m && (!supportsImportMaps || importMapSrcOrLazy))
+          load.n = true;
+        if (d !== -1) return;
+        if (!r)
+          throwUnresolved(n, load.r || load.u);
+        if (skip.test(r)) return { b: r };
+        if (childFetchOpts.integrity)
+          childFetchOpts = Object.assign({}, childFetchOpts, { integrity: undefined });
+        return getOrCreateLoad(r, childFetchOpts).f;
+      }).filter(l => l));
+    });
+    return load;
+  }
+  let importMap = { imports: {}, scopes: {} };
+  let importMapSrcOrLazy = false;
+  let importMapPromise = resolvedPromise;
+  if (hasDocument) {
+    processScripts();
+    waitingForImportMapsInterval = setInterval(processScripts, 20);
+  }
+  async function processScripts () {
+    if (waitingForImportMapsInterval > 0 && document.readyState !== 'loading') {
+      clearTimeout(waitingForImportMapsInterval);
+      waitingForImportMapsInterval = 0;
+    }
+    for (const link of document.querySelectorAll('link[rel="modulepreload"]'))
+      processPreload(link);
+    for (const script of document.querySelectorAll('script[type="module-shim"],script[type="importmap-shim"],script[type="module"],script[type="importmap"]'))
+      await processScript(script);
+  }
+  new MutationObserver(mutations => {
+    for (const mutation of mutations) {
+      if (mutation.type !== 'childList') continue;
+      for (const node of mutation.addedNodes) {
+        if (node.tagName === 'SCRIPT' && node.type)
+          processScript(node, !firstTopLevelProcess);
+        else if (node.tagName === 'LINK' && node.rel === 'modulepreload')
+          processPreload(node);
+        else if (node.querySelectorAll) {
+          for (const script of node.querySelectorAll('script[type="module-shim"],script[type="importmap-shim"],script[type="module"],script[type="importmap"]')) {
+            processScript(script, !firstTopLevelProcess);
+          }
+          for (const link of node.querySelectorAll('link[rel=modulepreload]')) {
+            processPreload(link);
+          }
+        }
+      }
+    }
+  }).observe(document, { childList: true, subtree: true });
+  function getFetchOpts (script) {
+    const fetchOpts = {};
+    if (script.integrity)
+      fetchOpts.integrity = script.integrity;
+    if (script.referrerpolicy)
+      fetchOpts.referrerPolicy = script.referrerpolicy;
+    if (script.crossorigin === 'use-credentials')
+      fetchOpts.credentials = 'include';
+    else if (script.crossorigin === 'anonymous')
+      fetchOpts.credentials = 'omit';
+    else
+      fetchOpts.credentials = 'same-origin';
+    return fetchOpts;
+  }
+  async function processScript (script, dynamic) {
+    if (script.ep) // ep marker = script processed
+      return;
+    const shim = script.type.endsWith('-shim');
+    if (shim) shimMode = true;
+    const type = shim ? script.type.slice(0, -5) : script.type;
+    if (!shim && shimMode || script.getAttribute('noshim') !== null)
+      return;
+    // empty inline scripts sometimes show before domready
+    if (!script.src && !script.innerHTML)
+      return;
+    script.ep = true;
+    if (type === 'module') {
+      await topLevelLoad(script.src || `${baseUrl}?${id++}`, getFetchOpts(script), !script.src && script.innerHTML, !shim).catch(onerror);
+    }
+    else if (type === 'importmap') {
+      importMapPromise = importMapPromise.then(async () => {
+        if (script.src || dynamic)
+          importMapSrcOrLazy = true;
+        importMap = resolveAndComposeImportMap(script.src ? await (await fetchHook(script.src)).json() : JSON.parse(script.innerHTML), script.src || baseUrl, importMap);
+      });
+    }
+  }
+  function processPreload (link) {
+    if (link.ep) // ep marker = processed
+      return;
+    link.ep = true;
+    // prepopulate the load record
+    const fetchOpts = getFetchOpts(link);
+    // save preloaded fetch options for later load
+    fetchOptsMap.set(link.href, fetchOpts);
+    fetch(link.href, fetchOpts);
+  }
+  function resolve (id, parentUrl) {
+    const urlResolved = resolveIfNotPlainOrUrl(id, parentUrl);
+    const resolved = resolveImportMap(importMap, urlResolved || id, parentUrl);
+    return { r: resolved, m: urlResolved !== resolved };
+  }
+  function throwUnresolved (id, parentUrl) {
+    throw Error("Unable to resolve specifier '" + id + (parentUrl ? "' from " + parentUrl : "'"));
+  }
+}());

data/app/helpers/importmap/importmap_tags_helper.rb ADDED Viewed

@@ -0,0 +1,26 @@
+module Importmap::ImportmapTagsHelper
+  # Setup all script tags needed to use an importmap-powered entrypoint (which defaults to application.js)
+  def javascript_importmap_tags(entry_point = "application")
+    safe_join [
+      javascript_inline_importmap_tag,
+      javascript_importmap_shim_tag,
+      javascript_import_module_tag(entry_point)
+    ], "\n"
+  end
+  # Generate an inline importmap tag using the passed `importmap_paths` object to produce the JSON map.
+  # By default, `Rails.application.config.importmap.paths` is used for this object,
+  def javascript_inline_importmap_tag(importmap_paths = Rails.application.config.importmap.paths)
+    tag.script(importmap_paths.to_json(self).html_safe, type: "importmap")
+  end
+  # Include the es-module-shim needed to make importmaps work in browsers without native support (like Firefox + Safari).
+  def javascript_importmap_shim_tag
+    javascript_include_tag "es-module-shims", async: true
+  end
+  # Import a named JavaScript module using a script-module tag.
+  def javascript_import_module_tag(module_name)
+    tag.script %(import "#{module_name}").html_safe, type: "module"
+  end
+end

data/lib/importmap-rails.rb ADDED Viewed

@@ -0,0 +1,5 @@
+module Importmap
+end
+require "importmap/version"
+require "importmap/engine"

data/lib/importmap/engine.rb ADDED Viewed

@@ -0,0 +1,22 @@
+require "importmap/paths"
+module Importmap
+  class Engine < ::Rails::Engine
+    config.importmap = ActiveSupport::OrderedOptions.new
+    config.importmap.paths = Importmap::Paths.new.tap { |paths| paths.assets_in "app/assets/javascripts" }
+    config.autoload_once_paths = %W( #{root}/app/helpers )
+    initializer "importmap.assets" do
+      if Rails.application.config.respond_to?(:assets)
+        Rails.application.config.assets.precompile += %w( es-module-shims )
+      end
+    end
+    initializer "importmap.helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper Importmap::ImportmapTagsHelper
+      end
+    end
+  end
+end

data/lib/importmap/paths.rb ADDED Viewed

@@ -0,0 +1,56 @@
+class Importmap::Paths
+  attr_reader :files, :directories
+  def initialize
+    @files = {}
+    @directories = {}
+  end
+  def asset(name, path: nil)
+    @files[name] = path || "#{name}.js"
+  end
+  def assets_in(path, append_base_path: false)
+    @directories[path] = append_base_path
+  end
+  def to_json(resolver)
+    { "imports" => map_to_asset_paths(resolver) }.to_json
+  end
+  private
+    def map_to_asset_paths(resolver)
+      expanded_files_and_directories.transform_values { |path| resolver.asset_path(path) }
+    end
+    def expanded_files_and_directories
+      @files.dup.tap { |expanded| expand_directories_into expanded }
+    end
+    def expand_directories_into(paths)
+      @directories.each do |(path, append_base_path)|
+        if (absolute_path = absolute_root_of(path)).exist?
+          find_javascript_files_in_tree(absolute_path).each do |filename|
+            module_filename = filename.relative_path_from(absolute_path)
+            module_name     = module_name_from(module_filename)
+            module_path     = append_base_path ? absolute_path.basename.join(module_filename).to_s : module_filename.to_s
+            paths[module_name] = module_path
+          end
+        end
+      end
+    end
+    # Strip off the extension, /index, or any versioning data for an absolute module name.
+    def module_name_from(filename)
+      filename.to_s.remove(filename.extname).remove("/index").split("@").first
+    end
+    def find_javascript_files_in_tree(path)
+      Dir[path.join("**/*.js{,m}")].collect { |file| Pathname.new(file) }.select(&:file?)
+    end
+    def absolute_root_of(path)
+      (pathname = Pathname.new(path)).absolute? ? pathname : Rails.root.join(path)
+    end
+end

data/lib/importmap/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Importmap
+  VERSION = "0.1.0"
+end

data/lib/install/install.rb ADDED Viewed

@@ -0,0 +1,37 @@
+APPLICATION_LAYOUT_PATH = Rails.root.join("app/views/layouts/application.html.erb")
+if APPLICATION_LAYOUT_PATH.exist?
+  say "Add Importmap include tags in application layout"
+  insert_into_file APPLICATION_LAYOUT_PATH.to_s, "\n    <%= javascript_importmap_tags %>", before: /\s*<\/head>/
+else
+  say "Default application.html.erb is missing!", :red
+  say "        Add <%= javascript_importmap_tags %> within the <head> tag in your custom layout."
+end
+say "Create application.js module as entrypoint"
+create_file Rails.root.join("app/assets/javascripts/application.js") do <<-JS
+// import "@rails/actioncable"
+// import "@rails/actiontext"
+// import "@rails/activestorage"
+JS
+end
+say "Ensure JavaScript files are in the asset pipeline manifest"
+append_to_file Rails.root.join("app/assets/config/manifest.js"), %(//= link_tree ../javascripts)
+say "Configure importmap paths in config/initializers/assets.rb"
+append_to_file Rails.root.join("config/initializers/assets.rb") do <<-RUBY
+# Configure importmap paths in addition to having all files in app/assets/javascripts mapped.
+Rails.application.config.importmap.paths do |paths|
+  # Match libraries with their NPM package names for possibility of easy later porting.
+  # Ensure that libraries listed in the path have been linked in the asset pipeline manifest or precompiled.
+  paths.asset "@rails/actioncable", path: "actioncable.esm.js"
+  paths.asset "@rails/actiontext", path: "actiontext.js"
+  paths.asset "@rails/activestorage", path: "activestorage.esm.js"
+  # Make all files in directory available as my_channel => channels/my_channel-$digest.js
+  # paths.assets_in "lib/assets/javascripts/channels", append_base_path: true
+end
+RUBY
+end

data/lib/shim.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ import "es-module-shim"

data/lib/tasks/importmap_tasks.rake ADDED Viewed

@@ -0,0 +1,6 @@
+namespace :importmap do
+  desc "Setup Importmap for the app"
+  task :install do
+    system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/install.rb",  __dir__)}"
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: importmap-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Heinemeier Hansson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description:
+email: david@loudthinking.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/es-module-shims.js
+- app/assets/javascripts/es-module-shims@0.12.2.js
+- app/helpers/importmap/importmap_tags_helper.rb
+- lib/importmap-rails.rb
+- lib/importmap/engine.rb
+- lib/importmap/paths.rb
+- lib/importmap/version.rb
+- lib/install/install.rb
+- lib/shim.js
+- lib/tasks/importmap_tasks.rake
+homepage: https://github.com/rails/importmap-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rails/importmap-rails
+  source_code_uri: https://github.com/rails/importmap-rails
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Use ESM with importmap to manage modern JavaScript in Rails without transpiling
+  or bundling.
+test_files: []