proscenium 0.5.0-x86_64-linux → 0.6.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c8a9ad032805dfed6ba21f4523f94599334ba7adfec880d3e1dab1c3ba74836
-  data.tar.gz: 2d8b98a5d503f8104c00c26dd90d775f9ea804cbf969d2d3182aea50d1805d60
+  metadata.gz: 24989d48e852d009d61ca3407eb5c0eca0f56f9cbcd8411379deb9d3388158a7
+  data.tar.gz: 79f44652dda8cf067b5f1df01cb3a7abb408a84f340b6910b15f933109fa6658
 SHA512:
-  metadata.gz: a529ec0ebcc1b3306a15a2ed889dd8ce174892e3267c5040fed3b24701cf201809979bd7b49f90803624a418e7b37a376bcbeaa66c45390f9d3c126c37730757
-  data.tar.gz: d14bedffc25862f0a8ce20a476b1fbdfb524d19cd916031b002153af2962294eaae1a6ed00616119242d217f0ea70fad1db891d98b78e03244945259e7d619e8
+  metadata.gz: 765d537f7c14394e7aed909394161669fc3a3880b6285f5a0a7b3c42c5554b2835522a159cea97d9d241eea509035e334345547ae0c942df92cd9f15d56659d0
+  data.tar.gz: 3d12dd75c35affe07c46ad369360fd66104799dce799ee4075931179347f7073d29c34ef3adaa3e616f75c3b14b6df5d756ef9a796fa1159936cd2cf7ec15e99

data/README.md

@@ -117,7 +117,10 @@ as you could end up swallowing everything, resulting in a very large file.
 ## Import Map
 
 Import map for both JS and CSS is supported out of the box, and works with no regard to the browser
-version being used. Just create `config/import_map.json`:
+version being used. This is because the import map is parsed and resolved by Proscenium on the
+server.
+
+Just create `config/import_map.json`:
 
 ```json
 {
@@ -157,6 +160,18 @@ env => ({
 })
 ```
 
+### Aliasing
+
+You can also use the import map to define aliases:
+
+```json
+{
+  "imports": {
+    "react": "preact/compact",
+  }
+}
+```
+
 ## Side Loading
 
 Proscenium has built in support for automatically side loading JS and CSS with your views and

data/lib/proscenium/compilers/esbuild/css/postcss.js

@@ -1,12 +1,12 @@
 import { expandGlob } from 'std/fs/mod.ts'
