@wix/origami-site-runtime 1.0.13 → 1.0.15

package/src/jsxPlugins/origamiCompatibility/index.js

@@ -1,48 +0,0 @@
-// Bridges generated Origami structures to the piler component contract by forcing a few props onto
-// the components that need them.
-//
-// Each forced prop is a rule in `rules/`, declaring the components it applies to. That table is
-// also what defines which imported names count as Origami components, so adding a rule extends
-// import recognition with it — there is no second list to keep in sync.
-
-import { basename } from 'node:path'
-import { collectComponentBindings } from './componentBindings.js'
-import { containerPropsRule } from './rules/containerProps.js'
-import { richTextHtmlRule } from './rules/richTextHtml.js'
-
-const STRUCTURE_FILE = 'structure.jsx'
-
-const RULES = [containerPropsRule, richTextHtmlRule]
-
-/** Origami component name -> the rules that force props on it. */
-const RULES_BY_COMPONENT = new Map(
-    RULES.flatMap(rule => rule.components).map(component => [
-        component,
-        RULES.filter(rule => rule.components.includes(component)),
-    ])
-)
-
-/** @type {import('../../transform/types.js').JsxTransformPlugin} */
-export const origamiCompatibilityPlugin = {
-    name: 'wix-import-origami-compatibility',
-    order: 0,
-    appliesTo: context => basename(context.filePath) === STRUCTURE_FILE,
-
-    transform: program => {
-        // Import identity, not tag name, decides what is an Origami component — so a module that
-        // imports none cannot match a rule, and the tree is never walked.
-        const rulesByLocalName = collectComponentBindings(program.node, RULES_BY_COMPONENT)
-        if (rulesByLocalName.size === 0) return
-
-        program.traverse({
-            JSXOpeningElement(path) {
-                if (path.node.name.type !== 'JSXIdentifier') return
-
-                const rules = rulesByLocalName.get(path.node.name.name)
-                if (rules === undefined) return
-
-                for (const rule of rules) rule.apply(path.node)
-            },
-        })
-    },
-}

package/src/jsxPlugins/origamiCompatibility/rules/containerProps.js

@@ -1,15 +0,0 @@
-// Container components need a `containerProps` object to satisfy the piler component contract.
-
-import { types as t } from '@babel/core'
-import { findAttribute } from '../ast.js'
-
-export const containerPropsRule = {
-    components: ['Section', 'RefComponent', 'HeaderSection', 'FooterSection'],
-    apply: openingElement => {
-        if (findAttribute(openingElement.attributes, 'containerProps')) return
-
-        openingElement.attributes.push(
-            t.jsxAttribute(t.jsxIdentifier('containerProps'), t.jsxExpressionContainer(t.objectExpression([])))
-        )
-    },
-}

package/src/jsxPlugins/origamiCompatibility/rules/richTextHtml.js

@@ -1,22 +0,0 @@
-// Rich text needs an `html` field, which the export only provides as `text`.
-
-import { types as t } from '@babel/core'
-import { indexProperties, objectPropValue } from '../ast.js'
-
-export const richTextHtmlRule = {
-    components: ['WRichText'],
-    apply: openingElement => {
-        const richText = objectPropValue(openingElement, 'richText')
-        if (!richText) return
-
-        const fields = indexProperties(richText.properties)
-        if (fields.has('html')) return
-
-        // Only a literal text/linkList pair is safe to derive from statically.
-        const text = fields.get('text')
-        const linkList = fields.get('linkList')
-        if (text?.value.type !== 'StringLiteral' || linkList?.value.type !== 'ArrayExpression') return
-
-        richText.properties.push(t.objectProperty(t.identifier('html'), t.cloneNode(text.value, true)))
-    },
-}

package/src/jsxPlugins/validation/checks.js

