@bleedingdev/modern-js-bff-runtime 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+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/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_modules__ = {
+    "./match" (module) {
+        module.exports = require("./match.js");
+    },
+    "farrow-schema" (module) {
+        module.exports = require("farrow-schema");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+        isHandler: ()=>_match__rspack_import_1.isHandler,
+        isSchemaHandler: ()=>_match__rspack_import_1.isSchemaHandler,
+        match: ()=>_match__rspack_import_1.match
+    });
+    var farrow_schema__rspack_import_0 = __webpack_require__("farrow-schema");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in farrow_schema__rspack_import_0)if ([
+        "isHandler",
+        "default",
+        "isSchemaHandler",
+        "match"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>farrow_schema__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _match__rspack_import_1 = __webpack_require__("./match");
+})();
+exports.isHandler = __webpack_exports__.isHandler;
+exports.isSchemaHandler = __webpack_exports__.isSchemaHandler;
+exports.match = __webpack_exports__.match;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isHandler",
+    "isSchemaHandler",
+    "match"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/match.js

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    baseMatch: ()=>baseMatch,
+    isHandler: ()=>isHandler,
+    isSchemaHandler: ()=>isSchemaHandler,
+    match: ()=>match
+});
+const external_farrow_schema_namespaceObject = require("farrow-schema");
+const validator_namespaceObject = require("farrow-schema/validator");
+const external_response_js_namespaceObject = require("./response.js");
+const getErrorMessage = (error)=>{
+    let { message } = error;
+    if (Array.isArray(error.path) && error.path.length > 0) message = `path: ${JSON.stringify(error.path)}\n${message}`;
+    return message;
+};
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isSchemaHandler = (input)=>input && input?.[HANDLER_WITH_SCHEMA] === true;
+const isHandler = (input)=>input && 'function' == typeof input;
+const baseMatch = (schema, handler)=>{
+    const validateApiInput = createRequestSchemaValidator(schema.request);
+    const validateApiOutput = (0, validator_namespaceObject.createSchemaValidator)((0, external_farrow_schema_namespaceObject.toSchemaCtor)(schema.response));
+    const handle = async (input)=>{
+        const inputResult = validateApiInput(input);
+        if (inputResult.isErr) return (0, external_response_js_namespaceObject.InputValidationError)(getErrorMessage(inputResult.value));
+        const output = await handler(input);
+        const outputResult = validateApiOutput(output);
+        if (outputResult.isErr) return (0, external_response_js_namespaceObject.OutputValidationError)(getErrorMessage(outputResult.value));
+        return (0, external_response_js_namespaceObject.HandleSuccess)(output);
+    };
+    return Object.assign(handle, {
+        schema,
+        [HANDLER_WITH_SCHEMA]: true
+    });
+};
+const match = baseMatch;
+const createRequestSchemaValidator = (schema)=>{
+    const descriptors = {};
+    if (schema.params) descriptors.params = schema.params;
+    if (schema.query) descriptors.query = schema.query;
+    if (schema.data) descriptors.data = schema.data;
+    if (schema.headers) descriptors.headers = schema.headers;
+    if (schema.cookies) descriptors.cookies = schema.cookies;
+    const RequestStruct = (0, external_farrow_schema_namespaceObject.Struct)(descriptors);
+    return (0, validator_namespaceObject.createSchemaValidator)((0, external_farrow_schema_namespaceObject.NonStrict)(RequestStruct));
+};
+exports.baseMatch = __webpack_exports__.baseMatch;
+exports.isHandler = __webpack_exports__.isHandler;
+exports.isSchemaHandler = __webpack_exports__.isSchemaHandler;
+exports.match = __webpack_exports__.match;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "baseMatch",
+    "isHandler",
+    "isSchemaHandler",
+    "match"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/request.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/response.js

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    HandleSuccess: ()=>HandleSuccess,
+    InputValidationError: ()=>InputValidationError,
+    OutputValidationError: ()=>OutputValidationError
+});
+const HandleSuccess = (output)=>({
+        type: 'HandleSuccess',
+        value: output
+    });
+const InputValidationError = (message)=>({
+        type: 'InputValidationError',
+        message
+    });
+const OutputValidationError = (message)=>({
+        type: 'OutputValidationError',
+        message
+    });
+exports.HandleSuccess = __webpack_exports__.HandleSuccess;
+exports.InputValidationError = __webpack_exports__.InputValidationError;
+exports.OutputValidationError = __webpack_exports__.OutputValidationError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HandleSuccess",
+    "InputValidationError",
+    "OutputValidationError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/index.mjs