-import postcss, { CssSyntaxError } from 'postcss'
+import postcss from 'postcss'
 
 export default async (root, path) => {
   let tmpFile
   let contents
 
   const mixinFiles = []
-  for await (const file of expandGlob(`lib/**/*.mixin.css`, { root })) {
+  for await (const file of expandGlob('lib/**/*.mixin.css', { root, globstar: true })) {
     mixinFiles.push(file.path)
   }
 

data/lib/proscenium/compilers/esbuild/import_map/parser.js

@@ -0,0 +1,178 @@
+import { tryURLParse, tryURLLikeSpecifierParse } from './utils.js'
+
+/**
+ * @param {ImportMap} input
+ * @param {URL} baseURL
+ * @returns {ParsedImportMap}
+ */
+export function parse(input, baseURL) {
+  if (!isJSONObject(input)) {
+    throw new TypeError('Import map JSON must be an object.')
+  }
+
+  if (!(baseURL instanceof URL)) {
+    throw new TypeError('Missing base URL or base URL is not a URL')
+  }
+
+  let sortedAndNormalizedImports = {}
+  if ('imports' in input) {
+    if (!input.imports || !isJSONObject(input.imports)) {
+      throw new TypeError("Import map's imports value must be an object.")
+    }
+    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(input.imports, baseURL)
+  }
+
+  let sortedAndNormalizedScopes = {}
+  if ('scopes' in input) {
+    if (!input.scopes || !isJSONObject(input.scopes)) {
+      throw new TypeError("Import map's scopes value must be an object.")
+    }
+    sortedAndNormalizedScopes = sortAndNormalizeScopes(input.scopes, baseURL)
+  }
+
+  const badTopLevelKeys = new Set(Object.keys(input))
+  badTopLevelKeys.delete('imports')
+  badTopLevelKeys.delete('scopes')
+
+  for (const badKey of badTopLevelKeys) {
+    throw new TypeError(
+      `Invalid top-level key "${badKey}". Only "imports" and "scopes" can be present.`
+    )
+  }
+
+  // Always have these two keys, and exactly these two keys, in the result.
+  return {
+    imports: sortedAndNormalizedImports,
+    scopes: sortedAndNormalizedScopes
+  }
+}
+
+/**
+ * @param {string} input
+ * @param {URL} baseURL
+ * @returns {ParsedImportMap}
+ */
+export function parseFromString(input, baseURL) {
+  const importMap = JSON.parse(input)
+  return parse(importMap, baseURL)
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ */
+function codeUnitCompare(a, b) {
+  if (a > b) {
+    return 1
+  }
+
+  if (b > a) {
+    return -1
+  }
+
+  throw new Error('This should never be reached because this is only used on JSON object keys')
+}
+
+/**
+ * @param {string} specifierKey
+ * @param {URL} baseURL
+ * @returns {string | undefined}
+ */
+function normalizeSpecifierKey(specifierKey, baseURL) {
+  // Ignore attempts to use the empty string as a specifier key
+  if (specifierKey === '') {
+    throw new TypeError(`Invalid empty string specifier key.`)
+  }
+
+  const url = tryURLLikeSpecifierParse(specifierKey, baseURL)
+  if (url) return url.href
+
+  return specifierKey
+}
+
+/**
+ * @param {SpecifierMap} obj
+ * @param {URL} baseURL
+ * @returns {ParsedSpecifierMap}
+ */
+function sortAndNormalizeSpecifierMap(obj, baseURL) {
+  if (!isJSONObject(obj)) {
+    throw new TypeError('Expect map to be a JSON object.')
+  }
+
+  const normalized = {}
+
+  for (const [specifierKey, value] of Object.entries(obj)) {
+    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL)
+    if (!normalizedSpecifierKey) continue
+
+    if (typeof value !== 'string') {
+      throw new TypeError(
+        `Invalid address ${JSON.stringify(value)} for the specifier key "${specifierKey}". ` +
+          `Addresses must be strings.`
+      )
+    }
+
+    const addressURL = tryURLLikeSpecifierParse(value, baseURL)
+    if (!addressURL) {
+      // Support aliases.
+      // console.warn(`Invalid address "${value}" for the specifier key "${specifierKey}".`)
+      normalized[normalizedSpecifierKey] = value
+      continue
+    }
+
+    if (specifierKey.endsWith('/') && !addressURL.href.endsWith('/')) {
+      throw new TypeError(
+        `Invalid address "${addressURL.href}" for package specifier key "${specifierKey}". ` +
+          `Package addresses must end with "/".`
+      )
+    }
+
+    normalized[normalizedSpecifierKey] = addressURL
+  }
+
+  const sortedAndNormalized = {}
+  const sortedKeys = Object.keys(normalized).sort((a, b) => codeUnitCompare(b, a))
+  for (const key of sortedKeys) {
+    sortedAndNormalized[key] = normalized[key]
+  }
+
+  return sortedAndNormalized
+}
+
+/**
+ * @param {ScopesMap} obj
+ * @param {URL} baseURL
+ */
+function sortAndNormalizeScopes(obj, baseURL) {
+  const normalized = {}
+  for (const [scopePrefix, potentialSpecifierMap] of Object.entries(obj)) {
+    if (!isJSONObject(potentialSpecifierMap)) {
+      throw new TypeError(`The value for the "${scopePrefix}" scope prefix must be an object.`)
+    }
+
+    const scopePrefixURL = tryURLParse(scopePrefix, baseURL)
+    if (!scopePrefixURL) {
+      throw new TypeError(`Invalid scope "${scopePrefix}" (parsed against base URL "${baseURL}").`)
+    }
+
+    const normalizedScopePrefix = scopePrefixURL.href
+    normalized[normalizedScopePrefix] = sortAndNormalizeSpecifierMap(potentialSpecifierMap, baseURL)
+  }
+
+  const sortedAndNormalized = {}
+  const sortedKeys = Object.keys(normalized).sort((a, b) => codeUnitCompare(b, a))
+  for (const key of sortedKeys) {
+    sortedAndNormalized[key] = normalized[key]
+  }
+
+  return sortedAndNormalized
+}
+
+/**
+ * @param {*} value
+ * @returns {value is object}
+ */
+function isJSONObject(value) {
+  return typeof value === 'object' && value != null && !Array.isArray(value)
+}

data/lib/proscenium/compilers/esbuild/{import_map.js → import_map/read.js}

@@ -1,5 +1,10 @@
+//
+// Taken almost verbatim from https://github.com/open-wc/open-wc/tree/master/packages/import-maps-resolve
+// Slightly modified to support aliases.
+//
+
 import { join } from 'std/path/mod.ts'
-import { parseFromString } from 'import-maps/resolve'
+import { parseFromString } from './parser.js'
 
 const baseURL = new URL('file://')
 
@@ -16,7 +21,7 @@ class ImportMapError extends Error {
   }
 }
 
-export function readImportMap(fileName, rootDir) {
+export default function (fileName, rootDir) {
   let importMap
 
   if (fileName) {

data/lib/proscenium/compilers/esbuild/import_map/resolver.js

@@ -0,0 +1,95 @@
+import { tryURLLikeSpecifierParse, tryURLParse } from './utils.js'
+
+/**
+ * @param {string} specifier
+ * @param {ParsedImportMap} parsedImportMap
+ * @param {URL} scriptURL
+ * @returns {{ resolvedImport: URL | null, matched: boolean }}
+ */
+export default function (specifier, parsedImportMap, scriptURL) {
+  const asURL = tryURLLikeSpecifierParse(specifier, scriptURL)
+  const normalizedSpecifier = asURL ? asURL.href : specifier
+  const scriptURLString = scriptURL.href
+
+  for (const [scopePrefix, scopeImports] of Object.entries(parsedImportMap.scopes || {})) {
+    if (
+      scopePrefix === scriptURLString ||
+      (scopePrefix.endsWith('/') && scriptURLString.startsWith(scopePrefix))
+    ) {
+      const scopeImportsMatch = resolveImportsMatch(normalizedSpecifier, scopeImports)
+
+      if (scopeImportsMatch) {
+        return { resolvedImport: scopeImportsMatch, matched: true }
+      }
+    }
+  }
+
+  const topLevelImportsMatch = resolveImportsMatch(
+    normalizedSpecifier,
+    parsedImportMap.imports || {}
+  )
+
+  if (topLevelImportsMatch) {
+    return { resolvedImport: topLevelImportsMatch, matched: true }
+  }
+
+  // The specifier was able to be turned into a URL, but wasn't remapped into anything.
+  if (asURL) {
+    return { resolvedImport: asURL, matched: false }
+  }
+
+  return { resolvedImport: null, matched: false }
+}
+
+/**
+ * @param {string} normalizedSpecifier
+ * @param {ParsedSpecifierMap} specifierMap
+ */
+function resolveImportsMatch(normalizedSpecifier, specifierMap) {
+  for (const [specifierKey, resolutionResult] of Object.entries(specifierMap)) {
+    // Exact-match case
+    if (specifierKey === normalizedSpecifier) {
+      if (!resolutionResult) {
+        throw new TypeError(`Blocked by a null entry for "${specifierKey}"`)
+      }
+
+      if (!(resolutionResult instanceof URL)) {
+        // Support aliases.
+        // throw new TypeError(`Expected ${resolutionResult} to be a URL.`)
+      }
+
+      return resolutionResult
+    }
+
+    // Package prefix-match case
+    if (specifierKey.endsWith('/') && normalizedSpecifier.startsWith(specifierKey)) {
+      if (!resolutionResult) {
+        throw new TypeError(`Blocked by a null entry for "${specifierKey}"`)
+      }
+
+      if (!(resolutionResult instanceof URL)) {
+        throw new TypeError(`Expected ${resolutionResult} to be a URL.`)
+      }
+
+      const afterPrefix = normalizedSpecifier.substring(specifierKey.length)
+
+      // Enforced by parsing
+      if (!resolutionResult.href.endsWith('/')) {
+        throw new TypeError(`Expected ${resolutionResult.href} to end with a '/'.`)
+      }
+
+      const url = tryURLParse(afterPrefix, resolutionResult)
+      if (!url) {
+        throw new TypeError(`Failed to resolve prefix-match relative URL for "${specifierKey}"`)
+      }
+
+      if (!(url instanceof URL)) {
+        throw new TypeError(`Expected ${url} to be a URL.`)
+      }
+
+      return url
+    }
+  }
+
+  return undefined
+}

data/lib/proscenium/compilers/esbuild/import_map/utils.js

@@ -0,0 +1,25 @@
+/**
+ * @param {string} string
+ * @param {URL} [baseURL]
+ * @returns {URL | undefined}
+ */
+export function tryURLParse(string, baseURL) {
+  try {
+    return new URL(string, baseURL)
+  } catch (e) {
+    return undefined
+  }
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL} baseURL
+ * @returns {URL | undefined}
+ */
+export function tryURLLikeSpecifierParse(specifier, baseURL) {
+  if (specifier.startsWith('/') || specifier.startsWith('./') || specifier.startsWith('../')) {
+    return tryURLParse(specifier, baseURL)
+  }
+
+  return tryURLParse(specifier)
+}

data/lib/proscenium/compilers/esbuild/resolve_plugin.js

@@ -1,8 +1,9 @@
 import { join, resolve } from 'std/path/mod.ts'
-import { resolve as resolveFromImportMap } from 'import-maps/resolve'
+import resolveFromImportMap from './import_map/resolver.js'
 import { cache } from 'cache'
 
 import setup from './setup_plugin.js'
+import { isBareModule } from '../../utils.js'
 
 const importKinds = ['import-statement', 'dynamic-import', 'require-call', 'import-rule']
 
@@ -108,16 +109,21 @@ export default setup('resolve', (build, options) => {
       }
 
       const { matched, resolvedImport } = resolveFromImportMap(params.path, importMap, baseURL)
+      // console.log({ importMap, matched, resolvedImport })
 
       if (matched) {
-        if (resolvedImport.protocol === 'file:') {
-          params.path = resolvedImport.pathname
-        } else {
-          if (params.importer.endsWith('.css')) {
-            return { path: resolvedImport.href, external: true }
+        if (resolvedImport instanceof URL) {
+          if (resolvedImport.protocol === 'file:') {
+            params.path = resolvedImport.pathname
+          } else {
+            if (params.importer.endsWith('.css')) {
+              return { path: resolvedImport.href, external: true }
+            }
+
+            return { path: `/url:${encodeURIComponent(resolvedImport.href)}`, external: true }
           }
-
-          return { path: `/url:${encodeURIComponent(resolvedImport.href)}`, external: true }
+        } else {
+          result.path = resolvedImport
         }
       }
     }
@@ -199,7 +205,3 @@ export default setup('resolve', (build, options) => {
     return result
   }
 })
-
-function isBareModule(mod) {
-  return !mod.startsWith('/') && !mod.startsWith('.')
-}

data/lib/proscenium/compilers/esbuild.js

@@ -4,7 +4,7 @@ import { expandGlob } from 'std/fs/mod.ts'
 import { join, isGlob, resolve, dirname, fromFileUrl } from 'std/path/mod.ts'
 import { build, stop } from 'esbuild'
 
-import { readImportMap } from './esbuild/import_map.js'
+import readImportMap from './esbuild/import_map/read.js'
 import envPlugin from './esbuild/env_plugin.js'
 import cssPlugin from './esbuild/css_plugin.js'
 import resolvePlugin from './esbuild/resolve_plugin.js'

data/lib/proscenium/utils.js

@@ -6,3 +6,7 @@ export async function fileExists(path) {
     return false
   }
 }
+
+export function isBareModule(mod) {
+  return !mod.startsWith('/') && !mod.startsWith('.')
+}

data/lib/proscenium/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Proscenium
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proscenium
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: x86_64-linux
 authors:
 - Joel Moss
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-08 00:00:00.000000000 Z
+date: 2022-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable
@@ -167,7 +167,10 @@ files:
 - lib/proscenium/compilers/esbuild/css_plugin.js
 - lib/proscenium/compilers/esbuild/env_plugin.js
 - lib/proscenium/compilers/esbuild/http_bundle_plugin.js
-- lib/proscenium/compilers/esbuild/import_map.js
+- lib/proscenium/compilers/esbuild/import_map/parser.js
+- lib/proscenium/compilers/esbuild/import_map/read.js
+- lib/proscenium/compilers/esbuild/import_map/resolver.js
+- lib/proscenium/compilers/esbuild/import_map/utils.js
 - lib/proscenium/compilers/esbuild/resolve_plugin.js
 - lib/proscenium/compilers/esbuild/setup_plugin.js
 - lib/proscenium/compilers/esbuild/solidjs_plugin.js