@@ -1,105 +0,0 @@
-// The checks behind the constraints in ./rules.js. Each gets the element a rule applies to and
-// reports what it found; the message states the rule's whole constraint and how to fix it, so one
-// error is enough to write the correct structure.
-//
-// To add a kind of constraint: add a function to CHECKS, use its key in rules.js, and extend
-// expectation() so messages state it.
-
-import { describe } from './tree.js'
-
-const CHILD_CONSTRAINTS = ['allowedChildren', 'minChildren', 'maxChildren']
-
-const list = names => {
-    const items = names.map(name => `<${name}>`)
-    return items.length === 1 ? items[0] : `${items.slice(0, -1).join(', ')} or ${items.at(-1)}`
-}
-
-// "must have exactly one <InternalContainer> child"
-const childrenExpectation = ({ allowedChildren, minChildren: min, maxChildren: max }) => {
-    const count =
-        min !== undefined && min === max
-            ? `exactly ${min === 1 ? 'one' : min}`
-            : min !== undefined && max !== undefined
-              ? `between ${min} and ${max}`
-              : min !== undefined
-                ? `at least ${min}`
-                : max !== undefined
-                  ? `at most ${max}`
-                  : 'only'
-    const kind = allowedChildren ? list(allowedChildren) : 'JSX element'
-    const noun = min === 1 && max === 1 ? 'child' : 'children'
-    return `must have ${count} ${kind} ${noun}`
-}
-
-const expectation = rule => {
-    const parts = []
-    if (rule.allowedChildren || rule.minChildren !== undefined || rule.maxChildren !== undefined) {
-        parts.push(childrenExpectation(rule))
-    }
-    return parts.join(', and ')
-}
-
-const at = node => (node.loc ? ` (line ${node.loc.start.line})` : '')
-
-/** A constrained parent's children must be literal JSX tags. */
-const checkLiteral = ({ node, fail }) => {
-    const unseen = what => fail(`${what}; write each child as a JSX tag`)
-    for (const attribute of node.openingElement.attributes) {
-        if (attribute.type === 'JSXSpreadAttribute') unseen(`spread props${at(attribute)}`)
-        else if (attribute.name.name === 'children') unseen(`a children= prop${at(attribute)}`)
-    }
-    for (const child of node.children) {
-        if (child.type === 'JSXExpressionContainer' && child.expression.type !== 'JSXEmptyExpression') {
-            unseen(`a {…} expression${at(child)}`)
-        } else if (child.type === 'JSXSpreadChild') unseen(`a {...spread} child${at(child)}`)
-        else if (child.type === 'JSXFragment') unseen(`a fragment${at(child)}`)
-        else if (child.type === 'JSXText' && child.value.trim()) unseen(`text${at(child)}`)
-    }
-}
-
-const CHECKS = {
-    allowedChildren: (allowed, { elements, fail }) => {
-        for (const { element, component } of elements) {
-            if (!allowed.includes(component)) fail(`${describe(element)}`)
-        }
-    },
-    minChildren: (min, { elements, fail }) => {
-        if (elements.length < min) fail(elements.length === 0 ? 'none' : `${elements.length}`)
-    },
-    maxChildren: (max, { elements, fail }) => {
-        if (elements.length > max) fail(`${elements.length}`)
-    },
-}
-
-// Fail fast on a typo in rules.js.
-export const assertKnownConstraints = rules => {
-    for (const rule of rules) {
-        for (const key of Object.keys(rule)) {
-            if (key !== 'id' && key !== 'components' && !CHECKS[key]) {
-                throw new Error(
-                    `layout rules: unknown constraint "${key}" on ${rule.id}. Known: ${Object.keys(CHECKS).join(', ')}`
-                )
-            }
-        }
-    }
-}
-
-export const constrainsChildren = rule => CHILD_CONSTRAINTS.some(key => key in rule)
-
-/** Runs every constraint of `rule` on one element; `report` receives each full message. */
-export const checkRule = (rule, { node, componentOf, report }) => {
-    const prefix = `${describe(node)} ${expectation(rule)}`
-    const fail = got => report(`${prefix}; found ${got}.`)
-
-    const elements = node.children
-        .filter(child => child.type === 'JSXElement')
-        .map(element => ({ element, component: componentOf(element) }))
-    const context = { node, elements, fail }
-
-    if (constrainsChildren(rule)) checkLiteral(context)
-    for (const [key, value] of Object.entries(rule)) CHECKS[key]?.(value, context)
-}
-
-/** `createElement(Section, …)` would hide a constrained component's children from the checks. */
-export const checkCreateElement = (rule, { node, component, report }) =>
-    report(`<${component}>${at(node)} ${expectation(rule)}; found createElement(${component}), write it as a JSX tag.`)

