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

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

@@ -1,207 +0,0 @@
-import { join, resolve } from 'std/path/mod.ts'
-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']
-
-export default setup('resolve', (build, options) => {
-  const { runtimeDir, importMap } = options
-  const cwd = build.initialOptions.absWorkingDir
-  const runtimeCwdAlias = `${cwd}/proscenium-runtime`
-  let bundled = false
-
-  const env = Deno.env.get('RAILS_ENV')
-  const isProd = env === 'production'
-
-  return [
-    {
-      // Filters for imports starting with `url:http://` or `url:https://`; returning the path
-      // without the `url:` prefix, and a namespace of 'url`
-      type: 'onResolve',
-      filter: /^url:https?:\/\//,
-      callback(args) {
-        return {
-          path: args.path.slice(4),
-          namespace: 'url'
-        }
-      }
-    },
-
-    {
-      type: 'onResolve',
-      filter: /.*/,
-      namespace: 'url',
-      callback(args) {
-        if (!isBareModule(args.path)) {
-          return {
-            path: new URL(args.path, args.importer).toString(),
-            namespace: 'url'
-          }
-        }
-      }
-    },
-
-    {
-      type: 'onLoad',
-      filter: /.*/,
-      namespace: 'url',
-      async callback(args) {
-        const file = await cache(args.path)
-        const contents = await Deno.readTextFile(file.path)
-
-        return { contents }
-      }
-    },
-
-    {
-      type: 'onResolve',
-      filter: /.*/,
-      async callback(args) {
-        if (args.path.includes('?')) {
-          const [path, query] = args.path.split('?')
-          args.path = path
-          args.suffix = `?${query}`
-          args.queryParams = new URLSearchParams(query)
-        } else if (options.cacheQueryString && options.cacheQueryString !== '') {
-          args.suffix = `?${options.cacheQueryString}`
-        }
-
-        // Mark remote modules as external. If not css, then the path is prefixed with "url:", which
-        // is then handled by the Url Middleware.
-        if (
-          !args.importer.endsWith('.css') &&
-          (args.path.startsWith('http://') || args.path.startsWith('https://'))
-        ) {
-          return { path: `/url:${encodeURIComponent(args.path)}`, external: true }
-        }
-
-        // Rewrite the path to the actual runtime directory.
-        if (args.path.startsWith(runtimeCwdAlias)) {
-          return { path: join(runtimeDir, args.path.slice(runtimeCwdAlias.length)) }
-        }
-
-        // Everything else is unbundled.
-        if (importKinds.includes(args.kind)) {
-          return await unbundleImport(args)
-        }
-      }
-    }
-  ]
-
-  // Resolve the given `params.path` to a path relative to the Rails root.
-  //
-  // Examples:
-  //  'react' -> '/.../node_modules/react/index.js'
-  //  './my_module' -> '/.../app/my_module.js'
-  //  '/app/my_module' -> '/.../app/my_module.js'
-  async function unbundleImport(params) {
-    const result = { path: params.path, suffix: params.suffix }
-
-    if (importMap) {
-      let baseURL
-      if (params.importer.startsWith('https://') || params.importer.startsWith('http://')) {
-        baseURL = new URL(params.importer)
-      } else {
-        baseURL = new URL(params.importer.slice(cwd.length), 'file://')
-      }
-
-      const { matched, resolvedImport } = resolveFromImportMap(params.path, importMap, baseURL)
-      // console.log({ importMap, matched, resolvedImport })
-
-      if (matched) {
-        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 }
-          }
-        } else {
-          result.path = resolvedImport
-        }
-      }
-    }
-
-    // Absolute path - append to current working dir.
-    if (params.path.startsWith('/')) {
-      result.path = resolve(cwd, params.path.slice(1))
-    }
-
-    const resOptions = {
-      // If path is a bare module (node_modules), and resolveDir is the Proscenium runtime dir, or
-      // is the current working dir, then use `cwd` as the `resolveDir`, otherwise pass it through
-      // as is. This ensures that nested node_modules are resolved correctly.
-      resolveDir:
-        isBareModule(result.path) &&
-        (!params.resolveDir.startsWith(cwd) || params.resolveDir.startsWith(runtimeDir))
-          ? cwd
-          : params.resolveDir,
-      kind: params.kind,
-      pluginData: {
-        // We use this property later on, as we should ignore this resolution call.
-        isResolvingPath: true
-      }
-    }
-
-    // Resolve the path using esbuild's internal resolution. This allows us to import node packages
-    // and extension-less paths without custom code, as esbuild with resolve them for us.
-    const resolveResult = await build.resolve(result.path, resOptions)
-
-    // Simple return the resolved result if we have an error. Usually happens when module is not
-    // found.
-    if (resolveResult.errors.length > 0) return resolveResult
-
-    // If 'bundle-all' queryParam is defined, return the resolveResult.
-    if (bundled || params.queryParams?.has('bundle-all')) {
-      bundled = true
-      return { ...resolveResult, suffix: '?bundle-all' }
-    }
-
-    // If 'bundle' queryParam is defined, return the resolveResult.
-    if (params.queryParams?.has('bundle')) {
-      return { ...resolveResult, suffix: '?bundle' }
-    }
-
-    if (resolveResult.path.startsWith(runtimeDir)) {
-      result.path = '/proscenium-runtime' + resolveResult.path.slice(runtimeDir.length)
-    } else if (!resolveResult.path.startsWith(cwd) && !isProd) {
-      // Resolved path is not in the current working directory. It could be linked to a file outside
-      // the CWD, or it's just invalid. If not in production, return as an outsideRoot namespaced,
-      // and externally suffixed path. This lets the Rails Proscenium::Middleware::OutsideRoot
-      // handle the import.
-      return {
-        ...resolveResult,
-        namespace: 'outsideRoot',
-        path: `${resolveResult.path}?outsideRoot`,
-        external: true
-      }
-    } else {
-      result.path = resolveResult.path.slice(cwd.length)
-    }
-
-    result.sideEffects = resolveResult.sideEffects
-
-    if (
-      params.path.endsWith('.css') &&
-      params.kind === 'import-statement' &&
-      /\.jsx?$/.test(params.importer)
-    ) {
-      // We're importing a CSS file from JS(X).
-      return { ...resolveResult, pluginData: { importedFromJs: true } }
-    } else {
-      result.external = true
-    }
-
-    if (result.suffix && result.suffix !== '') {
-      result.path = `${result.path}${result.suffix}`
-    }
-
-    return result
-  }
-})

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

