@depup/react-live 4.1.8-depup.0 → 5.0.0-depup.0

package/README.md

@@ -13,17 +13,10 @@ npm install @depup/react-live
 
 | Field | Value |
 |-------|-------|
-| Original | [react-live](https://www.npmjs.com/package/react-live) @ 4.1.8 |
-| Processed | 2026-03-18 |
-| Smoke test | failed |
-| Deps updated | 2 |
-
-## Dependency Changes
-
-| Dependency | From | To |
-|------------|------|-----|
-| prism-react-renderer | ^2.4.0 | ^2.4.1 |
-| sucrase | ^3.35.0 | ^3.35.1 |
+| Original | [react-live](https://www.npmjs.com/package/react-live) @ 5.0.0 |
+| Processed | 2026-09-27 |
+| Smoke test | passed |
+| Deps updated | 0 |
 
 ---
 

package/changes.json

@@ -1,14 +1,5 @@
 {
-  "bumped": {
-    "prism-react-renderer": {
-      "from": "^2.4.0",
-      "to": "^2.4.1"
-    },
-    "sucrase": {
-      "from": "^3.35.0",
-      "to": "^3.35.1"
-    }
-  },
-  "timestamp": "2026-03-18T23:30:47.259Z",
-  "totalUpdated": 2
+  "bumped": {},
+  "timestamp": "2026-09-27T01:02:02.585Z",
+  "totalUpdated": 0
 }

package/dist/index.d.mts

@@ -0,0 +1,166 @@
+import { Prism, themes } from "prism-react-renderer";
+import React, { CSSProperties, ComponentType, PropsWithChildren } from "react";
+//#region src/components/Editor/index.d.ts
+type Props$3 = {
+  className?: string;
+  code: string;
+  disabled?: boolean;
+  language: string;
+  prism?: typeof Prism;
+  style?: CSSProperties;
+  tabMode?: "focus" | "indentation";
+  theme?: typeof themes.nightOwl;
+  onChange?(value: string): void;
+};
+declare const CodeEditor: (props: Props$3) => import("react").JSX.Element;
+//#endregion
+//#region src/components/Live/LiveProvider.d.ts
+type Props$2 = {
+  code?: string;
+  disabled?: boolean;
+  enableTypeScript?: boolean;
+  language?: string;
+  noInline?: boolean;
+  scope?: Record<string, unknown>;
+  theme?: typeof themes.nightOwl;
+  transformCode?(code: string): void;
+};
+declare function LiveProvider({ children, code, language, theme, enableTypeScript, disabled, scope, transformCode, noInline }: PropsWithChildren<Props$2>): import("react").JSX.Element;
+//#endregion
+//#region src/components/Live/LiveEditor.d.ts
+declare function LiveEditor(props: Partial<Props$3>): React.JSX.Element;
+//#endregion
+//#region src/components/Live/LiveError.d.ts
+declare function LiveError<T extends Record<string, unknown>>(props: T): React.JSX.Element | null;
+//#endregion
+//#region src/components/Live/LivePreview.d.ts
+type Props$1<T extends React.ElementType = React.ElementType> = {
+  Component?: T;
+} & React.ComponentPropsWithoutRef<T>;
+declare function LivePreview<T extends keyof React.JSX.IntrinsicElements>(props: Props$1<T>): React.JSX.Element;
+declare function LivePreview<T extends React.ElementType>(props: Props$1<T>): React.JSX.Element;
+//#endregion
+//#region src/components/Live/LiveContext.d.ts
+type LiveContextValue = {
+  error?: string;
+  element?: ComponentType | null;
+  code: string;
+  newCode?: string;
+  disabled: boolean;
+  language: string;
+  theme?: typeof themes.nightOwl;
+  onError(error: Error): void;
+  onChange(value: string): void;
+};
+declare const LiveContext: import("react").Context<LiveContextValue>;
+//#endregion
+//#region src/hoc/withLive.d.ts
+type Props = {
+  live: LiveContextValue;
+};
+declare function withLive<T>(WrappedComponent: ComponentType<T & Props>): {
+  (props: T): React.JSX.Element;
+  displayName: string;
+};
+//#endregion
+//#region src/utils/transpile/index.d.ts
+type GenerateOptions = {
+  code: string;
+  scope?: Record<string, unknown>;
+  enableTypeScript: boolean;
+};
+export declare const generateElement: ({ code, scope, enableTypeScript }: GenerateOptions, errorCallback: (error: Error) => void) => {
+  new (props: Record<string, never>): {
+    state: {
+      hasError: boolean;
+    };
+    componentDidCatch(error: Error): void;
+    render(): React.JSX.Element | null;
+    context: unknown;
+    setState<K extends "hasError">(state: Pick<{
+      hasError: boolean;
+    }, K> | ((prevState: Readonly<{
+      hasError: boolean;
+    }>, props: Readonly<Record<string, never>>) => Pick<{
+      hasError: boolean;
+    }, K> | {
+      hasError: boolean;
+    } | null) | {
+      hasError: boolean;
+    } | null, callback?: (() => void) | undefined): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    readonly props: Readonly<Record<string, never>>;
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    getSnapshotBeforeUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>): any;
+    componentDidUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>, snapshot?: any): void;
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+  };
+  new (props: Record<string, never>, context: any): {
+    state: {
+      hasError: boolean;
+    };
+    componentDidCatch(error: Error): void;
+    render(): React.JSX.Element | null;
+    context: unknown;
+    setState<K extends "hasError">(state: Pick<{
+      hasError: boolean;
+    }, K> | ((prevState: Readonly<{
+      hasError: boolean;
+    }>, props: Readonly<Record<string, never>>) => Pick<{
+      hasError: boolean;
+    }, K> | {
+      hasError: boolean;
+    } | null) | {
+      hasError: boolean;
+    } | null, callback?: (() => void) | undefined): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    readonly props: Readonly<Record<string, never>>;
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    getSnapshotBeforeUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>): any;
+    componentDidUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>, snapshot?: any): void;
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+  };
+  getDerivedStateFromError(): {
+    hasError: boolean;
+  };
+  contextType?: React.Context<any> | undefined;
+  propTypes?: any;
+};
+export declare const renderElementAsync: ({ code, scope, enableTypeScript }: GenerateOptions, resultCallback: (sender: ComponentType) => void, errorCallback: (error: Error) => void) => void;
+//#endregion
+export { CodeEditor as Editor, LiveContext, LiveEditor, LiveError, LivePreview, LiveProvider, withLive };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.ts