package/src/jsxPlugins/validation/index.js

@@ -1,65 +0,0 @@
-// Checks authored structures against the Studio 2 site rulebook layout rules. It changes
-// nothing: every violation in the file is collected, and the build fails once with all of them.
-//
-// One walk serves every rule. Rules are data (./rules.js); each names the components it looks at,
-// identified for now by JSX tag name as written (<Section>, <InternalContainer>), whatever they are
-// imported from, and the checks (./checks.js) run on each matching element.
-
-import { basename } from 'node:path'
-import { LayoutError } from '../../transform/layoutError.js'
-import { assertKnownConstraints, checkCreateElement, checkRule, constrainsChildren } from './checks.js'
-import { RULES } from './rules.js'
-
-const STRUCTURE_FILES = new Set(['structure.tsx', 'structure.jsx'])
-
-assertKnownConstraints(RULES)
-
-/** Component (tag) name -> the rules that check it. */
-const RULES_BY_COMPONENT = new Map(
-    RULES.flatMap(rule => rule.components).map(component => [
-        component,
-        RULES.filter(rule => rule.components.includes(component)),
-    ])
-)
-
-const isCreateElement = callee =>
-    (callee.type === 'Identifier' && callee.name === 'createElement') ||
-    (callee.type === 'MemberExpression' && !callee.computed && callee.property.name === 'createElement')
-
-/** @type {import('../../transform/types.js').JsxTransformPlugin} */
-export const layoutValidationPlugin = {
-    name: 'wix-import-layout-validation',
-    // Before any plugin that rewrites the tree, so the rules see it as authored.
-    order: -100,
-    appliesTo: context => STRUCTURE_FILES.has(basename(context.filePath)),
-
-    transform: program => {
-        // The component an element is: its tag name, as written.
-        const componentOf = node => {
-            const name = node.openingElement.name
-            return name.type === 'JSXIdentifier' ? name.name : undefined
-        }
-
-        const violations = []
-        const report = message => violations.push(message)
-        program.traverse({
-            JSXElement(path) {
-                const component = componentOf(path.node)
-                const rules = component === undefined ? undefined : RULES_BY_COMPONENT.get(component)
-                if (rules === undefined) return
-                for (const rule of rules) checkRule(rule, { node: path.node, componentOf, report })
-            },
-
-            CallExpression({ node }) {
-                const [type] = node.arguments
-                if (!isCreateElement(node.callee) || type?.type !== 'Identifier') return
-                const component = type.name
-                for (const rule of RULES_BY_COMPONENT.get(component) ?? []) {
-                    if (constrainsChildren(rule)) checkCreateElement(rule, { node, component, report })
-                }
-            },
-        })
-
-        if (violations.length) throw new LayoutError(violations)
-    },
-}

package/src/jsxPlugins/validation/rules.js

@@ -1,24 +0,0 @@
-// The Studio 2 site rulebook rules (rev 1.40) this build checks, as data.
-// A rule lives here unless TypeScript can enforce all of it; a rule is never split between the two.
-//
-// A rule names the components it applies to, by JSX tag name, and the constraints they must meet. Each
-// constraint is a check in ./checks.js, keyed by its name:
-//   allowedChildren:  string[]  — the only components allowed as direct children
-//   minChildren:      number    — minimum number of direct child elements
-//   maxChildren:      number    — maximum number of direct child elements
-//
-// A component whose children a rule constrains must be written as literal JSX with literal child
-// tags: {expressions}, fragments, text, spread props, a children= prop and createElement() are
-// errors, so the check always sees the real structure.
-
-const STANDARD_SECTIONS = ['Section', 'HeaderSection', 'FooterSection']
-
-export const RULES = [
-    {
-        id: 'S2-SECTION-001',
-        components: STANDARD_SECTIONS,
-        allowedChildren: ['InternalContainer'],
-        minChildren: 1,
-        maxChildren: 1,
-    },
-]

