@object-ui/react-runtime 11.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ObjectQL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ObjectUI — @object-ui/react-runtime (ADR: kind:'react')
+ *
+ * Inlined, vendored react-runner (github.com/nihgwu/react-runner, MIT): transpile
+ * a JSX/TSX source string with Sucrase, then eval it with an injected scope
+ * (React, your registered components, page data) and render in the MAIN React
+ * tree. NO sandbox — this is the *trusted* execution tier, gated to enterprise/
+ * private deployments where authors are trusted. Inlined (not depended) so we
+ * fully control the scope/imports surface and can lazy-load it behind a flag.
+ */
+import { Component, type ReactElement, type ReactNode } from 'react';
+export type Scope = Record<string, unknown>;
+/** Transpile JSX/TS → JS (classic runtime; imports → require). */
+export declare const transform: (code: string) => string;
+/** Transpile + eval a source string into a React element (or null). */
+export declare function generateElement(code: string, scope?: Scope): ReactElement | null;
+export interface ReactRunnerProps {
+    code: string;
+    scope?: Scope;
+    /** rendered when the code throws at transpile/eval/render time */
+    fallback?: (error: Error) => ReactNode;
+    onError?: (error: Error) => void;
+}
+interface ReactRunnerState {
+    element: ReactElement | null;
+    error: Error | null;
+}
+/** Renders a JSX/TSX source string with a built-in error boundary. */
+export declare class ReactRunner extends Component<ReactRunnerProps, ReactRunnerState> {
+    state: ReactRunnerState;
+    static getDerivedStateFromProps(props: ReactRunnerProps): Partial<ReactRunnerState> | null;
+    static getDerivedStateFromError(error: Error): Partial<ReactRunnerState>;
+    componentDidUpdate(): void;
+    render(): ReactNode;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,78 @@
+/**
+ * ObjectUI — @object-ui/react-runtime (ADR: kind:'react')
+ *
+ * Inlined, vendored react-runner (github.com/nihgwu/react-runner, MIT): transpile
+ * a JSX/TSX source string with Sucrase, then eval it with an injected scope
+ * (React, your registered components, page data) and render in the MAIN React
+ * tree. NO sandbox — this is the *trusted* execution tier, gated to enterprise/
+ * private deployments where authors are trusted. Inlined (not depended) so we
+ * fully control the scope/imports surface and can lazy-load it behind a flag.
+ */
+import React, { Component, createElement, isValidElement } from 'react';
+import { transform as sucrase } from 'sucrase';
+const normalizeCode = (code) => code.replace(/^(\s*)(<[^>]*>|function[(\s]|\(\)[\s=]|class\s)(.*)/, '$1export default $2$3');
+/** Transpile JSX/TS → JS (classic runtime; imports → require). */
+export const transform = (code) => sucrase(code, { transforms: ['jsx', 'typescript', 'imports'], production: true }).code.substring(13);
+const createRequire = (imports = {}) => (module) => {
+    if (!Object.prototype.hasOwnProperty.call(imports, module)) {
+        throw new Error(`Module not found: '${module}' — provide it via the runtime scope.imports`);
+    }
+    return imports[module];
+};
+const evalCode = (code, scope) => {
+    const { default: _d, import: imports, ...rest } = scope;
+    const finalScope = { React, require: createRequire(imports), ...rest };
+    const keys = Object.keys(finalScope);
+    // eslint-disable-next-line no-new-func
+    return new Function(...keys, code)(...keys.map((k) => finalScope[k]));
+};
+/** Transpile + eval a source string into a React element (or null). */
+export function generateElement(code, scope = {}) {
+    if (!code.trim())
+        return null;
+    const exports = {};
+    evalCode(transform(normalizeCode(code)), { render: (v) => (exports.default = v), ...scope, exports });
+    const result = exports.default;
+    if (!result)
+        return null;
+    if (isValidElement(result))
+        return result;
+    if (typeof result === 'function')
+        return createElement(result);
+    return null;
+}
+/** Renders a JSX/TSX source string with a built-in error boundary. */
+export class ReactRunner extends Component {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { element: null, error: null }
+        });
+    }
+    static getDerivedStateFromProps(props) {
+        try {
+            return { element: generateElement(props.code, props.scope), error: null };
+        }
+        catch (error) {
+            return { element: null, error: error };
+        }
+    }
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidUpdate() {
+        if (this.state.error)
+            this.props.onError?.(this.state.error);
+    }
+    render() {
+        if (this.state.error) {
+            return this.props.fallback
+                ? this.props.fallback(this.state.error)
+                : createElement('pre', { style: { color: 'crimson', padding: 16, whiteSpace: 'pre-wrap' } }, String(this.state.error));
+        }
+        return this.state.element;
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@object-ui/react-runtime",
+  "version": "11.3.0",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "description": "Trusted runtime React execution for kind:'react' pages — vendored react-runner (Sucrase transpile + scope-eval, no sandbox). Enterprise/private-deploy tier.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "sucrase": "^3.35.0"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}