@@ -1,45 +0,0 @@
-export default (pluginName, pluginFn) => {
-  return (options = {}) => ({
-    name: pluginName,
-    async setup(build) {
-      const callbacks = await pluginFn(build, options)
-
-      callbacks.forEach(({ type, callback, filter, namespace }) => {
-        if (type === 'onResolve') {
-          build.onResolve({ filter, namespace }, async params => {
-            if (params.pluginData?.isResolvingPath) return
-
-            let results
-
-            if (options.debug) {
-              console.debug()
-              console.group(`plugin(${pluginName}):onResolve`, { filter, namespace })
-              console.debug('params:', params)
-
-              try {
-                results = await callback(params)
-                console.debug('results:', results)
-              } finally {
-                console.groupEnd()
-              }
-            } else {
-              results = await callback(params)
-            }
-
-            return results
-          })
-        } else if (type === 'onLoad') {
-          build.onLoad({ filter, namespace }, async params => {
-            options.debug && console.debug(`plugin(${pluginName}):onLoad`, { params })
-
-            const results = await callback(params)
-
-            options.debug && console.debug(`plugin(${pluginName}):onLoad`, { results })
-
-            return results
-          })
-        }
-      })
-    }
-  })
-}

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

@@ -1,24 +0,0 @@
-import { basename } from 'std/path/mod.ts'
-import { transformAsync } from '@babel/core'
-import solid from 'babel-preset-solid'
-
-import { setup } from './setup_plugin.js'
-
-export default setup('solidjs', () => {
-  return [
-    {
-      type: 'onLoad',
-      filter: /\.jsx$/,
-      async callback(args) {
-        const source = await Deno.readTextFile(args.path)
-
-        const { code } = await transformAsync(source, {
-          presets: [solid],
-          filename: basename(args.path)
-        })
-
-        return { contents: code, loader: 'js' }
-      }
-    }
-  ]
-})

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

