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

package/dist/cjs/manifest.js

@@ -0,0 +1,167 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    OCTANE_COMPILER_VERSION: ()=>OCTANE_COMPILER_VERSION,
+    OCTANE_RUNTIME_VERSION: ()=>OCTANE_RUNTIME_VERSION,
+    compilerArtifacts: ()=>compilerArtifacts,
+    octaneModuleManifestFileName: ()=>octaneModuleManifestFileName,
+    validateOctaneModuleManifest: ()=>validateOctaneModuleManifest
+});
+const identity_namespaceObject = require("@modern-js/renderer-core/identity");
+const external_bootstrap_js_namespaceObject = require("./bootstrap.js");
+const OCTANE_RUNTIME_VERSION = '0.13.8';
+const OCTANE_COMPILER_VERSION = '0.2.4';
+function octaneModuleManifestFileName(entryName) {
+    return (0, identity_namespaceObject.nativeModuleManifestFilename)('octane', entryName);
+}
+function record(value, fields) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) throw new Error('Malformed Octane compiler manifest object.');
+    if (Object.keys(value).some((key)=>!fields.includes(key))) throw new Error('Octane compiler manifest contains an unknown field.');
+    return value;
+}
+function digest(value) {
+    return 'string' == typeof value && /^[a-f\d]{64}$/u.test(value);
+}
+function nonempty(value) {
+    return 'string' == typeof value && value.trim().length > 0 && !value.includes('\0');
+}
+function assetPath(value) {
+    return nonempty(value) && value.endsWith('.js') && !value.startsWith('/') && !value.includes('\\') && !value.split('/').some((part)=>'..' === part || '.' === part || !part);
+}
+const validatedManifests = new WeakMap();
+function validateOctaneModuleManifest(value, expectedIdentity, expectedNativeHydrationBuildId) {
+    (0, external_bootstrap_js_namespaceObject.assertOctaneIdentity)(expectedIdentity);
+    const cached = value && 'object' == typeof value ? validatedManifests.get(value) : void 0;
+    const manifest = cached ?? readOctaneModuleManifest(value);
+    (0, identity_namespaceObject.readRendererIdentity)(manifest.rendererIdentity, expectedIdentity);
+    if (void 0 !== expectedNativeHydrationBuildId) {
+        (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(expectedNativeHydrationBuildId);
+        if (manifest.nativeHydrationBuildId !== expectedNativeHydrationBuildId) throw new Error('Octane native hydration build differs from the compiled client.');
+    }
+    if (!cached) {
+        validatedManifests.set(value, manifest);
+        validatedManifests.set(manifest, manifest);
+    }
+    return manifest;
+}
+function readOctaneModuleManifest(value) {
+    const manifest = record(value, [
+        'schemaVersion',
+        'renderer',
+        'runtimeVersion',
+        'compilerVersion',
+        'rendererIdentity',
+        'nativeHydrationBuildId',
+        'sourceModules',
+        'assets'
+    ]);
+    if (1 !== manifest.schemaVersion || 'octane' !== manifest.renderer || manifest.runtimeVersion !== OCTANE_RUNTIME_VERSION || manifest.compilerVersion !== OCTANE_COMPILER_VERSION) throw new Error('Octane compiler manifest ABI conflicts with the application.');
+    const rendererIdentity = (0, identity_namespaceObject.readRendererIdentity)(manifest.rendererIdentity, manifest.rendererIdentity);
+    const nativeHydrationBuildId = manifest.nativeHydrationBuildId;
+    (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(nativeHydrationBuildId);
+    if (!Array.isArray(manifest.assets) || !manifest.assets.length) throw new Error('Octane compiler manifest has no emitted JavaScript closure.');
+    const assetNames = new Set();
+    const assets = manifest.assets.map((value)=>{
+        const asset = record(value, [
+            'file',
+            'sha256'
+        ]);
+        if (!assetPath(asset.file) || !digest(asset.sha256) || assetNames.has(asset.file)) throw new Error('Invalid Octane emitted asset digest.');
+        assetNames.add(asset.file);
+        return Object.freeze({
+            file: asset.file,
+            sha256: asset.sha256
+        });
+    });
+    if (!Array.isArray(manifest.sourceModules) || !manifest.sourceModules.length) throw new Error('Octane compiler manifest has no authenticated native sources.');
+    const resources = new Set();
+    const sourceModules = manifest.sourceModules.map((value)=>{
+        const source = record(value, [
+            'resource',
+            'canonicalId',
+            'moduleId',
+            'transformKind',
+            'emittedSourceSha256',
+            'assets'
+        ]);
+        if (!nonempty(source.resource) || source.resource.startsWith('/') || source.resource.includes('\\') || !nonempty(source.canonicalId) || !('string' == typeof source.moduleId && nonempty(source.moduleId) || 'number' == typeof source.moduleId && Number.isFinite(source.moduleId)) || !('compile' === source.transformKind || 'slots' === source.transformKind || 'client-only-stub' === source.transformKind) || !digest(source.emittedSourceSha256) || !Array.isArray(source.assets) || !source.assets.length || source.assets.some((file)=>'string' != typeof file || !assetNames.has(file)) || new Set(source.assets).size !== source.assets.length || resources.has(source.resource)) throw new Error('Invalid Octane native source-to-asset provenance.');
+        resources.add(source.resource);
+        return Object.freeze({
+            resource: source.resource,
+            canonicalId: source.canonicalId,
+            moduleId: source.moduleId,
+            transformKind: source.transformKind,
+            emittedSourceSha256: source.emittedSourceSha256,
+            assets: Object.freeze([
+                ...source.assets
+            ])
+        });
+    });
+    return Object.freeze({
+        schemaVersion: 1,
+        renderer: 'octane',
+        runtimeVersion: OCTANE_RUNTIME_VERSION,
+        compilerVersion: OCTANE_COMPILER_VERSION,
+        rendererIdentity,
+        nativeHydrationBuildId,
+        sourceModules: Object.freeze(sourceModules),
+        assets: Object.freeze(assets)
+    });
+}
+const compilerArtifacts = {
+    clientManifestFile: octaneModuleManifestFileName,
+    async validateClientManifest (value, identity, context) {
+        const hydrationBuildId = context.compilationHash ?? context.hydrationBuildId;
+        if (context.development && ('string' != typeof hydrationBuildId || !hydrationBuildId.trim())) throw new Error('Octane development snapshot has no native hydration build.');
+        const nativeManifest = validateOctaneModuleManifest(value, identity, hydrationBuildId);
+        return {
+            nativeManifest,
+            hydrationBuildId: nativeManifest.nativeHydrationBuildId
+        };
+    },
+    isMutableDevelopmentAsset (filename, entryNames) {
+        return 'octane-client-build.json' === filename || entryNames.some((entry)=>filename === octaneModuleManifestFileName(entry));
+    }
+};
+exports.OCTANE_COMPILER_VERSION = __webpack_exports__.OCTANE_COMPILER_VERSION;
+exports.OCTANE_RUNTIME_VERSION = __webpack_exports__.OCTANE_RUNTIME_VERSION;
+exports.compilerArtifacts = __webpack_exports__.compilerArtifacts;
+exports.octaneModuleManifestFileName = __webpack_exports__.octaneModuleManifestFileName;
+exports.validateOctaneModuleManifest = __webpack_exports__.validateOctaneModuleManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OCTANE_COMPILER_VERSION",
+    "OCTANE_RUNTIME_VERSION",
+    "compilerArtifacts",
+    "octaneModuleManifestFileName",
+    "validateOctaneModuleManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/compiler.js

@@ -0,0 +1,122 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createOctaneCompilerPlugin: ()=>createOctaneCompilerPlugin,
+    pluginSourceDirectory: ()=>pluginSourceDirectory
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_manifest_js_namespaceObject = require("../manifest.js");
+function pluginSourceDirectory() {
+    let directory = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
+    while(true){
+        const compiler = external_node_path_default().join(directory, 'src/plugin');
+        if (external_node_fs_default().existsSync(external_node_path_default().join(directory, 'package.json')) && external_node_fs_default().existsSync(external_node_path_default().join(compiler, 'compiler-manifest.cjs'))) return compiler;
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) throw new Error('Cannot locate the UltraModern Octane compiler package.');
+        directory = parent;
+    }
+}
+function createOctaneCompilerPlugin(options) {
+    return {
+        name: 'ultramodern:octane:compiler',
+        setup (api) {
+            const directory = pluginSourceDirectory();
+            const require1 = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(directory, 'index.cjs'));
+            const { OctaneCompilerManifestPlugin } = require1('./compiler-manifest.cjs');
+            const appRequire = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(api.context.rootPath, 'package.json'));
+            const { inferRspackEnvironment, OctaneRspackPlugin } = appRequire('@octanejs/rspack-plugin');
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+                    source: {
+                        include: [
+                            /[/\\]@octanejs[/\\]/u
+                        ]
+                    }
+                }));
+            api.modifyRspackConfig((config, { environment: rsbuildEnvironment })=>{
+                const environment = rsbuildEnvironment.name === options.workerEnvironmentName ? 'server' : inferRspackEnvironment(config.target);
+                config.plugins ??= [];
+                config.plugins.push(new OctaneRspackPlugin({
+                    root: api.context.rootPath,
+                    environment,
+                    transpile: false
+                }));
+                config.plugins.push(new OctaneCompilerManifestPlugin({
+                    emitClientManifest: 'client' === environment,
+                    root: api.context.rootPath,
+                    runtimeVersion: external_manifest_js_namespaceObject.OCTANE_RUNTIME_VERSION,
+                    compilerVersion: external_manifest_js_namespaceObject.OCTANE_COMPILER_VERSION,
+                    rendererIdentities: options.rendererIdentities,
+                    manifestFilename: external_manifest_js_namespaceObject.octaneModuleManifestFileName,
+                    validateManifest: external_manifest_js_namespaceObject.validateOctaneModuleManifest
+                }));
+                config.module ??= {};
+                config.module.rules ??= [];
+                config.module.rules.push({
+                    test: /\.tsrx$/u,
+                    type: "javascript/auto",
+                    use: [
+                        {
+                            loader: 'builtin:swc-loader',
+                            options: {
+                                detectSyntax: 'auto'
+                            }
+                        }
+                    ]
+                });
+            });
+        }
+    };
+}
+exports.createOctaneCompilerPlugin = __webpack_exports__.createOctaneCompilerPlugin;
+exports.pluginSourceDirectory = __webpack_exports__.pluginSourceDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createOctaneCompilerPlugin",
+    "pluginSourceDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/create.js

