@cleanweb/oore 2.0.0-alpha.34 → 2.0.0-alpha.36

package/build/base/index.d.ts

@@ -1,3 +1,3 @@
-export * from './state/index.js';
-export * from './methods.js';
-export * from './merged-state.js';
+export * from './state';
+export * from './methods';
+export * from './merged-state';

package/build/base/index.js

@@ -1,3 +1,19 @@
-export * from './state/index.js';
-export * from './methods.js';
-export * from './merged-state.js';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./state"), exports);
+__exportStar(require("./methods"), exports);
+__exportStar(require("./merged-state"), exports);

package/build/base/merged-state.d.ts

@@ -1,3 +1,4 @@
+import '../globals';
 declare class MergedState<TState extends object> {
     static useRefresh<TState extends object>(this: MergedState<TState>): void;
     reservedKeys: string[];

package/build/base/merged-state.js

@@ -1,56 +1,84 @@
-import { useMemo, useRef, useState } from 'react';
-class MergedState {
-    static useRefresh() {
-        [this._values_, this.setState] = useState(this.initialState);
-    }
-    get put() {
-        return Object.assign({}, this._setters_);
-    }
-    get initialState() {
-        return Object.assign({}, this._initialValues_);
-    }
-    constructor(initialState) {
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMergedState = void 0;
+require("../globals");
+var react_1 = require("react");
+var MergedState = /** @class */ (function () {
+    function MergedState(initialState) {
+        var _this = this;
         this._initialValues_ = {};
         this._values_ = {};
         this._setters_ = {};
-        this.putMany = (newValues) => {
-            this.setState(Object.assign(Object.assign({}, this._values_), newValues));
+        this.putMany = function (newValues) {
+            _this.setState(__assign(__assign({}, _this._values_), newValues));
         };
         this.reservedKeys = Object.keys(this);
         this.valueKeys = [];
-        this._initialValues_ = Object.assign({}, initialState);
-        this._values_ = Object.assign({}, initialState);
-        Object.keys(initialState).forEach((_key) => {
-            const key = _key;
-            if (this.reservedKeys.includes(key)) {
-                throw new Error(`The name "${key}" is reserved by CleanState and cannot be used to index state variables. Please use a different key.`);
+        this._initialValues_ = __assign({}, initialState);
+        this._values_ = __assign({}, initialState);
+        Object.keys(initialState).forEach(function (_key) {
+            var key = _key;
+            if (_this.reservedKeys.includes(key)) {
+                throw new Error("The name \"".concat(key, "\" is reserved by CleanState and cannot be used to index state variables. Please use a different key."));
             }
-            this.valueKeys.push(key);
-            this._setters_[key] = (value) => {
+            _this.valueKeys.push(key);
+            _this._setters_[key] = function (value) {
+                var _a;
                 // this._values_[key] = value;
-                this.setState(Object.assign(Object.assign({}, this._values_), { [key]: value }));
+                _this.setState(__assign(__assign({}, _this._values_), (_a = {}, _a[key] = value, _a)));
             };
-            const self = this;
-            Object.defineProperty(this, key, {
-                get() {
+            var self = _this;
+            Object.defineProperty(_this, key, {
+                get: function () {
                     return self._values_[key];
                 },
-                set(value) {
+                set: function (value) {
                     self._setters_[key](value);
                 },
                 enumerable: true,
             });
         });
     }
-}
+    MergedState.useRefresh = function () {
+        var _a;
+        _a = (0, react_1.useState)(this.initialState), this._values_ = _a[0], this.setState = _a[1];
+    };
+    Object.defineProperty(MergedState.prototype, "put", {
+        get: function () {
+            return __assign({}, this._setters_);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MergedState.prototype, "initialState", {
+        get: function () {
+            return __assign({}, this._initialValues_);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MergedState;
+}());
 /**
  * Similar to {@link useCleanState},
  * but uses a single `useState` call for the entire state object.
  */
-export const useMergedState = (initialState) => {
-    const cleanState = useRef(useMemo(() => {
+var useMergedState = function (initialState) {
+    var cleanState = (0, react_1.useRef)((0, react_1.useMemo)(function () {
         return new MergedState(initialState);
     }, [])).current;
     MergedState.useRefresh.call(cleanState);
     return cleanState;
 };
+exports.useMergedState = useMergedState;

package/build/base/methods.d.ts

@@ -1,6 +1,7 @@
 /**
  * @module ComponentMethods
  */
+import type { TCleanState, TStateData } from './state';
 /**
  * @summary
  * Base class for a class that holds methods for a function component.
@@ -11,9 +12,9 @@
  *
  * Call the {@link useMethods} hook inside your function component to instantiate the class.
  */
-export declare class ComponentMethods<TProps extends object = {}, TState extends object | null = null> {
+export declare class ComponentMethods<TProps extends object = {}, TState extends TStateData | null = null> {
     readonly props: TProps;
-    readonly state: TState;
+    readonly state: TState extends TStateData ? TCleanState<TState> : null;
     /**
      * Persist class members during HMR. {@include ../classy/logic/hrm-preserve-keys.md}
      * @privateRemarks
@@ -28,9 +29,9 @@ export declare class ComponentMethods<TProps extends object = {}, TState extends
     _onHmrUpdate?: <TInstance extends this>(oldInstance: TInstance) => void;
 }
 type UseMethods = {
-    <Class extends typeof ComponentMethods<object, object>>(Methods: Class, props: InstanceType<Class>['props'], state: InstanceType<Class>['state']): InstanceType<Class>;
-    <Class extends typeof ComponentMethods<object, null>>(Methods: Class, props: InstanceType<Class>['props'], state?: null): InstanceType<Class>;
-    <Class extends typeof ComponentMethods<NeverObject, null>>(Methods: Class): InstanceType<Class>;
+    <Class extends typeof ComponentMethods<object, object>>(Methods: Class & Constructor<InstanceType<Class>>, props: InstanceType<Class>['props'], state: InstanceType<Class>['state']): InstanceType<Class>;
+    <Class extends typeof ComponentMethods<object, null>>(Methods: Class & Constructor<InstanceType<Class>>, props: InstanceType<Class>['props'], state?: null): InstanceType<Class>;
+    <Class extends typeof ComponentMethods<NeverObject, null>>(Methods: Class & Constructor<InstanceType<Class>>): InstanceType<Class>;
 };
 /**
  * Returns an instance of the provided class,

package/build/base/methods.js

@@ -1,8 +1,11 @@
+"use strict";
 /**
  * @module ComponentMethods
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMethods = exports.ComponentMethods = void 0;
 // Values
-import { useMemo, useRef } from 'react';
+var react_1 = require("react");
 /**
  * @summary
  * Base class for a class that holds methods for a function component.
@@ -13,8 +16,8 @@ import { useMemo, useRef } from 'react';
  *
  * Call the {@link useMethods} hook inside your function component to instantiate the class.
  */
-export class ComponentMethods {
-    constructor() {
+var ComponentMethods = /** @class */ (function () {
+    function ComponentMethods() {
         /**
          * Persist class members during HMR. {@include ../classy/logic/hrm-preserve-keys.md}
          * @privateRemarks
@@ -22,7 +25,9 @@ export class ComponentMethods {
          */
         this._hmrPreserveKeys = []; // @todo Keep undefined. Update to empty array after instantiation in dev env.
     }
-}
+    return ComponentMethods;
+}());
+exports.ComponentMethods = ComponentMethods;
 ;
 /**
  * Returns an instance of the provided class,
@@ -30,9 +35,13 @@ export class ComponentMethods {
  *
  * `state` should be an instance of `CleanState` created with {@link useCleanState}.
  */
-const useMethods = (...args) => {
+var useMethods = function () {
     var _a;
-    const [Methods, props = {}, state] = args;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var Methods = args[0], _b = args[1], props = _b === void 0 ? {} : _b, state = args[2];
     // Vite HMR seems to sometimes reinitialize useMemo calls after a hot update,
     // causing the instance to be unexpectedly recreated in the middle of the component's lifecycle.
     // But useRef and useState values appear to always be preserved whenever this happens.
@@ -40,9 +49,9 @@ const useMethods = (...args) => {
     // In production, we only use the latestInstance the first time, and it's ignored every other time.
     // This means changing the class at runtime will have no effect in production.
     // latestInstance is only extracted into a separate variable for use in dev mode during HMR.
-    const latestInstance = useMemo(() => new Methods(), [Methods]);
-    const instanceRef = useRef(latestInstance);
-    const refreshState = () => {
+    var latestInstance = (0, react_1.useMemo)(function () { return new Methods(); }, [Methods]);
+    var instanceRef = (0, react_1.useRef)(latestInstance);
+    var refreshState = function () {
         // @ts-expect-error
         instanceRef.current.props = props;
         // @ts-expect-error
@@ -50,29 +59,29 @@ const useMethods = (...args) => {
             instanceRef.current.state = state;
     };
     if (process.env.NODE_ENV === 'development' && instanceRef.current !== latestInstance) {
-        const oldInstance = instanceRef.current;
-        latestInstance._hmrPreserveKeys.forEach((_key) => {
-            const key = _key;
+        var oldInstance_1 = instanceRef.current;
+        latestInstance._hmrPreserveKeys.forEach(function (_key) {
+            var key = _key;
             // @ts-expect-error We're assigning to readonly properties. Also, Typescript doesn't know that the type of the left and right side will always match, due to the dynamic access.
-            latestInstance[key] = oldInstance[key];
+            latestInstance[key] = oldInstance_1[key];
         });
         // Ensure that any stale references to oldInstance within the app
         // will end up retrieving up-to-date values from latestInstance
         // through the prototype chain.
-        Reflect.ownKeys(oldInstance).forEach((_key) => {
-            const key = _key;
-            delete oldInstance[key];
+        Reflect.ownKeys(oldInstance_1).forEach(function (_key) {
+            var key = _key;
+            delete oldInstance_1[key];
         });
-        Object.setPrototypeOf(oldInstance, latestInstance);
+        Object.setPrototypeOf(oldInstance_1, latestInstance);
         instanceRef.current = latestInstance;
         refreshState();
-        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance);
+        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance_1);
     }
     else
         refreshState();
     return instanceRef.current;
 };
-export { useMethods };
+exports.useMethods = useMethods;
 /** /type_testing: {
     let a = async () => {
         const a: object = {b: ''};

package/build/base/state/class-types.d.ts

@@ -1,5 +1,5 @@
-import { CleanStateBase } from './class.js';
-import { TCleanState, TStateData } from './hook-types.js';
+import { CleanStateBase } from './class';
+import { TCleanState, TStateData } from './hook-types';
 export type TCleanStateBase = typeof CleanStateBase;
 export type TCleanStateBaseKeys = keyof TCleanStateBase;
 export type PutState<TState extends TStateData> = {

package/build/base/state/class-types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/base/state/class.d.ts

@@ -1,4 +1,4 @@
-import type { ICleanStateClass, ICleanStateConstructor, PutManyPayload, PutState } from './class-types.js';
+import type { ICleanStateClass, ICleanStateConstructor, PutManyPayload, PutState } from './class-types';
 /** @internal */
 export declare class CleanStateBase<TState extends Record<string, any>> {
     readonly reservedKeys: string[];

package/build/base/state/class.js

@@ -1,7 +1,22 @@
-import { useState } from 'react';
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CleanState = exports.CleanStateBase = void 0;
+var react_1 = require("react");
 /** @internal */
-export class CleanStateBase {
-    constructor(initialState) {
+var CleanStateBase = /** @class */ (function () {
+    function CleanStateBase(initialState) {
+        var _this = this;
         this._values_ = {};
         this._setters_ = {};
         /**
@@ -57,10 +72,10 @@ export class CleanStateBase {
          *     </>;
          * };
          */
-        this.putMany = (newValues) => {
-            Object.entries(newValues).forEach((entry) => {
-                const [key, value] = entry;
-                this.put[key](value);
+        this.putMany = function (newValues) {
+            Object.entries(newValues).forEach(function (entry) {
+                var _a = entry, key = _a[0], value = _a[1];
+                _this.put[key](value);
             });
         };
         this.reservedKeys = Object.keys(this);
@@ -74,52 +89,64 @@ export class CleanStateBase {
          * and they will always be processed in a consistent order during rerenders.
          */
         this.valueKeys = Object.keys(initialState);
-        this._initialValues_ = Object.assign({}, initialState);
-        this.valueKeys.forEach((key) => {
-            if (this.reservedKeys.includes(key))
-                throw new Error(`The name "${key}" is reserved by CleanState and cannot be used to index state variables. Please use a different key.`);
-            const self = this;
-            Object.defineProperty(this, key, {
-                get() {
+        this._initialValues_ = __assign({}, initialState);
+        this.valueKeys.forEach(function (key) {
+            if (_this.reservedKeys.includes(key))
+                throw new Error("The name \"".concat(key, "\" is reserved by CleanState and cannot be used to index state variables. Please use a different key."));
+            var self = _this;
+            Object.defineProperty(_this, key, {
+                get: function () {
                     return self._values_[key];
                 },
-                set(value) {
+                set: function (value) {
                     self._setters_[key](value);
                 },
                 enumerable: true,
             });
         });
     }
-    get put() {
-        return Object.assign({}, this._setters_);
-    }
-    get initialState() {
-        return Object.assign({}, this._initialValues_);
-    }
-}
-CleanStateBase.update = function update() {
-    if (!(this instanceof CleanState))
-        throw new Error('CleanState.update must be called with `this` value set to a CleanState instance. Did you forget to use `.call` or `.apply`? Example: CleanState.update.call(cleanState);');
-    /**
-     * Linters complain about the use of a React hook within a loop because:
-     * > By following this rule, you ensure that Hooks are called in the same order each time a component renders.
-     * > That’s what allows React to correctly preserve the state of Hooks between multiple useState and useEffect calls.
-     * To resolve this, we're calling `useState` via an alias `retrieveState`.
-     * Bypassing this rule is safe here because `useCleanState` is a special case,
-     * and it guarantees that the same useState calls will be made on every render in the exact same order.
-     * Therefore, it is safe to silence the linters, and required for this implementation to work smoothly.
-     */
-    const retrieveState = useState;
-    this.valueKeys.forEach((key) => {
-        // @todo Make state updates accessible immediately. Use state.staged to access the scheduled updates.
-        let setter;
-        [this._values_[key], setter] = retrieveState(this.initialState[key]);
-        this._setters_[key] = ((valueOrCallback) => {
-            // this._staged_[key] = value;
-            setter(valueOrCallback);
-        });
+    Object.defineProperty(CleanStateBase.prototype, "put", {
+        get: function () {
+            return __assign({}, this._setters_);
+        },
+        enumerable: false,
+        configurable: true
     });
-};
+    Object.defineProperty(CleanStateBase.prototype, "initialState", {
+        get: function () {
+            return __assign({}, this._initialValues_);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CleanStateBase.update = function update() {
+        var _this = this;
+        if (!(this instanceof exports.CleanState))
+            throw new Error('CleanState.update must be called with `this` value set to a CleanState instance. Did you forget to use `.call` or `.apply`? Example: CleanState.update.call(cleanState);');
+        /**
+         * Linters complain about the use of a React hook within a loop because:
+         * > By following this rule, you ensure that Hooks are called in the same order each time a component renders.
+         * > That’s what allows React to correctly preserve the state of Hooks between multiple useState and useEffect calls.
+         * To resolve this, we're calling `useState` via an alias `retrieveState`.
+         * Bypassing this rule is safe here because `useCleanState` is a special case,
+         * and it guarantees that the same useState calls will be made on every render in the exact same order.
+         * Therefore, it is safe to silence the linters, and required for this implementation to work smoothly.
+         */
+        var retrieveState = react_1.useState;
+        this.valueKeys.forEach(function (key) {
+            var _a;
+            // @todo Make state updates accessible immediately. Use state.staged to access the scheduled updates.
+            var setter;
+            _a = retrieveState(_this.initialState[key]), _this._values_[key] = _a[0], setter = _a[1];
+            _this._setters_[key] = (function (valueOrCallback) {
+                // this._staged_[key] = value;
+                setter(valueOrCallback);
+            });
+        });
+    };
+    return CleanStateBase;
+}());
+exports.CleanStateBase = CleanStateBase;
 ;
 /** @internal */
-export const CleanState = (CleanStateBase);
+exports.CleanState = (CleanStateBase);

package/build/base/state/hook-types.d.ts

@@ -1,4 +1,4 @@
-import { CleanStateBase } from './class.js';
+import { CleanStateBase } from './class';
 /**
  * Base type for an `initialState` object.
  * It is a regular object type, with some reserved keys excluded.

package/build/base/state/hook-types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/base/state/hooks.d.ts

@@ -1,4 +1,4 @@
-import { TUseCleanState } from './hook-types.js';
+import { TUseCleanState } from './hook-types';
 /**
  * Creates a state object, which includes the provided values,
  * as well as helper methods for updating those values and automatically

package/build/base/state/hooks.js

@@ -1,5 +1,8 @@
-import { useMemo, useRef } from 'react';
-import { CleanState } from './class.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCleanState = void 0;
+var react_1 = require("react");
+var class_1 = require("./class");
 /**
  * Creates a state object, which includes the provided values,
  * as well as helper methods for updating those values and automatically
@@ -10,17 +13,22 @@ import { CleanState } from './class.js';
  *
  * Discussion: [When to `useCleanState`](https://cleanjsweb.github.io/neat-react/documents/Clean_State.html).
  */
-export const useCleanState = (_initialState, ...props) => {
-    const initialState = typeof _initialState === 'function'
-        ? useMemo(() => _initialState(...props), [])
+var useCleanState = function (_initialState) {
+    var props = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        props[_i - 1] = arguments[_i];
+    }
+    var initialState = typeof _initialState === 'function'
+        ? (0, react_1.useMemo)(function () { return _initialState.apply(void 0, props); }, [])
         : _initialState;
     ;
-    const cleanState = useRef(useMemo(() => {
-        return new CleanState(initialState);
+    var cleanState = (0, react_1.useRef)((0, react_1.useMemo)(function () {
+        return new class_1.CleanState(initialState);
     }, [])).current;
-    CleanState.update.call(cleanState);
+    class_1.CleanState.update.call(cleanState);
     return cleanState;
 };
+exports.useCleanState = useCleanState;
 // Should be valid.
 // useCleanState((a: number) => ({b: a.toString(), q: 1}), 6);
 // useCleanState((a: boolean) => ({b: a.toString()}), true);

package/build/base/state/index.d.ts

@@ -1,8 +1,9 @@
 /**
  * @module CleanState
  */
-export { CleanState } from './class.js';
-export { useCleanState } from './hooks.js';
-export type { TCleanState, TStateData, ExtractCleanStateData } from './hook-types.js';
-export type { SF, StateFragment } from './class-types.js';
-export * as MergedState from '../../base/merged-state.js';
+import '../../globals';
+export { CleanState } from './class';
+export { useCleanState } from './hooks';
+export type { TCleanState, TStateData, ExtractCleanStateData } from './hook-types';
+export type { SF, StateFragment } from './class-types';
+export * as MergedState from '../../base/merged-state';

package/build/base/state/index.js

@@ -1,6 +1,35 @@
+"use strict";
 /**
  * @module CleanState
  */
-export { CleanState } from './class.js';
-export { useCleanState } from './hooks.js';
-export * as MergedState from '../../base/merged-state.js';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedState = exports.useCleanState = exports.CleanState = void 0;
+require("../../globals");
+var class_1 = require("./class");
+Object.defineProperty(exports, "CleanState", { enumerable: true, get: function () { return class_1.CleanState; } });
+var hooks_1 = require("./hooks");
+Object.defineProperty(exports, "useCleanState", { enumerable: true, get: function () { return hooks_1.useCleanState; } });
+exports.MergedState = __importStar(require("../../base/merged-state"));

package/build/classy/class/index.d.ts

@@ -1,7 +1,6 @@
-import type React from 'react';
-import type { TPropsBase } from '../logic/index.js';
-import type { Extractor } from './types/extractor.js';
-import { ComponentInstance } from '../instance/index.js';
+import type { TPropsBase } from '../logic';
+import type { Extractor } from './types/extractor';
+import { ComponentInstance } from '../instance';
 /**
  * @summary
  * A modern class component for React that is fully compatible with
@@ -66,14 +65,6 @@ export declare class ClassComponent<TProps extends TPropsBase = null> extends Co
      * Note that the callback argument is currently not supported.
      */
     readonly forceUpdate: VoidFunction;
-    /**
-     * A standard React function component that works like any
-     * other function component and can be rendered as JSX.
-     * \`<MyComponent.FC />\`
-     */
-    static _FC<T extends typeof ClassComponent>(this: T, props: InstanceType<T>['props']): JSX.Element | null;
-    static _BoundFC: typeof this._FC | undefined;
-    static get FC(): typeof ClassComponent._FC;
     /*************************************
      *   Function Component Extractor    *
     **************************************/
@@ -101,12 +92,8 @@ export declare class ClassComponent<TProps extends TPropsBase = null> extends Co
      * export default Button.RC;
      */
     static readonly extract: Extractor;
-    /**
-     * A standard React function component that works like any
-     * other function component and can be rendered as JSX.
-     * \`<MyComponent.RC />\`
-     */
-    static readonly RC: React.VoidFunctionComponent<object | EmptyObject>;
+    /** @see {@link ClassComponent.extract} */
+    static readonly FC: Extractor;
 }
 export { ClassComponent as Component };
 /** /