proscenium 0.6.0-x86_64-linux → 0.7.0-x86_64-linux

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

@@ -1,67 +0,0 @@
-import { expandGlob } from 'std/fs/mod.ts'
-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, globstar: true })) {
-    mixinFiles.push(file.path)
-  }
-
-  // Only process mixins with PostCSS if there are any 'lib/**/*.mixin.css' files.
-  if (mixinFiles.length > 0) {
-    tmpFile = await Deno.makeTempFile()
-    contents = await Deno.readTextFile(path)
-
-    const result = await postcss([mixinsPlugin({ mixinFiles })]).process(contents, { from: path })
-    contents = result.css
-  }
-
-  return [tmpFile, contents]
-}
-
-const mixinsPlugin = (opts = {}) => {
-  return {
-    postcssPlugin: 'mixins',
-
-    prepare() {
-      const mixins = {}
-
-      return {
-        async Once(_, helpers) {
-          for (const path of opts.mixinFiles) {
-            const content = await Deno.readTextFile(path)
-            const root = helpers.parse(content, { from: path })
-
-            root.walkAtRules('define-mixin', atrule => {
-              mixins[atrule.params] = atrule
-            })
-          }
-        },
-
-        AtRule: {
-          mixin: (rule, helpers) => {
-            const mixin = mixins[rule.params]
-
-            if (!mixin) {
-              throw rule.error(`Undefined mixin '${rule.params}'`)
-            }
-
-            const proxy = new helpers.Root()
-            for (let i = 0; i < mixin.nodes.length; i++) {
-              const node = mixin.nodes[i].clone()
-              delete node.raws.before
-              proxy.append(node)
-            }
-
-            rule.parent.insertBefore(rule, proxy)
-
-            if (rule.parent) rule.remove()
-          }
-        }
-      }
-    }
-  }
-}

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

