RubyGems - proscenium - Versions diffs - 0.6.0-arm64-darwin → 0.7.0-arm64-darwin - Mend

proscenium 0.6.0-arm64-darwin → 0.7.0-arm64-darwin

Files changed (63) hide show

checksums.yaml +4 -4
data/README.md +128 -107
data/bin/proscenium +0 -0
data/bin/proscenium.h +109 -0
data/config/routes.rb +0 -3
data/lib/proscenium/css_module/class_names_resolver.rb +66 -0
data/lib/proscenium/css_module/resolver.rb +76 -0
data/lib/proscenium/css_module.rb +18 -39
data/lib/proscenium/esbuild/golib.rb +97 -0
data/lib/proscenium/esbuild.rb +32 -0
data/lib/proscenium/helper.rb +0 -23
data/lib/proscenium/log_subscriber.rb +26 -0
data/lib/proscenium/middleware/base.rb +28 -36
data/lib/proscenium/middleware/esbuild.rb +18 -44
data/lib/proscenium/middleware/url.rb +1 -6
data/lib/proscenium/middleware.rb +12 -16
data/lib/proscenium/phlex/component_concerns.rb +27 -0
data/lib/proscenium/phlex/page.rb +62 -0
data/lib/proscenium/phlex/react_component.rb +52 -8
data/lib/proscenium/phlex/resolve_css_modules.rb +67 -0
data/lib/proscenium/phlex.rb +34 -33
data/lib/proscenium/railtie.rb +41 -67
data/lib/proscenium/side_load/ensure_loaded.rb +25 -0
data/lib/proscenium/side_load/helper.rb +25 -0
data/lib/proscenium/side_load/monkey.rb +48 -0
data/lib/proscenium/side_load.rb +58 -52
data/lib/proscenium/version.rb +1 -1
data/lib/proscenium/view_component/react_component.rb +14 -0
data/lib/proscenium/view_component.rb +28 -18
data/lib/proscenium.rb +79 -2
metadata +35 -75
data/app/channels/proscenium/connection.rb +0 -13
data/app/channels/proscenium/reload_channel.rb +0 -9
data/bin/esbuild +0 -0
data/bin/lightningcss +0 -0
data/lib/proscenium/compiler.js +0 -84
data/lib/proscenium/compilers/esbuild/argument_error.js +0 -24
data/lib/proscenium/compilers/esbuild/compile_error.js +0 -148
data/lib/proscenium/compilers/esbuild/css/postcss.js +0 -67
data/lib/proscenium/compilers/esbuild/css_plugin.js +0 -172
data/lib/proscenium/compilers/esbuild/env_plugin.js +0 -46
data/lib/proscenium/compilers/esbuild/http_bundle_plugin.js +0 -53
data/lib/proscenium/compilers/esbuild/import_map/parser.js +0 -178
data/lib/proscenium/compilers/esbuild/import_map/read.js +0 -64
data/lib/proscenium/compilers/esbuild/import_map/resolver.js +0 -95
data/lib/proscenium/compilers/esbuild/import_map/utils.js +0 -25
data/lib/proscenium/compilers/esbuild/resolve_plugin.js +0 -207
data/lib/proscenium/compilers/esbuild/setup_plugin.js +0 -45
data/lib/proscenium/compilers/esbuild/solidjs_plugin.js +0 -24
data/lib/proscenium/compilers/esbuild.bench.js +0 -14
data/lib/proscenium/compilers/esbuild.js +0 -179
data/lib/proscenium/link_to_helper.rb +0 -40
data/lib/proscenium/middleware/lightningcss.rb +0 -64
data/lib/proscenium/middleware/outside_root.rb +0 -26
data/lib/proscenium/middleware/runtime.rb +0 -22
data/lib/proscenium/middleware/static.rb +0 -14
data/lib/proscenium/phlex/component.rb +0 -9
data/lib/proscenium/precompile.rb +0 -31
data/lib/proscenium/runtime/auto_reload.js +0 -40
data/lib/proscenium/runtime/react_shim/index.js +0 -1
data/lib/proscenium/runtime/react_shim/package.json +0 -5
data/lib/proscenium/utils.js +0 -12
data/lib/tasks/assets.rake +0 -19

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

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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)
-}