@@ -0,0 +1,2 @@
+export * from "farrow-schema";
+export { isHandler, isSchemaHandler, match } from "./match.mjs";

package/dist/esm/match.mjs

@@ -0,0 +1,39 @@
+import { NonStrict, Struct, toSchemaCtor } from "farrow-schema";
+import { createSchemaValidator } from "farrow-schema/validator";
+import { HandleSuccess, InputValidationError, OutputValidationError } from "./response.mjs";
+const getErrorMessage = (error)=>{
+    let { message } = error;
+    if (Array.isArray(error.path) && error.path.length > 0) message = `path: ${JSON.stringify(error.path)}\n${message}`;
+    return message;
+};
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isSchemaHandler = (input)=>input && input?.[HANDLER_WITH_SCHEMA] === true;
+const isHandler = (input)=>input && 'function' == typeof input;
+const baseMatch = (schema, handler)=>{
+    const validateApiInput = createRequestSchemaValidator(schema.request);
+    const validateApiOutput = createSchemaValidator(toSchemaCtor(schema.response));
+    const handle = async (input)=>{
+        const inputResult = validateApiInput(input);
+        if (inputResult.isErr) return InputValidationError(getErrorMessage(inputResult.value));
+        const output = await handler(input);
+        const outputResult = validateApiOutput(output);
+        if (outputResult.isErr) return OutputValidationError(getErrorMessage(outputResult.value));
+        return HandleSuccess(output);
+    };
+    return Object.assign(handle, {
+        schema,
+        [HANDLER_WITH_SCHEMA]: true
+    });
+};
+const match = baseMatch;
+const createRequestSchemaValidator = (schema)=>{
+    const descriptors = {};
+    if (schema.params) descriptors.params = schema.params;
+    if (schema.query) descriptors.query = schema.query;
+    if (schema.data) descriptors.data = schema.data;
+    if (schema.headers) descriptors.headers = schema.headers;
+    if (schema.cookies) descriptors.cookies = schema.cookies;
+    const RequestStruct = Struct(descriptors);
+    return createSchemaValidator(NonStrict(RequestStruct));
+};
+export { baseMatch, isHandler, isSchemaHandler, match };

package/dist/esm/response.mjs

@@ -0,0 +1,13 @@
+const HandleSuccess = (output)=>({
+        type: 'HandleSuccess',
+        value: output
+    });
+const InputValidationError = (message)=>({
+        type: 'InputValidationError',
+        message
+    });
+const OutputValidationError = (message)=>({
+        type: 'OutputValidationError',
+        message
+    });
+export { HandleSuccess, InputValidationError, OutputValidationError };

package/dist/esm-node/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export * from "farrow-schema";
+export { isHandler, isSchemaHandler, match } from "./match.mjs";

package/dist/esm-node/match.mjs

@@ -0,0 +1,40 @@
+import "node:module";
+import { NonStrict, Struct, toSchemaCtor } from "farrow-schema";
+import { createSchemaValidator } from "farrow-schema/validator";
+import { HandleSuccess, InputValidationError, OutputValidationError } from "./response.mjs";
+const getErrorMessage = (error)=>{
+    let { message } = error;
+    if (Array.isArray(error.path) && error.path.length > 0) message = `path: ${JSON.stringify(error.path)}\n${message}`;
+    return message;
+};
+const HANDLER_WITH_SCHEMA = 'HANDLER_WITH_SCHEMA';
+const isSchemaHandler = (input)=>input && input?.[HANDLER_WITH_SCHEMA] === true;
+const isHandler = (input)=>input && 'function' == typeof input;
+const baseMatch = (schema, handler)=>{
+    const validateApiInput = createRequestSchemaValidator(schema.request);
+    const validateApiOutput = createSchemaValidator(toSchemaCtor(schema.response));
+    const handle = async (input)=>{
+        const inputResult = validateApiInput(input);
+        if (inputResult.isErr) return InputValidationError(getErrorMessage(inputResult.value));
+        const output = await handler(input);
+        const outputResult = validateApiOutput(output);
+        if (outputResult.isErr) return OutputValidationError(getErrorMessage(outputResult.value));
+        return HandleSuccess(output);
+    };
+    return Object.assign(handle, {
+        schema,
+        [HANDLER_WITH_SCHEMA]: true
+    });
+};
+const match = baseMatch;
+const createRequestSchemaValidator = (schema)=>{
+    const descriptors = {};
+    if (schema.params) descriptors.params = schema.params;
+    if (schema.query) descriptors.query = schema.query;
+    if (schema.data) descriptors.data = schema.data;
+    if (schema.headers) descriptors.headers = schema.headers;
+    if (schema.cookies) descriptors.cookies = schema.cookies;
+    const RequestStruct = Struct(descriptors);
+    return createSchemaValidator(NonStrict(RequestStruct));
+};
+export { baseMatch, isHandler, isSchemaHandler, match };