@@ -1,117 +1,166 @@
-import { Prism, themes } from 'prism-react-renderer';
-import * as React from 'react';
-import React__default, { CSSProperties, PropsWithChildren, ComponentType } from 'react';
-
+import { Prism, themes } from "prism-react-renderer";
+import React, { CSSProperties, ComponentType, PropsWithChildren } from "react";
+//#region src/components/Editor/index.d.ts
 type Props$3 = {
-    className?: string;
-    code: string;
-    disabled?: boolean;
-    language: string;
-    prism?: typeof Prism;
-    style?: CSSProperties;
-    tabMode?: "focus" | "indentation";
-    theme?: typeof themes.nightOwl;
-    onChange?(value: string): void;
+  className?: string;
+  code: string;
+  disabled?: boolean;
+  language: string;
+  prism?: typeof Prism;
+  style?: CSSProperties;
+  tabMode?: "focus" | "indentation";
+  theme?: typeof themes.nightOwl;
+  onChange?(value: string): void;
 };
-declare const CodeEditor: (props: Props$3) => JSX.Element;
-
+declare const CodeEditor: (props: Props$3) => import("react").JSX.Element;
+//#endregion
+//#region src/components/Live/LiveProvider.d.ts
 type Props$2 = {
-    code?: string;
-    disabled?: boolean;
-    enableTypeScript?: boolean;
-    language?: string;
-    noInline?: boolean;
-    scope?: Record<string, unknown>;
-    theme?: typeof themes.nightOwl;
-    transformCode?(code: string): void;
+  code?: string;
+  disabled?: boolean;
+  enableTypeScript?: boolean;
+  language?: string;
+  noInline?: boolean;
+  scope?: Record<string, unknown>;
+  theme?: typeof themes.nightOwl;
+  transformCode?(code: string): void;
 };