package/src/jsxPlugins/validation/tree.js

@@ -1,15 +0,0 @@
-// Reads over the authored JSX tree, shared by the layout rules.
-
-/** `<Section id="x">` at line 12 → `<Section id="x"> (line 12)`, for error messages. */
-export const describe = node => {
-    const opening = node.openingElement
-    const tag = opening.name.type === 'JSXIdentifier' ? opening.name.name : 'element'
-    const id = opening.attributes.find(
-        attribute =>
-            attribute.type === 'JSXAttribute' &&
-            attribute.name.name === 'id' &&
-            attribute.value?.type === 'StringLiteral'
-    )
-    const line = node.loc ? ` (line ${node.loc.start.line})` : ''
-    return `<${tag}${id ? ` id="${id.value.value}"` : ''}>${line}`
-}

package/src/transform/context.js

@@ -1,13 +0,0 @@
-import { relativeToSite } from '../routing/siteLayout.js'
-
-export const createContextFactory =
-    ({ layout, command }) =>
-    (id, { ssr = false } = {}) =>
-        Object.freeze({
-            id,
-            filePath: id.split('?', 1)[0],
-            relativePath: relativeToSite(layout.root, id),
-            layout,
-            command,
-            ssr,
-        })

package/src/transform/css/postcssPlugin.js

@@ -1,60 +0,0 @@
-// The CSS stage, exposed as a PostCSS plugin rather than a Vite `transform` hook.
-//
-// That placement is load-bearing. A generated page imports one stylesheet that `@import`s the
-// Origami carriers (layout.css, style.css); Vite inlines those with its own postcss-import, which
-// reads them straight from disk and never runs plugin transform hooks over them. A Vite hook at
-// `enforce: 'pre'` therefore sees the page's `@import` statements and nothing else. Vite installs
-// postcss-import ahead of the configured PostCSS plugins, so by the time this one runs the
-// stylesheet the plugins see is the whole page: a rule declared in one carrier and a rule that
-// depends on it in another arrive in the same document.
-
-import { runCssPlugins } from './runPlugins.js'
-
-const DEPENDENCY_DIRECTORY = 'node_modules/'
-
-// The site's own files, and only those. A stylesheet outside the root belongs to a dependency; so
-// does one reached through the site's own node_modules, which merely happens to live inside it.
-const isSiteOwned = relativePath =>
-    relativePath !== undefined &&
-    !relativePath.startsWith(DEPENDENCY_DIRECTORY) &&
-    !relativePath.includes(`/${DEPENDENCY_DIRECTORY}`)
-
-/**
- * @param {{
- *     selectPlugins: (context: import('../types.js').TransformContext) => readonly object[],
- *     contextFor: (id: string) => import('../types.js').TransformContext,
- *     failures?: Map<string, Set<string>>,
- * }} options `failures` maps each stylesheet whose last run failed to the files it declared before failing.
- */
-export const createCssPostcssPlugin = ({ selectPlugins, contextFor, failures }) => ({
-    postcssPlugin: 'wix-import-css-transform',
-
-    Once(root, { result }) {
-        const from = result.opts.from
-        if (from === undefined) return
-
-        const fileContext = contextFor(from)
-        if (!isSiteOwned(fileContext.relativePath)) return
-
-        const plugins = selectPlugins(fileContext)
-        if (!plugins.length) return
-        // A plugin that reads another file declares it, so the bundler re-runs this stylesheet when that file
-        // changes. Vite reads these messages only from a run that succeeds, so a failed run's declarations are
-        // kept in `failures` instead; see vitePlugins/siteDocumentsPlugin.js.
-        const declared = new Set()
-        const addDependency = file => {
-            declared.add(file)
-            result.messages.push({ type: 'dependency', plugin: 'wix-import-css-transform', file, parent: from })
-        }
-        // A plugin reports a problem that need not stop the build as a PostCSS warning, which Vite prints with the
-        // node's code frame.
-        const warn = (node, text) => node.warn(result, text)
-        try {
-            runCssPlugins({ plugins, root, context: { ...fileContext, addDependency, warn } })
-            failures?.delete(from)
-        } catch (error) {
-            failures?.set(from, declared)
-            throw error
-        }
-    },
-})