@@ -1,14 +0,0 @@
-import { join } from 'std/path/mod.ts'
-
-import compile from './esbuild.js'
-
-const root = join(Deno.cwd(), 'test', 'internal')
-const lightningcssBin = join(Deno.cwd(), 'bin', 'lightningcss')
-
-Deno.bench('esbuild js', async () => {
-  await compile(['lib/foo.js'], { root, lightningcssBin })
-})
-
-Deno.bench('esbuild css', async () => {
-  await compile(['lib/foo.css'], { root, lightningcssBin })
-})

data/lib/proscenium/compilers/esbuild.js

@@ -1,179 +0,0 @@
-import { writeAll } from 'std/streams/mod.ts'
-import { parse as parseArgs } from 'std/flags/mod.ts'
-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/read.js'
-import envPlugin from './esbuild/env_plugin.js'
-import cssPlugin from './esbuild/css_plugin.js'
-import resolvePlugin from './esbuild/resolve_plugin.js'
-import ArgumentError from './esbuild/argument_error.js'
-import throwCompileError from './esbuild/compile_error.js'
-
-/**
- * Compile the given paths, outputting the result to stdout. This is designed to be called as a CLI:
- *
- * Example with Deno run (dev and test):
- *  deno run -A lib/proscenium/compilers/esbuild.js --root ./test/internal lib/foo.js
- * Example with Deno compiled binary:
- *  bin/esbuild lib/proscenium/compilers/esbuild.js --root ./test/internal lib/foo.js
- *
- * USAGE:
- *   esbuild [OPTIONS] <PATHS_ARG>...
- *
- * ARGS:
- *   <PATHS_ARG>... One or more file paths or globs to compile.
- *
- * OPTIONS:
- *   --root <PATH>
- *       Relative or absolute path to the root or current working directory when compilation will
- *       take place.
- *   --import-map <PATH>
- *       Path to an import map, relative to the <root>.
- *   --lightningcss-bin <PATH>
- *       Path to the lightningcss CLI binary.
- *   --write
- *       Write output to the filesystem according to esbuild logic.
- *   --cache-query-string <STRING>
- *       Query string to append to all imports as a cache buster. Example: `v1`.
- *   --debug
- *       Debug output,
- */
-if (import.meta.main) {
-  !Deno.env.get('RAILS_ENV') && Deno.env.set('RAILS_ENV', 'development')
-
-  const { _: paths, ...options } = parseArgs(Deno.args, {
-    string: ['root', 'import-map', 'lightningcss-bin', 'cache-query-string'],
-    boolean: ['write', 'debug'],
-    alias: {
-      'import-map': 'importMap',
-      'cache-query-string': 'cacheQueryString',
-      'lightningcss-bin': 'lightningcssBin'
-    }
-  })
-
-  let result = await main(paths, options)
-
-  // `result` is an error object, so return to stderr as JSON, and an exit code of 1.
-  if (isPlainObject(result)) {
-    result = new TextEncoder().encode(`(${throwCompileError()})(${JSON.stringify(result)})`)
-  }
-
-  await writeAll(Deno.stdout, result)
-}
-
-async function main(paths = [], options = {}) {
-  const { write, debug } = { write: false, ...options }
-
-  if (!Array.isArray(paths) || paths.length < 1) throw new ArgumentError('pathsRequired')
-  if (!options.root) throw new ArgumentError('rootRequired')
-  if (!options.lightningcssBin) throw new ArgumentError('lightningcssBinRequired')
-
-  const root = resolve(options.root)
-
-  // Make sure that `root` is a valid directory.
-  try {
-    const stat = Deno.lstatSync(root)
-    if (!stat.isDirectory) throw new ArgumentError('rootUnknown', { root })
-  } catch {
-    throw new ArgumentError('rootUnknown', { root })
-  }
-
-  const env = Deno.env.get('RAILS_ENV')
-  const isProd = env === 'production'
-  const isTest = env === 'test'
-  const entryPoints = new Set()
-
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i]
-
-    if (isGlob(path)) {
-      for await (const file of expandGlob(path, { root })) {
-        file.isFile && entryPoints.add(file.path)
-      }
-    } else if (path.startsWith('/') || /^url:https?:\/\//.test(path)) {
-      // Path is absolute, or is prefixed with 'url:', so it must be outsideRoot, or Url. Don't
-      // prefix the root.
-      // See Proscenium::Middleware::[OutsideRoot|Url].
-      entryPoints.add(path)
-    } else {
-      entryPoints.add(join(root, path))
-    }
-  }
-
-  let importMap
-  try {
-    importMap = readImportMap(options.importMap, root)
-  } catch (error) {
-    return {
-      detail: error.stack,
-      text: `Cannot read/parse import map: ${error.message}`,
-      location: {
-        file: error.file
-      }
-    }
-  }
-
-  const runtimeDir = resolve(dirname(fromFileUrl(import.meta.url)), '../runtime')
-
-  const params = {
-    entryPoints: Array.from(entryPoints),
-    absWorkingDir: root,
-    logLevel: 'silent',
-    logLimit: 1,
-    outdir: 'public/assets',
-    outbase: './',
-    format: 'esm',
-    jsx: 'automatic',
-    jsxDev: !isTest && !isProd,
-    minify: isProd,
-    bundle: true,
-
-    // The Esbuild default places browser before module, but we're building for modern browsers
-    // which support esm. So we prioritise that. Some libraries export a "browser" build that still
-    // uses CJS.
-    mainFields: ['module', 'browser', 'main'],
-
-    plugins: [
-      envPlugin(),
-      resolvePlugin({ runtimeDir, importMap, debug, cacheQueryString: options.cacheQueryString }),
-      cssPlugin({ lightningcssBin: options.lightningcssBin, debug })
-    ],
-    metafile: write,
-    write
-  }
-
-  if (!debug) {
-    params.sourcemap = isProd || isTest ? false : 'inline'
-  }
-
-  let result
-  try {
-    result = await build(params)
-  } catch (error) {
-    if (debug) {
-      throw error
-    }
-
-    return { ...error.errors[0] }
-  } finally {
-    stop()
-  }
-
-  if (write) {
-    return new TextEncoder().encode(JSON.stringify(result))
-  } else {
-    const fileIndex = params.sourcemap === 'linked' ? 1 : 0
-    return result.outputFiles[fileIndex].contents
-  }
-}
-
-export function isPlainObject(value) {
-  if (Object.prototype.toString.call(value) !== '[object Object]') return false
-
-  const prototype = Object.getPrototypeOf(value)
-  return prototype === null || prototype === Object.prototype
-}
-
-export default main