@@ -1,172 +0,0 @@
-import { crypto } from 'std/crypto/mod.ts'
-import { join, dirname, basename } from 'std/path/mod.ts'
-
-import { fileExists } from '../../utils.js'
-import postcss from './css/postcss.js'
-import setup from './setup_plugin.js'
-
-export default setup('css', async (build, options) => {
-  const cwd = build.initialOptions.absWorkingDir
-
-  let customMedia
-  try {
-    customMedia = await Deno.readTextFile(join(cwd, 'config', 'custom_media_queries.css'))
-  } catch {
-    // do nothing, as we don't require custom media.
-  }
-
-  return [
-    {
-      type: 'onLoad',
-      filter: /\.css$/,
-      namespace: 'file',
-      async callback(args) {
-        const hash = await digest(args.path.slice(cwd.length))
-        const isCssModule = args.path.endsWith('.module.css')
-
-        // If path is a CSS module, imported from JS, and a side-loaded ViewComponent stylesheet,
-        // simply return a JS proxy of the class names. The stylesheet itself will have already been
-        // side loaded. This avoids compiling the CSS all over again.
-        if (isCssModule && args.pluginData?.importedFromJs && (await isViewComponent(args.path))) {
-          return {
-            resolveDir: cwd,
-            loader: 'js',
-            contents: cssModulesProxyTemplate(hash)
-          }
-        }
-
-        let cmd = [
-          options.lightningcssBin,
-          '--nesting',
-          '--error-recovery',
-          args.pluginData?.importedFromJs && '--minify',
-          '--targets',
-          '>= 0.25%'
-        ].filter(Boolean)
-
-        // This will process the CSS with Postcss only if it needs to.
-        let [tmpFile, contents] = await postcss(cwd, args.path)
-
-        // As custom media are defined in their own file, we have to append the file contents to our
-        // stylesheet, so that the custom media can be used.
-        if (customMedia) {
-          cmd.push('--custom-media')
-
-          if (!tmpFile && !contents) {
-            tmpFile = await Deno.makeTempFile()
-            contents = await Deno.readTextFile(args.path)
-          }
-
-          contents += customMedia
-        }
-
-        if (tmpFile && contents) {
-          await Deno.writeTextFile(tmpFile, contents)
-        }
-
-        if (isCssModule) {
-          cmd = cmd.concat(['--css-modules', '--css-modules-pattern', `[local]${hash}`])
-        }
-
-        const p = Deno.run({
-          cmd: [...cmd, tmpFile || args.path],
-          stdout: 'piped',
-          stderr: 'piped'
-        })
-
-        const { code } = await p.status()
-        const rawOutput = await p.output()
-        const rawError = await p.stderrOutput()
-
-        // Even though Deno docs say that reading the outputs (above) closes their pipes, warnings
-        // are raised during tests that the child process have not been closed. So we manually close
-        // here.
-        p.close()
-
-        // Success!
-        if (code === 0) {
-          let contents = new TextDecoder().decode(rawOutput)
-          if (isCssModule) {
-            contents = JSON.parse(contents)
-          }
-
-          // If stylesheet is imported from JS, then we return JS code that appends the stylesheet
-          // in a <style> in the <head> of the page, and if the stylesheet is a CSS module, it
-          // exports a plain object of class names.
-          if (args.pluginData?.importedFromJs) {
-            const code = isCssModule ? contents.code : contents
-            const mod = [
-              `let e = document.querySelector('#_${hash}');`,
-              'if (!e) {',
-              "e = document.createElement('style');",
-              `e.id = '_${hash}';`,
-              'document.head.appendChild(e);',
-              `e.appendChild(document.createTextNode(\`${code}\`));`,
-              '}'
-            ]
-
-            if (isCssModule) {
-              const classes = {}
-              for (const key in contents.exports) {
-                if (Object.hasOwnProperty.call(contents.exports, key)) {
-                  classes[key] = contents.exports[key].name
-                }
-              }
-              mod.push(`export default ${JSON.stringify(classes)};`)
-            }
-
-            // We are importing from JS, so return the entire result from LightningCSS via the js
-            // loader.
-            return {
-              resolveDir: cwd,
-              loader: 'js',
-              contents: mod.join('')
-            }
-          }
-
-          return { loader: 'css', contents: isCssModule ? contents.code : contents }
-        } else {
-          const errorString = new TextDecoder().decode(rawError)
-          throw errorString
-        }
-      }
-    }
-  ]
-})
-
-async function digest(value) {
-  value = new TextEncoder().encode(value)
-  const view = new DataView(await crypto.subtle.digest('SHA-1', value))
-
-  let hexCodes = ''
-  for (let index = 0; index < view.byteLength; index += 4) {
-    hexCodes += view.getUint32(index).toString(16).padStart(8, '0')
-  }
-
-  return hexCodes.slice(0, 8)
-}
-
-async function isViewComponent(path) {
-  const fileName = basename(path)
-  const dirName = dirname(path)
-
-  return (
-    (fileName === 'component.module.css' && (await fileExists(join(dirName, 'component.rb')))) ||
-    (fileName.endsWith('_component.module.css') &&
-      (await fileExists(join(dirName, fileName.replace(/\.module\.css$/, '.rb')))))
-  )
-}
-
-function cssModulesProxyTemplate(hash) {
-  return [
-    `export default new Proxy( {}, {`,
-    `  get(target, prop, receiver) {`,
-    `    if (prop in target || typeof prop === 'symbol') {`,
-    `      return Reflect.get(target, prop, receiver)`,
-    `    } else {`,
-    `      return prop + '${hash}'`,
-    `    }`,
-    `  }`,
-    `})`
-  ].join('')
-}

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