package/src/transform/css/runPlugins.js

@@ -1,40 +0,0 @@
-// Runs the selected CSS plugins over one shared Root, in order. Parsing, stringifying and source
-// maps belong to PostCSS, which drives this stage — the only thing added here is attributing a
-// failure to the plugin and the file that caused it. A LayoutError is the author's, so it passes through.
-//
-// A LayoutError comes from a plugin that only checks, so the Root is as it was and the later plugins still run:
-// the author gets every plugin's violations in one error, at the first one's position, not one plugin's per build.
-
-import { LayoutError } from '../layoutError.js'
-
-const reason = cause => (cause instanceof Error ? cause.message : String(cause))
-
-export const runCssPlugins = ({ plugins, root, context }) => {
-    /** @type {LayoutError[]} */
-    const layoutErrors = []
-    for (const phase of ['validate', 'transform']) {
-        for (const plugin of plugins) {
-            try {
-                plugin[phase]?.(root, context)
-            } catch (cause) {
-                if (cause instanceof LayoutError) {
-                    layoutErrors.push(cause)
-                    continue
-                }
-                // Tooling such as Vite's error overlay prints only the message, so the reason goes in it as well. A
-                // plugin may throw any value, so it is read without assuming an Error.
-                throw new Error(
-                    `CSS transform "${plugin.name}" failed for ${context.relativePath ?? context.filePath}: ${reason(cause)}`,
-                    { cause }
-                )
-            }
-        }
-    }
-    if (layoutErrors.length === 1) throw layoutErrors[0]
-    if (layoutErrors.length > 1) {
-        throw new LayoutError(
-            layoutErrors.flatMap(error => error.violations),
-            layoutErrors[0].location
-        )
-    }
-}

package/src/transform/jsx/babelAdapter.js

@@ -1,37 +0,0 @@
-// The JSX stage's bridge to Babel.
-//
-// Exactly one Babel plugin is registered per module, however many of our plugins are selected: this
-// adapter. Babel parses the module once, and the adapter's Program visitor is where that AST is
-// handed to the stage — the same hand-off PostCSS gives the CSS stage. Our plugins are therefore
-// plain functions over an AST, and none of them has to be shaped like a Babel plugin.
-//
-// The adapter is a stable module-level function and the per-file work is passed as Babel plugin
-// options, so Babel still sees the same plugin identity on every file.
-
-import { runJsxPlugins } from './runPlugins.js'
-
-const babelAdapter = () => ({
-    name: 'wix-import-jsx-transform',
-    visitor: {
-        Program(program, state) {
-            const { plugins, context } = state.opts
-            runJsxPlugins({ plugins, program, context })
-        },
-    },
-})
-
-export const createBabelOptionsSelector =
-    ({ selectPlugins, contextFor }) =>
-    (id, { ssr = false } = {}) => {
-        const context = contextFor(id, { ssr })
-        const plugins = selectPlugins(context)
-        if (!plugins.length) return { plugins: [] }
-
-        // Parser plugins configure the parse itself, so they are collected before anything runs.
-        const parserPlugins = [...new Set(plugins.flatMap(plugin => plugin.parserPlugins ?? []))]
-
-        return {
-            plugins: [[babelAdapter, { plugins, context }]],
-            ...(parserPlugins.length ? { parserOpts: { plugins: parserPlugins } } : {}),
-        }
-    }

package/src/transform/jsx/runPlugins.js

@@ -1,23 +0,0 @@
-// Runs the selected JSX plugins over one shared Program path, in order. Parsing and printing belong
-// to Babel, which drives this stage — the only thing added here is attributing a failure to the
-// plugin and the file that caused it. A LayoutError is the author's, so it passes through.
-
-import { LayoutError } from '../layoutError.js'
-
-const reason = cause => (cause instanceof Error ? cause.message : String(cause))
-
-export const runJsxPlugins = ({ plugins, program, context }) => {
-    for (const plugin of plugins) {
-        try {
-            plugin.transform(program, context)
-        } catch (cause) {
-            if (cause instanceof LayoutError) throw cause
-            // Tooling such as Vite's error overlay prints only the message, so the reason goes in it as well. A
-            // plugin may throw any value, so it is read without assuming an Error.
-            throw new Error(
-                `JSX transform "${plugin.name}" failed for ${context.relativePath ?? context.filePath}: ${reason(cause)}`,
-                { cause }
-            )
-        }
-    }
-}

