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

proscenium 0.6.0-x86_64-darwin → 0.7.0-x86_64-darwin

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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