@bleedingdev/modern-js-renderer-solid 0.0.0-stage → 3.9.3-ultramodern.10

package/dist/esm-node/manifest.js

@@ -0,0 +1,150 @@
+import { nativeModuleManifestFilename, readRendererIdentity } from "@modern-js/renderer-core/identity";
+const SOLID_COMPILER_VERSION = "2.0.0-rc.15";
+function solidModuleManifestFilename(entryName) {
+    return nativeModuleManifestFilename("solid", entryName);
+}
+function requireRecord(value, description) {
+    if (!value || "object" != typeof value || ![
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value))) throw new Error(`Invalid Solid module manifest ${description}`);
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ("string" != typeof key || !descriptor || !("value" in descriptor)) throw new Error(`Invalid Solid module manifest ${description}: data properties are required`);
+    }
+    return value;
+}
+function requireArray(value, description) {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) throw new Error(`Invalid Solid module manifest ${description}: an array is required`);
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ("string" != typeof key || "length" !== key && !/^(0|[1-9]\d*)$/.test(key) || !descriptor || !("value" in descriptor)) throw new Error(`Invalid Solid module manifest ${description}: array data properties are required`);
+    }
+}
+function requireStrings(value, description) {
+    requireArray(value, description);
+    for(let index = 0; index < value.length; index++)if ("string" != typeof value[index] || !value[index]) throw new Error(`Invalid Solid module manifest ${description}: nonempty strings are required`);
+}
+function validateAssetUrl(base, file) {
+    const prefix = base || "/";
+    const joined = /^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(file) ? file : `${prefix.endsWith("/") ? prefix : `${prefix}/`}${file.startsWith("/") ? file.slice(1) : file}`;
+    try {
+        new URL(joined, "https://manifest.invalid/");
+    } catch (cause) {
+        throw new Error(`Invalid Solid module manifest asset URL: ${file}`, {
+            cause
+        });
+    }
+}
+function validatePreload(value, base) {
+    const link = requireRecord(value, "preload");
+    if (![
+        "fetch",
+        "font",
+        "image",
+        "script",
+        "style",
+        "track"
+    ].includes(link.as)) throw new Error("Invalid Solid module manifest preload destination");
+    if (void 0 !== link.href) {
+        if ("string" != typeof link.href || !link.href) throw new Error("Invalid Solid module manifest preload href");
+        validateAssetUrl(base, link.href);
+    }
+    if ("image" === link.as) {
+        if (void 0 !== link.imagesrcset && ("string" != typeof link.imagesrcset || !link.imagesrcset)) throw new Error("Invalid Solid module manifest image preload source set");
+        if (void 0 === link.href && void 0 === link.imagesrcset) throw new Error("Invalid Solid module manifest image preload source");
+        if (void 0 !== link.imagesizes && "string" != typeof link.imagesizes) throw new Error("Invalid Solid module manifest image preload sizes");
+    } else if (void 0 === link.href || void 0 !== link.imagesrcset || void 0 !== link.imagesizes) throw new Error("Invalid Solid module manifest preload source");
+    for (const key of [
+        "type",
+        "integrity",
+        "media"
+    ])if (void 0 !== link[key] && "string" != typeof link[key]) throw new Error(`Invalid Solid module manifest preload ${key}`);
+    const enumerated = {
+        crossorigin: [
+            "",
+            true,
+            "anonymous",
+            "use-credentials"
+        ],
+        fetchpriority: [
+            "high",
+            "low",
+            "auto"
+        ],
+        referrerpolicy: [
+            "no-referrer",
+            "no-referrer-when-downgrade",
+            "origin",
+            "origin-when-cross-origin",
+            "same-origin",
+            "strict-origin",
+            "strict-origin-when-cross-origin",
+            "unsafe-url"
+        ]
+    };
+    for (const [key, values] of Object.entries(enumerated))if (void 0 !== link[key] && !values.includes(link[key])) throw new Error(`Invalid Solid module manifest preload ${key}`);
+}
+function assertCurrentIdentity(manifest, expectedIdentity) {
+    if (!manifest.rendererIdentity || "solid" !== expectedIdentity.renderer) throw new Error("Solid module manifest requires the current Solid application build identity.");
+    try {
+        readRendererIdentity(manifest.rendererIdentity, expectedIdentity);
+    } catch (cause) {
+        throw new Error("Stale Solid module manifest identity. Serve the manifest and hydration assets from the same application build.", {
+            cause
+        });
+    }
+}
+function readSolidModuleManifest(value, expectedIdentity) {
+    const manifest = requireRecord(value, "envelope");
+    if (1 !== manifest.schemaVersion || "solid" !== manifest.renderer || manifest.compilerVersion !== SOLID_COMPILER_VERSION) throw new Error(`Solid module manifest compiler ABI mismatch. Rebuild with @solidjs/compiler ${SOLID_COMPILER_VERSION}.`);
+    assertCurrentIdentity(manifest, expectedIdentity);
+    if (!manifest.modules || "object" != typeof manifest.modules || Array.isArray(manifest.modules)) throw new Error("Solid module manifest has no module inventory. Rebuild the application.");
+    const modules = requireRecord(manifest.modules, "module inventory");
+    if (void 0 !== modules._base && "string" != typeof modules._base) throw new Error("Invalid Solid module manifest asset base");
+    const base = modules._base;
+    for (const [key, value] of Object.entries(modules)){
+        if ("_base" === key) continue;
+        const chunk = requireRecord(value, `chunk ${key}`);
+        if ("string" != typeof chunk.file || !chunk.file) throw new Error(`Invalid Solid module manifest chunk ${key}: a nonempty file is required`);
+        validateAssetUrl(base, chunk.file);
+        for (const field of [
+            "css",
+            "imports"
+        ])if (void 0 !== chunk[field]) requireStrings(chunk[field], `${key}.${field}`);
+        for (const file of chunk.css ?? [])validateAssetUrl(base, file);
+        if (void 0 !== chunk.isEntry && "boolean" != typeof chunk.isEntry) throw new Error(`Invalid Solid module manifest chunk ${key}: isEntry must be boolean`);
+        if (void 0 !== chunk.preloads) {
+            requireArray(chunk.preloads, `${key}.preloads`);
+            for (const preload of chunk.preloads)validatePreload(preload, base);
+        }
+    }
+    for (const [key, value] of Object.entries(modules))if ("_base" !== key) {
+        for (const dependency of value.imports ?? [])if ("_base" === dependency || !Object.hasOwn(modules, dependency)) throw new Error(`Solid module manifest chunk ${key} imports missing own chunk ${dependency}`);
+    }
+    return manifest;
+}
+const validatedManifests = new WeakMap();
+function validateSolidModuleManifest(value, expectedIdentity, requiredModuleKeys = []) {
+    if (!value || "object" != typeof value) throw new Error("Missing Solid module manifest. Rebuild the application before SSR or hydration.");
+    let manifest = validatedManifests.get(value);
+    if (manifest) assertCurrentIdentity(manifest, expectedIdentity);
+    else {
+        manifest = readSolidModuleManifest(value, expectedIdentity);
+        validatedManifests.set(value, manifest);
+    }
+    for (const key of requiredModuleKeys)if ("_base" === key || !Object.hasOwn(manifest.modules, key)) throw new Error(`Solid module manifest is missing ${key}. Rebuild the application before SSR or hydration.`);
+    return manifest;
+}
+const compilerArtifacts = {
+    clientManifestFile: solidModuleManifestFilename,
+    async validateClientManifest (value, identity) {
+        return {
+            nativeManifest: validateSolidModuleManifest(value, identity)
+        };
+    },
+    isMutableDevelopmentAsset (filename, entryNames) {
+        return entryNames.some((entry)=>filename === solidModuleManifestFilename(entry));
+    }
+};
+export { SOLID_COMPILER_VERSION, compilerArtifacts, solidModuleManifestFilename, validateSolidModuleManifest };