package/src/transform/layoutError.js

@@ -1,19 +0,0 @@
-// A broken layout rule is the author's to fix, not a plugin crash. The stages pass it through as is,
-// without naming the plugin, and it carries no stack: the bundler already names the file, and the
-// messages say where in it.
-
-export class LayoutError extends Error {
-    /**
-     * @param {readonly string[]} violations
-     * @param {{ file?: string, line?: number, column?: number }} [location] The first violation's, which the
-     *     bundler prints as the error's position (Vite's CSS stage reads `file`, `line` and `column`).
-     */
-    constructor(violations, location = {}) {
-        super(violations.length === 1 ? violations[0] : `\n  ${violations.join('\n  ')}`)
-        this.name = 'LayoutError'
-        this.stack = ''
-        this.violations = violations
-        this.location = location
-        Object.assign(this, location)
-    }
-}

package/src/transform/pipeline.js

@@ -1,60 +0,0 @@
-// Select and cache transform plugins by stage, file, and SSR context.
-import { cssPlugins as defaultCssPlugins } from '../cssPlugins/index.js'
-import { jsxPlugins as defaultJsxPlugins } from '../jsxPlugins/index.js'
-import { createContextFactory } from './context.js'
-import { createCssPostcssPlugin } from './css/postcssPlugin.js'
-import { createBabelOptionsSelector } from './jsx/babelAdapter.js'
-import { createTransformRegistry } from './registry.js'
-
-const createState = ({ layout, registries, command }) => {
-    const contextFactory = createContextFactory({ layout, command })
-    /** @type {Map<string, readonly object[]>} `<stage>\0<ssr>\0<filePath>` -> selected plugins */
-    const selections = new Map()
-
-    const selectPlugins = (stage, context) => {
-        const key = `${stage}\0${context.ssr ? 1 : 0}\0${context.filePath}`
-        const cached = selections.get(key)
-        if (cached !== undefined) return cached
-
-        const selected = registries[stage].select(context)
-        selections.set(key, selected)
-        return selected
-    }
-
-    return { contextFactory, selectPlugins }
-}
-
-/**
- * @param {{
- *     layout: ReturnType<typeof import('../routing/siteLayout.js').siteLayout>,
- *     jsxPlugins?: readonly import('./types.js').JsxTransformPlugin[],
- *     cssPlugins?: readonly import('./types.js').CssTransformPlugin[],
- * }} options
- */
-export const createTransformPipeline = ({ layout, jsxPlugins = defaultJsxPlugins, cssPlugins = defaultCssPlugins }) => {
-    const registries = {
-        jsx: createTransformRegistry(jsxPlugins),
-        css: createTransformRegistry(cssPlugins),
-    }
-    let command
-    let state
-
-    const currentState = () => (state ??= createState({ layout, registries, command }))
-    const contextFor = (id, options) => currentState().contextFactory(id, options)
-    const selectFor = stage => context => currentState().selectPlugins(stage, context)
-    /** @type {Map<string, Set<string>>} stylesheet whose last CSS run failed -> the files it declared */
-    const cssFailures = new Map()
-
-    return {
-        postcssPlugin: createCssPostcssPlugin({ contextFor, selectPlugins: selectFor('css'), failures: cssFailures }),
-        babelOptionsFor: createBabelOptionsSelector({ contextFor, selectPlugins: selectFor('jsx') }),
-
-        /** Whether a stylesheet whose last CSS run failed declared `file`, so an edit to it may fix the stylesheet. */
-        failedStylesheetDependsOn: file => [...cssFailures.values()].some(files => files.has(file)),
-
-        setCommand: value => {
-            command = value
-            state = undefined
-        },
-    }
-}

package/src/transform/registry.js