data/lib/proscenium/link_to_helper.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium
-  module LinkToHelper
-    # Overrides ActionView::Helpers::UrlHelper#link_to to allow passing a component instance as the
-    # URL, which will build the URL from the component path, eg. `/components/my_component`. The
-    # resulting link tag will also populate the `data` attribute with the component props.
-    #
-    # Example:
-    #   link_to 'Go to', MyComponent
-    #
-    # TODO: ummm, todo it! ;)
-  end
-
-  # Component handling for the `link_to` helper.
-  class LinkToComponentArguments
-    def initialize(options, name_argument_index, context)
-      @options = options
-      @name_argument_index = name_argument_index
-      @component = @options[@name_argument_index]
-
-      # We have to render the component, and then extract the props from the component. Rendering
-      # first ensures that we have all the correct props.
-      context.render @component
-    end
-
-    def helper_options
-      @options[@name_argument_index] = "/components#{@component.virtual_path}"
-      @options[@name_argument_index += 1] ||= {}
-      @options[@name_argument_index][:rel] = 'nofollow'
-      @options[@name_argument_index][:data] ||= {}
-      @options[@name_argument_index][:data][:component] = {
-        path: @component.virtual_path,
-        props: @component.props
-      }
-
-      @options
-    end
-  end
-end