package/dist/esm-node/native-promise-serialization.js

@@ -0,0 +1,113 @@
+import { createPlugin } from "@solidjs/web/serialization";
+const nativeThen = Promise.prototype.then;
+class ResolverToken {
+}
+class SettlementToken {
+    constructor(resolver, value, fulfilled){
+        this.resolver = resolver;
+        this.value = value;
+        this.fulfilled = fulfilled;
+    }
+}
+function mintNativeResolver() {
+    let accept;
+    let reject;
+    const promise = new Promise((resolve, fail)=>{
+        accept = resolve;
+        reject = fail;
+    });
+    const resolver = {
+        p: promise,
+        s (value) {
+            accept(value);
+            promise.s = 1;
+            promise.v = value;
+        },
+        f (value) {
+            reject(value);
+            promise.s = 2;
+            promise.v = value;
+        }
+    };
+    Promise.prototype.then.call(promise, void 0, ()=>void 0);
+    return resolver;
+}
+function requireStreamingHydration() {
+    throw new Error("The Solid native Promise serializer only supports streaming SSR hydration.");
+}
+const resolverPlugin = createPlugin({
+    tag: "ultramodern/solid/native-promise-resolver-v1",
+    test: (value)=>value instanceof ResolverToken,
+    parse: {
+        sync: requireStreamingHydration,
+        async: requireStreamingHydration,
+        stream: ()=>({})
+    },
+    serialize: ()=>`(${mintNativeResolver.toString()})()`,
+    deserialize: requireStreamingHydration
+});
+const settlementPlugin = createPlugin({
+    tag: "ultramodern/solid/native-promise-settlement-v1",
+    test: (value)=>value instanceof SettlementToken,
+    parse: {
+        sync: requireStreamingHydration,
+        async: requireStreamingHydration,
+        stream: (value, context)=>({
+                resolver: context.parse(value.resolver),
+                value: context.parse(value.value),
+                fulfilled: context.parse(value.fulfilled)
+            })
+    },
+    serialize: (node, context)=>`(${context.serialize(node.resolver)})[${context.serialize(node.fulfilled)}?"s":"f"](${context.serialize(node.value)})`,
+    deserialize: requireStreamingHydration
+});
+const nativePromiseSerializationPlugin = createPlugin({
+    tag: "ultramodern/solid/native-promise-v1",
+    extends: [
+        resolverPlugin,
+        settlementPlugin
+    ],
+    test: (value)=>value instanceof Promise,
+    parse: {
+        sync: requireStreamingHydration,
+        async: requireStreamingHydration,
+        stream (value, context) {
+            const resolver = new ResolverToken();
+            const node = context.parse(resolver);
+            context.pushPendingState();
+            let pending = {
+                context,
+                resolver
+            };
+            context.addCleanup(()=>{
+                pending = void 0;
+            });
+            const settle = (result, fulfilled)=>{
+                const current = pending;
+                if (!current) return;
+                pending = void 0;
+                try {
+                    if (!current.context.isAlive()) return;
+                    const settlement = current.context.parseWithError(new SettlementToken(current.resolver, result, fulfilled));
+                    if (settlement && current.context.isAlive()) current.context.onParse(settlement);
+                } finally{
+                    if (current.context.isAlive()) current.context.popPendingState();
+                }
+            };
+            try {
+                const bridge = nativeThen.call(value, (result)=>settle(result, true), (reason)=>settle(reason, false));
+                nativeThen.call(bridge, void 0, ()=>void 0);
+            } catch (error) {
+                pending = void 0;
+                if (context.isAlive()) context.popPendingState();
+                throw error;
+            }
+            return {
+                resolver: node
+            };
+        }
+    },
+    serialize: (node, context)=>`(${context.serialize(node.resolver)}).p`,
+    deserialize: requireStreamingHydration
+});
+export { nativePromiseSerializationPlugin };