@@ -1,40 +0,0 @@
-// One stage's plugins, kept in the order they run.
-//
-// Ordering is resolved once per registration rather than per selection: a site re-transforms the
-// same modules on every hot update, and the plugin list does not change between them. Selection
-// stays pure — the pipeline decides whether to consult a registry at all, and caches what it gets
-// back. Each stage gets its own registry, which is why nothing here knows about stages.
-
-/** @type {readonly any[]} */
-const EMPTY = Object.freeze([])
-
-const byOrderThenRegistration = (left, right) => left.plugin.order - right.plugin.order || left.index - right.index
-
-/** @param {readonly any[]} [plugins] */
-export const createTransformRegistry = (plugins = EMPTY) => {
-    const names = new Set()
-    /** @type {{ plugin: any, index: number }[]} */
-    const entries = []
-
-    const registry = {
-        register: plugin => {
-            if (names.has(plugin.name)) throw new Error(`Duplicate transform plugin "${plugin.name}"`)
-            names.add(plugin.name)
-
-            entries.push({ plugin, index: entries.length })
-            entries.sort(byOrderThenRegistration)
-            return registry
-        },
-
-        /** The plugins that apply to `context`, in order. Frozen; safe to hold onto. */
-        select: context => {
-            const selected = entries
-                .filter(({ plugin }) => !plugin.appliesTo || plugin.appliesTo(context))
-                .map(({ plugin }) => plugin)
-            return selected.length ? Object.freeze(selected) : EMPTY
-        },
-    }
-
-    for (const plugin of plugins) registry.register(plugin)
-    return registry
-}

package/src/transform/types.js

@@ -1,47 +0,0 @@
-/**
- * The transform-plugin contract.
- *
- * Both stages have the same shape: an engine parses the file once, and each plugin is handed that
- * AST plus the file's context and does what it likes with it. Babel and PostCSS are engines here,
- * not plugin hosts — a plugin never has to know either one's own plugin protocol. Which stage a
- * plugin belongs to is decided by the list it is registered in, so no descriptor restates it.
- *
- * @typedef {object} TransformContext
- * @property {string} id Module id as the bundler reports it, query string included.
- * @property {string} filePath `id` with any query stripped.
- * @property {string | undefined} relativePath Posix path relative to the site root, or undefined when the file lies outside it.
- * @property {ReturnType<typeof import('../routing/siteLayout.js').siteLayout>} layout
- * @property {'serve' | 'build'} command
- * @property {boolean} ssr Always false for the CSS stage, which PostCSS drives without an SSR signal.
- *
- * @typedef {object} TransformPluginBase
- * @property {string} name
- * @property {number} order Ascending. Ties break by registration order.
- * @property {(context: TransformContext) => boolean} [appliesTo] Whether the plugin runs for this
- * file. Must depend only on the file's identity, not on anything that can change between transforms
- * of the same file: the pipeline memoizes the selection per file path.
- *
- * @typedef {TransformPluginBase & {
- *     transform: (program: any, context: TransformContext) => void,
- *     parserPlugins?: readonly string[]
- * }} JsxTransformPlugin
- * `program` is the Babel `NodePath` for the module's Program node. Traverse it if you need to —
- * nothing walks it for you, so a plugin that can rule itself out cheaply should just return.
- * `parserPlugins` are Babel parser plugins the file needs; they are unioned across selected plugins
- * and applied before any of them run.
- *
- * @typedef {TransformPluginBase & {
- *     validate?: (root: import('postcss').Root, context: CssTransformContext) => void,
- *     transform: (root: import('postcss').Root, context: CssTransformContext) => void
- * }} CssTransformPlugin
- *
- * @typedef {TransformContext & {
- *     addDependency?: (file: string) => void,
- *     warn?: (node: import('postcss').Node, text: string) => void
- * }} CssTransformContext
- * `addDependency` declares a file the plugin read besides the stylesheet, so the bundler re-runs the
- * stylesheet when it changes. `warn` reports a problem at `node` without failing the run, as a PostCSS
- * warning on the stylesheet's result. Both are absent when no bundler drives the run.
- */
-
-export {}