@@ -0,0 +1,266 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function generateOctaneAppSources(options) {
+    if ((options.entryName ?? 'main') !== 'main') throw new Error('The Octane app template supports the main entry only. The create-time workspace writer places src/modern-app-env.d.ts, src/routes/index.css and the package manifest at the app root regardless of entryName, so it cannot yet route a second entry into src/<entryName>/. Add that entry by hand after generation (mirror src/routes under src/<entryName>/routes) until an admitted native multi-entry create template exists; the native entry generator itself already supports arbitrary entry names.');
+    if (!options.appId.trim() || !options.title.trim()) throw new Error('The Octane app template requires an appId and title.');
+    if ('.tsx' !== options.sourceExtension) throw new Error('The Octane app template requires the admitted .tsx source profile. .tsrx generation requires an admitted native template profile.');
+    if ('octane' !== options.jsxImportSource) throw new Error('The Octane app template requires jsxImportSource: "octane" from the admitted profile.');
+    if ('boolean' != typeof options.capabilities.ssr || 'boolean' != typeof options.capabilities.federation) throw new Error('The Octane app template requires admitted capabilities.');
+    const title = JSON.stringify(options.title);
+    const aboutTitle = JSON.stringify(`${options.title} - About`);
+    const appId = JSON.stringify(options.appId);
+    return {
+        sourceExtension: '.tsx',
+        jsxImportSource: 'octane',
+        artifacts: [
+            {
+                path: 'src/routes/layout.tsx',
+                content: `import { Link, Outlet } from '@modern-js/renderer-octane/router';
+import Stable from '../components/stable';
+import './index.css';
+
+const appTitle = ${title};
+
+export default function Layout() {
+  return (
+    <main data-testid="native-layout">
+      <header>
+        <p>{appTitle}</p>
+        <nav aria-label="Application">
+          <Link to="/">Home</Link>
+          <Link to="/about">About</Link>
+${options.capabilities.federation ? '          <Link to="/remotes">Federated applications</Link>\n' : ''}
+        </nav>
+      </header>
+      <Stable />
+      <Outlet />
+    </main>
+  );
+}
+`
+            },
+            {
+                path: 'src/routes/page.tsx',
+                content: `import {
+  Link,
+  useLoaderData,
+  useOctaneRouteAction,
+} from '@modern-js/renderer-octane/router';
+import { useActionState } from 'octane';
+import Counter from '../components/counter';
+
+const appId = ${appId};
+const appTitle = ${title};
+
+export default function HomePage() {
+  const data = useLoaderData({ strict: false });
+  const submit = useOctaneRouteAction();
+  const [result, action, pending] = useActionState(submit, undefined);
+  return (
+    <section data-app-id={appId} data-testid="native-route" data-renderer="octane">
+      <h1>{appTitle}</h1>
+      <Counter />
+      <pre data-testid="native-loader-value">{JSON.stringify(data)}</pre>
+      <form action={action}>
+        <label>
+          Name <input name="name" />
+        </label>
+        <button type="submit" disabled={pending}>
+          Save
+        </button>
+        <button type="submit" name="intent" value="redirect">
+          Save and redirect
+        </button>
+      </form>
+      <pre data-testid="native-action-value">{JSON.stringify(result)}</pre>
+      <Link to="/about">Open native about route</Link>
+    </section>
+  );
+}
+`
+            },
+            {
+                path: 'src/routes/page.head.ts',
+                content: `import type { FileSystemRouteModule } from '@modern-js/renderer-octane/router';
+
+export const head: NonNullable<FileSystemRouteModule['head']> = () => ({
+  meta: [
+    { title: ${title} },
+    { name: 'description', content: 'Built with the native Octane renderer' },
+  ],
+});
+`
+            },
+            {
+                path: 'src/routes/about/page.tsx',
+                content: `import { Link } from '@modern-js/renderer-octane/router';
+
+export default function AboutPage() {
+  return (
+    <section data-testid="native-about">
+      <h1>Native Octane navigation</h1>
+      <Link to="/">Home</Link>
+    </section>
+  );
+}
+`
+            },
+            {
+                path: 'src/routes/about/page.head.ts',
+                content: `import type { FileSystemRouteModule } from '@modern-js/renderer-octane/router';
+
+export const head: NonNullable<FileSystemRouteModule['head']> = () => ({
+  meta: [
+    { title: ${aboutTitle} },
+    { name: 'description', content: 'Built with the native Octane renderer' },
+  ],
+});
+`
+            },
+            {
+                path: 'src/components/counter.tsx',
+                content: `import { useState } from 'octane';
+
+export default function Counter() {
+  const [count, setCount] = useState(0);
+  return (
+    <section data-testid="native-edited-component">
+      <span data-testid="native-hmr-marker">Counter before native edit</span>
+      <button type="button" onClick={() => setCount(value => value + 1)}>
+        Increment
+      </button>
+      <output data-testid="native-count">{count}</output>
+    </section>
+  );
+}
+`
+            },
+            {
+                path: 'src/components/stable.tsx',
+                content: `import { useState } from 'octane';
+
+export default function Stable() {
+  const [count, setCount] = useState(0);
+  return (
+    <section data-testid="native-unaffected-component">
+      <button type="button" onClick={() => setCount(value => value + 1)}>
+        Increment stable state
+      </button>
+      <output data-testid="native-unaffected-count">{count}</output>
+    </section>
+  );
+}
+`
+            },
+            {
+                path: 'src/routes/page.data.ts',
+                content: `import type { DataHandlerInput } from '@modern-js/renderer-core/data';
+
+export function loader({ request }: DataHandlerInput) {
+  const url = new URL(request.url);
+  if (url.searchParams.get('case') === 'not-found')
+    throw new Response('Native route not found', { status: 404 });
+  if (url.searchParams.get('case') === 'error')
+    throw new Error('Native loader failure');
+  if (url.searchParams.get('case') === 'redirect')
+    return new Response(null, { headers: { location: '/about' }, status: 302 });
+  return {
+    message: 'Native loader value',
+    privateValue: request.headers.get('x-conformance-private'),
+  };
+}
+
+export function action({ request }: DataHandlerInput) {
+  return request.formData().then(form => {
+    const name = form.get('name');
+    if (typeof name !== 'string' || name.trim().length === 0)
+      return Response.json(
+        { fieldErrors: { name: 'Name required' } },
+        { status: 422 },
+      );
+    if (form.get('intent') === 'redirect')
+      return new Response(null, {
+        headers: {
+          location: '/about',
+          'set-cookie': 'conformance-saved=1; Path=/; SameSite=Lax',
+        },
+        status: 303,
+      });
+    if (form.get('intent') === 'throw') throw new Error('Native action failure');
+    return {
+      saved: name,
+      privateValue: request.headers.get('x-conformance-private'),
+    };
+  });
+}
+`
+            },
+            {
+                path: 'src/routes/error.tsx',
+                content: `import type { ErrorRouteComponent } from '@modern-js/renderer-octane/router';
+
+const ErrorBoundary: ErrorRouteComponent = props => (
+  <section data-testid="native-error">
+    <h1>Something went wrong</h1>
+    <output>
+      {props.error instanceof Error ? props.error.message : String(props.error)}
+    </output>
+  </section>
+);
+
+export default ErrorBoundary;
+`
+            },
+            {
+                path: 'src/routes/not-found.tsx',
+                content: `import type { NotFoundRouteComponent } from '@modern-js/renderer-octane/router';
+
+const NotFound: NotFoundRouteComponent = () => (
+  <section data-testid="native-not-found">
+    <h1>Page not found</h1>
+  </section>
+);
+
+export default NotFound;
+`
+            }
+        ]
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    generateOctaneAppSources: ()=>generateOctaneAppSources
+});
+exports.generateOctaneAppSources = __webpack_exports__.generateOctaneAppSources;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateOctaneAppSources"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});