package/dist/esm-node/plugin/compiler.js

@@ -0,0 +1,209 @@
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { identityCacheKey } from "@modern-js/renderer-core";
+import { SOLID_COMPILER_VERSION, solidModuleManifestFilename } from "../manifest.js";
+const nativeDependencySources = [
+    /[/\\]node_modules[/\\]\.modern-js[/\\]solid[/\\]/u,
+    /[/\\]node_modules[/\\]@modern-js[/\\]renderer-solid[/\\]/u
+];
+function pluginSourceDirectory() {
+    let directory = node_path.dirname(fileURLToPath(import.meta.url));
+    while(true){
+        const manifest = node_path.join(directory, 'package.json');
+        const compiler = node_path.join(directory, 'src/plugin');
+        if (node_fs.existsSync(manifest) && node_fs.existsSync(node_path.join(compiler, 'solid-loader.cjs'))) return compiler;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) throw new Error('Cannot locate the UltraModern Solid compiler package');
+        directory = parent;
+    }
+}
+function pluginSolidRenderer(options) {
+    return {
+        name: 'ultramodern:solid:compiler',
+        setup (api) {
+            if ('function' != typeof options?.rendererIdentities) throw new Error('Solid compiler requires identities from the native UltraModern infrastructure. Select renderer: solid through defineConfig.');
+            const directory = pluginSourceDirectory();
+            const require = createRequire(node_path.join(directory, 'index.cjs'));
+            const { collectLazyModules } = require('./lazy-modules.cjs');
+            const projectRoot = api.context.rootPath;
+            api.modifyRsbuildConfig((config)=>{
+                config.html ??= {};
+                config.html.scriptLoading = 'module';
+                config.source ??= {};
+                config.source.include = [
+                    ...config.source.include ?? [],
+                    ...nativeDependencySources
+                ];
+                return config;
+            });
+            api.modifyRspackConfig((config, { environment, isProd, rspack })=>{
+                const target = environment.config.output.target;
+                const ssrWorker = environment.name === options.workerEnvironmentName;
+                const client = 'web' === target && !ssrWorker;
+                const worker = 'web-worker' === target || ssrWorker;
+                const server = !client;
+                config.resolve ??= {};
+                config.resolve.conditionNames = [
+                    'solid',
+                    client ? 'browser' : worker ? 'worker' : 'node',
+                    ...isProd ? [] : [
+                        'development'
+                    ],
+                    'import',
+                    'default'
+                ];
+                const sourceExtensions = (config.resolve.extensions ?? [
+                    '.tsx',
+                    '.ts',
+                    '.jsx',
+                    '.js'
+                ]).filter((extension)=>[
+                        '.tsx',
+                        '.ts',
+                        '.jsx',
+                        '.js'
+                    ].includes(extension));
+                config.module ??= {};
+                config.module.rules ??= [];
+                config.module.rules.unshift({
+                    test: /\.[jt]sx?$/u,
+                    exclude: /\.d\.[cm]?ts$/u,
+                    include: (filename)=>node_path.isAbsolute(filename) && (!filename.includes(`${node_path.sep}node_modules${node_path.sep}`) || nativeDependencySources.some((source)=>source.test(filename))),
+                    enforce: 'pre',
+                    use: [
+                        {
+                            loader: node_path.join(directory, 'solid-loader.cjs'),
+                            options: {
+                                projectRoot,
+                                server,
+                                isProd,
+                                sourceExtensions
+                            }
+                        }
+                    ]
+                });
+                if (!client) return config;
+                config.module.rules.unshift({
+                    test: /[/\\]@solidjs[/\\]web[/\\]dist[/\\]web(?:\.dev)?\.js$/u,
+                    enforce: 'pre',
+                    use: [
+                        node_path.join(directory, 'preserve-import-loader.cjs')
+                    ]
+                });
+                config.output = {
+                    ...config.output,
+                    module: true,
+                    chunkFormat: 'module',
+                    chunkLoading: 'import',
+                    iife: false,
+                    scriptType: 'module',
+                    library: {
+                        type: 'module'
+                    }
+                };
+                config.optimization ??= {};
+                config.optimization.runtimeChunk = {
+                    name: 'runtime'
+                };
+                let currentDiscovery;
+                const originalEntry = config.entry;
+                config.entry = async ()=>{
+                    const discovery = currentDiscovery;
+                    if (!discovery) throw new Error('Solid lazy discovery requires an active Rspack compilation');
+                    const entries = 'function' == typeof originalEntry ? await originalEntry() : originalEntry;
+                    if (!entries || 'object' != typeof entries || Array.isArray(entries)) throw new Error('Solid lazy modules require named application entries');
+                    const entryDirectories = Object.values(entries).flatMap((entry)=>{
+                        const imports = 'object' != typeof entry || Array.isArray(entry) ? entry : entry.import;
+                        return (Array.isArray(imports) ? imports : [
+                            imports
+                        ]).filter((file)=>'string' == typeof file && /\.[jt]sx?$/u.test(file)).map((file)=>node_path.dirname(node_path.resolve(projectRoot, file)));
+                    });
+                    discovery.applicationEntries = Object.keys(entries);
+                    for (const directory of entryDirectories)discovery.compilation.contextDependencies.add(directory);
+                    try {
+                        discovery.modules = collectLazyModules(projectRoot, entryDirectories, sourceExtensions, {
+                            files: discovery.compilation.fileDependencies,
+                            contexts: discovery.compilation.contextDependencies,
+                            missing: discovery.compilation.missingDependencies
+                        });
+                    } catch (error) {
+                        discovery.failed = true;
+                        discovery.modules = [];
+                        discovery.compilation.errors.push(error instanceof Error ? error : new Error(String(error)));
+                        return entries;
+                    }
+                    const next = {
+                        ...entries
+                    };
+                    for (const module of discovery.modules){
+                        if (Object.hasOwn(next, module.entryName)) throw new Error(`Reserved Solid lazy entry ${module.entryName} conflicts with an application entry`);
+                        next[module.entryName] = {
+                            import: module.request
+                        };
+                    }
+                    return next;
+                };
+                config.plugins ??= [];
+                config.plugins.push({
+                    apply (compiler) {
+                        compiler.hooks.thisCompilation.tap('UltraModernSolidModuleManifest', (compilation)=>{
+                            const discovery = {
+                                compilation,
+                                modules: [],
+                                applicationEntries: [],
+                                failed: false
+                            };
+                            currentDiscovery = discovery;
+                            compilation.contextDependencies.add(node_path.join(projectRoot, 'src'));
+                            compilation.hooks.processAssets.tap({
+                                name: 'UltraModernSolidModuleManifest',
+                                stage: rspack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+                            }, ()=>{
+                                if (discovery.failed || compilation.errors.length > 0) return;
+                                const assets = {};
+                                const publicPath = compilation.outputOptions.publicPath;
+                                if ('string' == typeof publicPath && 'auto' !== publicPath) assets._base = publicPath;
+                                for (const module of discovery.modules){
+                                    const entry = compilation.entrypoints.get(module.entryName);
+                                    const files = entry?.getFiles() ?? [];
+                                    const chunk = entry?.getEntrypointChunk();
+                                    const entryFiles = chunk ? [
+                                        ...chunk.files
+                                    ] : [];
+                                    const file = entryFiles.find((asset)=>/\.(?:m)?js$/u.test(asset));
+                                    if (!file) throw new Error(`Solid lazy module ${module.key} has no native ESM entry asset`);
+                                    const css = files.filter((asset)=>/\.css$/u.test(asset));
+                                    assets[module.key] = {
+                                        file,
+                                        ...css.length ? {
+                                            css
+                                        } : {}
+                                    };
+                                }
+                                const identities = options.rendererIdentities();
+                                if (!identities || 'object' != typeof identities || Array.isArray(identities)) throw new Error('Solid compiler requires the current native application entry identity map');
+                                for (const entryName of discovery.applicationEntries){
+                                    const rendererIdentity = identities[entryName];
+                                    if (!rendererIdentity || 'solid' !== rendererIdentity.renderer || rendererIdentity.entryName !== entryName) throw new Error(`Solid compiler requires the current source-build identity for entry ${entryName}`);
+                                    identityCacheKey(rendererIdentity);
+                                    const manifest = {
+                                        schemaVersion: 1,
+                                        renderer: 'solid',
+                                        compilerVersion: SOLID_COMPILER_VERSION,
+                                        rendererIdentity,
+                                        modules: assets
+                                    };
+                                    compilation.emitAsset(solidModuleManifestFilename(entryName), new rspack.sources.RawSource(JSON.stringify(manifest, null, 2)));
+                                }
+                            });
+                        });
+                    }
+                });
+                return config;
+            });
+        }
+    };
+}
+export { pluginSolidRenderer, pluginSourceDirectory };