@@ -1,46 +0,0 @@
-import setup from './setup_plugin.js'
-
-// Export environment variables as named exports only. You can also import from `env:ENV_VAR_NAME`,
-// which will return the value of the environment variable as the default export. This allows you to
-// safely import a variable regardless of its existence.
-export default setup('env', () => {
-  return [
-    {
-      type: 'onResolve',
-      filter: /^env(:.+)?$/,
-      callback({ path }) {
-        return { path, namespace: 'env' }
-      }
-    },
-
-    {
-      type: 'onLoad',
-      filter: /.*/,
-      namespace: 'env',
-      callback({ path }) {
-        if (path.includes(':')) {
-          const name = Deno.env.get(path.split(':')[1])
-
-          return {
-            loader: 'js',
-            contents: name ? `export default '${name}'` : `export default ${name}`
-          }
-        }
-
-        const env = Deno.env.toObject()
-        const contents = []
-
-        for (const key in env) {
-          if (Object.hasOwnProperty.call(env, key)) {
-            contents.push(`export const ${key} = '${env[key]}'`)
-          }
-        }
-
-        return {
-          loader: 'js',
-          contents: contents.join(';')
-        }
-      }
-    }
-  ]
-})

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

@@ -1,53 +0,0 @@
-import setup from './setup_plugin.js'
-
-export default setup('httpBundle', () => {
-  return [
-    {
-      type: 'onResolve',
-      filter: /^https?:\/\//,
-      callback(args) {
-        let queryParams, suffix
-        if (args.path.includes('?')) {
-          const [path, query] = args.path.split('?')
-          queryParams = new URLSearchParams(query)
-          suffix = `?${query}`
-          args.path = path
-        }
-
-        if (queryParams?.has('bundle')) {
-          return { path: args.path, namespace: 'httpBundle', suffix }
-        } else {
-          return { external: true }
-        }
-      }
-    },
-
-    // Intercept all import paths inside downloaded files and resolve them against the original URL.
-    {
-      type: 'onResolve',
-      filter: /.*/,
-      namespace: 'httpBundle',
-      callback(args) {
-        return {
-          path: new URL(args.path, args.importer).toString(),
-          namespace: 'httpBundle'
-        }
-      }
-    },
-
-    // Download and return the content.
-    //
-    // TODO: cache this!
-    {
-      type: 'onLoad',
-      filter: /.*/,
-      namespace: 'httpBundle',
-      async callback(args) {
-        const textResponse = await fetch(args.path)
-        const contents = await textResponse.text()
-
-        return { contents }
-      }
-    }
-  ]
-})

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

@@ -1,178 +0,0 @@
-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/read.js

@@ -1,64 +0,0 @@
-//
-// 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 './parser.js'
-
-const baseURL = new URL('file://')
-
-class ImportMapError extends Error {
-  constructor(fileName, ...params) {
-    super(...params)
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, ImportMapError)
-    }
-
-    this.name = 'ImportMapError'
-    this.file = fileName
-  }
-}
-
-export default function (fileName, rootDir) {
-  let importMap
-
-  if (fileName) {
-    importMap = readFile(fileName, rootDir, true)
-  } else {
-    fileName = ['config/import_map.json', 'config/import_map.js'].find(f => {
-      const result = readFile(f, rootDir)
-      if (result) {
-        importMap = result
-        return true
-      }
-    })
-  }
-
-  return importMap
-}
-
-function readFile(file, rootDir, required = false) {
-  let contents = null
-
-  try {
-    contents = Deno.readTextFileSync(join(rootDir, file))
-  } catch (error) {
-    if (required) {
-      throw new ImportMapError(file, error.message, { cause: error })
-    }
-  }
-
-  if (contents === null) return null
-
-  try {
-    if (file.endsWith('.js')) {
-      contents = JSON.stringify(eval(contents)(Deno.env.get('RAILS_ENV')))
-    }
-
-    return parseFromString(contents, baseURL)
-  } catch (error) {
-    throw new ImportMapError(file, error.message, { cause: error })
-  }
-}

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

@@ -1,95 +0,0 @@
-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

@@ -1,25 +0,0 @@
-/**
- * @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)
-}