data/lib/proscenium/middleware/lightningcss.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'oj'
-
-module Proscenium
-  class Middleware
-    class Lightningcss < Base
-      def attempt
-        benchmark :lightningcss do
-          with_custom_media { |path| build path }
-        end
-      end
-
-      private
-
-      def with_custom_media
-        if custom_media?
-          Tempfile.create do |f|
-            contents = Pathname.new("#{root}#{@request.path}").read
-            f.write contents, "\n", custom_media_path.read
-            f.rewind
-
-            yield f.path
-          end
-        else
-          yield "#{root}#{@request.path}"
-        end
-      end
-
-      def build(path)
-        results = super("#{cli} #{cli_options.join ' '} #{path}")
-        render_response css_module? ? Oj.load(results, mode: :strict)['code'] : results
-      end
-
-      def custom_media?
-        @custom_media ||= custom_media_path.exist?
-      end
-
-      def custom_media_path
-        @custom_media_path ||= Rails.root.join('lib', 'custom_media_queries.css')
-      end
-
-      def cli
-        Gem.bin_path 'proscenium', 'lightningcss'
-      end
-
-      def cli_options
-        options = ['--nesting', '--targets', "'>= 0.25%'"]
-        options << '--custom-media' if custom_media?
-
-        if css_module?
-          hash = Digest::SHA1.hexdigest(@request.path)[..7]
-          options += ['--css-modules', '--css-modules-pattern', "'[local]#{hash}'"]
-        end
-
-        Rails.env.production? ? options << '-m' : options
-      end
-
-      def css_module?
-        @css_module ||= /\.module\.css$/i.match?(@request.path_info)
-      end
-    end
-  end
-end

data/lib/proscenium/middleware/outside_root.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium
-  class Middleware
-    # Provides a way to render files outside of the Rails root during non-production. This is
-    # primarily to support linked NPM modules, for example when using `pnpm link ...`.
-    class OutsideRoot < Esbuild
-      private
-
-      # @override [Esbuild] reassigns root to '/'.
-      def renderable?
-        old_root = root
-        @root = Pathname.new('/')
-
-        super
-      ensure
-        @root = old_root
-      end
-
-      # @override [Esbuild] does not remove leading slash, ensuring it is an absolute path.
-      def path
-        @request.path
-      end
-    end
-  end
-end

data/lib/proscenium/middleware/runtime.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium
-  class Middleware
-    class Runtime < Esbuild
-      private
-
-      def renderable?
-        old_root = root
-        old_path_info = @request.path_info
-
-        @root = Pathname.new(__dir__).join('../')
-        @request.path_info = @request.path_info.sub(%r{^/proscenium-runtime/}, 'runtime/')
-
-        super
-      ensure
-        @request.path_info = old_path_info
-        @root = old_root
-      end
-    end
-  end
-end

data/lib/proscenium/middleware/static.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium
-  module Middleware
-    # Serves static files from disk that end with .js or .css.
-    class Static < Base
-      def attempt
-        benchmark :static do
-          Rack::File.new(root, { 'X-Proscenium-Middleware' => 'static' }).call(@request.env)
-        end
-      end
-    end
-  end
-end

data/lib/proscenium/phlex/component.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class Proscenium::Phlex::Component < Proscenium::Phlex
-  private
-
-  def virtual_path
-    "/#{self.class.name.underscore}"
-  end
-end

data/lib/proscenium/precompile.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-
-module Proscenium
-  class Precompile
-    def self.call
-      new.call
-    end
-
-    def call
-      Rails.application.config.proscenium.glob_types.find do |type, globs|
-        cmd = "#{cli type} --root #{Rails.root} '#{globs.join "' '"}' --write"
-        _, stderr, status = Open3.capture3(cmd)
-
-        raise stderr unless status.success?
-        raise "#{type} compiliation failed -- #{stderr}" unless stderr.empty?
-      end
-    end
-
-    private
-
-    def cli(type)
-      if ENV['PROSCENIUM_TEST']
-        "deno run -q --import-map import_map.json -A lib/proscenium/compilers/#{type}.js"
-      else
-        Gem.bin_path 'proscenium', type.to_s
-      end
-    end
-  end
-end