package/dist/esm-node/request.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/response.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+const HandleSuccess = (output)=>({
+        type: 'HandleSuccess',
+        value: output
+    });
+const InputValidationError = (message)=>({
+        type: 'InputValidationError',
+        message
+    });
+const OutputValidationError = (message)=>({
+        type: 'OutputValidationError',
+        message
+    });
+export { HandleSuccess, InputValidationError, OutputValidationError };

package/dist/esm-node/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from 'farrow-schema';
+export type { Handler, SchemaHandler } from './match';
+export { isHandler, isSchemaHandler, match } from './match';
+export type { InputType, RequestSchema, TypeOfRequestSchema } from './request';
+export type { HandleResult, HandleSuccess, InputValidationError, OutputValidationError, } from './response';

package/dist/types/match.d.ts

@@ -0,0 +1,27 @@
+import type { MaybeAsync } from 'farrow-pipeline';
+import { type SchemaCtorInput } from 'farrow-schema';
+import type { PureTypeOfRequestSchema, RequestSchema, TypeOfRequestSchema } from './request';
+import { type HandleResult } from './response';
+import type { TypeOfRouterRequestField } from './types';
+export type NormalHandler = (...args: any[]) => any;
+export type Handler<I, O> = (input: I) => MaybeAsync<O>;
+export type Schema<Req extends RequestSchema, Res extends SchemaCtorInput> = {
+    request: Req;
+    response: Res;
+    description?: string;
+    deprecated?: string;
+};
+declare const HANDLER_WITH_SCHEMA = "HANDLER_WITH_SCHEMA";
+export type BaseSchemaHandler<Req extends RequestSchema, Res extends SchemaCtorInput> = ((input: TypeOfRequestSchema<Req>) => Promise<HandleResult<TypeOfRouterRequestField<Res>>>) & {
+    schema: Schema<Req, Res>;
+    [HANDLER_WITH_SCHEMA]: true;
+};
+export type SchemaHandler<Req extends RequestSchema, Res extends SchemaCtorInput> = ((input: TypeOfRequestSchema<Req>) => Promise<TypeOfRouterRequestField<Res>>) & {
+    schema: Schema<Req, Res>;
+    [HANDLER_WITH_SCHEMA]: true;
+};
+export declare const isSchemaHandler: (input: any) => input is SchemaHandler<any, any>;
+export declare const isHandler: (input: any) => input is Handler<any, any>;
+export declare const baseMatch: <Req extends RequestSchema, Res extends SchemaCtorInput>(schema: Schema<Req, Res>, handler: Handler<TypeOfRequestSchema<Req>, TypeOfRouterRequestField<Res>>) => BaseSchemaHandler<Req, Res>;
+export declare const match: <Req extends RequestSchema, Res extends SchemaCtorInput>(schema: Schema<Req, Res>, handler: Handler<PureTypeOfRequestSchema<Req>, TypeOfRouterRequestField<Res>>) => SchemaHandler<Req, Res>;
+export {};

package/dist/types/request.d.ts