-declare function LiveProvider({ children, code, language, theme, enableTypeScript, disabled, scope, transformCode, noInline, }: PropsWithChildren<Props$2>): JSX.Element;
-
-declare function LiveEditor(props: Partial<Props$3>): JSX.Element;
-
-declare function LiveError<T extends Record<string, unknown>>(props: T): JSX.Element | null;
-
-type Props$1<T extends React__default.ElementType = React__default.ElementType> = {
-    Component?: T;
-} & React__default.ComponentPropsWithoutRef<T>;
-declare function LivePreview<T extends keyof JSX.IntrinsicElements>(props: Props$1<T>): JSX.Element;
-declare function LivePreview<T extends React__default.ElementType>(props: Props$1<T>): JSX.Element;
-
-type ContextValue = {
-    error?: string;
-    element?: ComponentType | null;
-    code: string;
-    newCode?: string;
-    disabled: boolean;
-    language: string;
-    theme?: typeof themes.nightOwl;
-    onError(error: Error): void;
-    onChange(value: string): void;
+declare function LiveProvider({ children, code, language, theme, enableTypeScript, disabled, scope, transformCode, noInline }: PropsWithChildren<Props$2>): import("react").JSX.Element;
+//#endregion
+//#region src/components/Live/LiveEditor.d.ts
+declare function LiveEditor(props: Partial<Props$3>): React.JSX.Element;
+//#endregion
+//#region src/components/Live/LiveError.d.ts
+declare function LiveError<T extends Record<string, unknown>>(props: T): React.JSX.Element | null;
+//#endregion
+//#region src/components/Live/LivePreview.d.ts
+type Props$1<T extends React.ElementType = React.ElementType> = {
+  Component?: T;
+} & React.ComponentPropsWithoutRef<T>;
+declare function LivePreview<T extends keyof React.JSX.IntrinsicElements>(props: Props$1<T>): React.JSX.Element;
+declare function LivePreview<T extends React.ElementType>(props: Props$1<T>): React.JSX.Element;
+//#endregion
+//#region src/components/Live/LiveContext.d.ts
+type LiveContextValue = {
+  error?: string;
+  element?: ComponentType | null;
+  code: string;
+  newCode?: string;
+  disabled: boolean;
+  language: string;
+  theme?: typeof themes.nightOwl;
+  onError(error: Error): void;
+  onChange(value: string): void;
 };
-declare const LiveContext: React.Context<ContextValue>;
-
+declare const LiveContext: import("react").Context<LiveContextValue>;
+//#endregion
+//#region src/hoc/withLive.d.ts
 type Props = {
-    live: Record<string, unknown>;
+  live: LiveContextValue;
 };
 declare function withLive<T>(WrappedComponent: ComponentType<T & Props>): {
-    (props: T): JSX.Element;
-    displayName: string;
+  (props: T): React.JSX.Element;
+  displayName: string;
 };
-
+//#endregion
+//#region src/utils/transpile/index.d.ts
 type GenerateOptions = {
-    code: string;
-    scope?: Record<string, unknown>;
-    enableTypeScript: boolean;
+  code: string;
+  scope?: Record<string, unknown>;
+  enableTypeScript: boolean;
 };
-declare const generateElement: ({ code, scope, enableTypeScript }: GenerateOptions, errorCallback: (error: Error) => void) => {
-    new (props: {} | Readonly<{}>): {
-        componentDidCatch(error: Error): void;
-        render(): JSX.Element | null;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<{}>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React__default.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+export declare const generateElement: ({ code, scope, enableTypeScript }: GenerateOptions, errorCallback: (error: Error) => void) => {
+  new (props: Record<string, never>): {
+    state: {
+      hasError: boolean;
     };
-    new (props: {}, context: any): {
-        componentDidCatch(error: Error): void;
-        render(): JSX.Element | null;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<{}>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React__default.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    componentDidCatch(error: Error): void;
+    render(): React.JSX.Element | null;
+    context: unknown;
+    setState<K extends "hasError">(state: Pick<{
+      hasError: boolean;
+    }, K> | ((prevState: Readonly<{
+      hasError: boolean;
+    }>, props: Readonly<Record<string, never>>) => Pick<{
+      hasError: boolean;
+    }, K> | {
+      hasError: boolean;
+    } | null) | {
+      hasError: boolean;
+    } | null, callback?: (() => void) | undefined): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    readonly props: Readonly<Record<string, never>>;
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    getSnapshotBeforeUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>): any;
+    componentDidUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>, snapshot?: any): void;
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+  };
+  new (props: Record<string, never>, context: any): {
+    state: {
+      hasError: boolean;
     };
-    contextType?: React__default.Context<any> | undefined;
+    componentDidCatch(error: Error): void;
+    render(): React.JSX.Element | null;
+    context: unknown;
+    setState<K extends "hasError">(state: Pick<{
+      hasError: boolean;
+    }, K> | ((prevState: Readonly<{
+      hasError: boolean;
+    }>, props: Readonly<Record<string, never>>) => Pick<{
+      hasError: boolean;
+    }, K> | {
+      hasError: boolean;
+    } | null) | {
+      hasError: boolean;
+    } | null, callback?: (() => void) | undefined): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    readonly props: Readonly<Record<string, never>>;
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    getSnapshotBeforeUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>): any;
+    componentDidUpdate?(prevProps: Readonly<Record<string, never>>, prevState: Readonly<{
+      hasError: boolean;
+    }>, snapshot?: any): void;
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Record<string, never>>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<Record<string, never>>, nextState: Readonly<{
+      hasError: boolean;
+    }>, nextContext: any): void;
+  };
+  getDerivedStateFromError(): {
+    hasError: boolean;
+  };
+  contextType?: React.Context<any> | undefined;
+  propTypes?: any;
 };
-declare const renderElementAsync: ({ code, scope, enableTypeScript }: GenerateOptions, resultCallback: (sender: ComponentType) => void, errorCallback: (error: Error) => void) => void;
-
-export { CodeEditor as Editor, LiveContext, LiveEditor, LiveError, LivePreview, LiveProvider, generateElement, renderElementAsync, withLive };
+export declare const renderElementAsync: ({ code, scope, enableTypeScript }: GenerateOptions, resultCallback: (sender: ComponentType) => void, errorCallback: (error: Error) => void) => void;
+//#endregion
+export { CodeEditor as Editor, LiveContext, LiveEditor, LiveError, LivePreview, LiveProvider, withLive };
+//# sourceMappingURL=index.d.ts.map