@@ -0,0 +1,47 @@
+import type { FieldDescriptor, FieldDescriptors, TypeOfFieldDescriptor, TypeOfFieldDescriptors } from 'farrow-schema';
+import type { MarkReadOnlyDeep, RouterSchemaDescriptor } from './types';
+export type RequestBaseSchema = {
+    params?: RouterSchemaDescriptor;
+    query?: RouterSchemaDescriptor;
+    headers?: RouterSchemaDescriptor;
+    cookies?: RouterSchemaDescriptor;
+};
+export type RequestDataSchema = {
+    data?: RouterSchemaDescriptor;
+};
+export type RequestBodyType = {
+    body?: string;
+};
+export type PureRequestFormDataType = {
+    formData?: Record<string, any>;
+};
+export type RequestFormDataType = {
+    formData?: FormData;
+};
+export type RequestFormUrlencodedType = {
+    formUrlencoded?: URLSearchParams | Record<string, string> | string;
+};
+export type PureRequestFormUrlencodedType = {
+    formUrlencoded?: Record<string, string>;
+};
+export type RequestExtraType = RequestBodyType & RequestFormDataType & RequestFormUrlencodedType;
+export type PureRequestExtraType = RequestBodyType & PureRequestFormDataType & PureRequestFormUrlencodedType;
+export type RequestSchema = RequestBaseSchema & RequestDataSchema;
+export type TypeOfRequestField<T> = T extends string ? string : T extends FormData ? FormData : T extends FieldDescriptor ? TypeOfFieldDescriptor<T> : T extends FieldDescriptors ? TypeOfFieldDescriptors<T> : never;
+export type TypeOfRequestDataSchema<T extends RequestDataSchema> = MarkReadOnlyDeep<T extends {
+    data: any;
+} ? Pick<{
+    [key in keyof T]: TypeOfRequestField<T[key]>;
+}, 'data'> : RequestExtraType>;
+export type TypeOfRequestSchema<T extends RequestSchema> = MarkReadOnlyDeep<Omit<{
+    [key in keyof T]: TypeOfRequestField<T[key]>;
+}, 'data'> & TypeOfRequestDataSchema<T>>;
+export type PureTypeOfRequestDataSchema<T extends RequestDataSchema> = MarkReadOnlyDeep<T extends {
+    data: any;
+} ? Pick<{
+    [key in keyof T]: TypeOfRequestField<T[key]>;
+}, 'data'> : PureRequestExtraType>;
+export type PureTypeOfRequestSchema<T extends RequestSchema> = MarkReadOnlyDeep<Omit<{
+    [key in keyof T]: TypeOfRequestField<T[key]>;
+}, 'data'> & PureTypeOfRequestDataSchema<T>>;
+export type InputType = TypeOfRequestSchema<RequestSchema>;

package/dist/types/response.d.ts

@@ -0,0 +1,16 @@
+export type HandleSuccess<T> = {
+    type: 'HandleSuccess';
+    value: T;
+};
+export declare const HandleSuccess: <T>(output: T) => HandleSuccess<T>;
+export type InputValidationError = {
+    type: 'InputValidationError';
+    message: string;
+};
+export declare const InputValidationError: (message: string) => InputValidationError;
+export type OutputValidationError = {
+    type: 'OutputValidationError';
+    message: string;
+};
+export declare const OutputValidationError: (message: string) => OutputValidationError;
+export type HandleResult<T> = HandleSuccess<T> | InputValidationError | OutputValidationError;

package/dist/types/types.d.ts

@@ -0,0 +1,8 @@
+import type * as Schema from 'farrow-schema';
+type Path = string | RegExp | Array<string | RegExp>;
+export type TypeOfRouterRequestField<T> = T extends string | string[] ? string : T extends Path ? string : T extends Schema.FieldDescriptor ? Schema.TypeOfFieldDescriptor<T> : T extends Schema.FieldDescriptors ? Schema.TypeOfFieldDescriptors<T> : never;
+export type RouterSchemaDescriptor = Schema.FieldDescriptors | (new () => Schema.ObjectType) | (new () => Schema.StructType);
+export type MarkReadOnlyDeep<T> = T extends {} | any[] ? {
+    readonly [key in keyof T]: MarkReadOnlyDeep<T[key]>;
+} : T;
+export {};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@bleedingdev/modern-js-bff-runtime",
+  "description": "A Progressive React Framework for modern web development.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/server/bff-runtime"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "3.2.0-ultramodern.0",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "^0.5.21",
+    "farrow-api": "^2.3.1",
+    "farrow-pipeline": "^2.3.0",
+    "farrow-schema": "^2.3.3"
+  },
+  "devDependencies": {
+    "@rslib/core": "0.21.5",
+    "@types/node": "^25.8.0",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest --passWithNoTests"
+  }
+}

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -0,0 +1,5 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  globals: true,
+});