victory-core 36.7.0 → 36.8.2

package/src/v37/victory-state/types.ts

@@ -1,32 +0,0 @@
-import {
-  D3ScaleFn,
-  Datum,
-  DomainTuple,
-  RangeTuple,
-  ScalePropType,
-  ValueOrAxes,
-} from "../../types/prop-types";
-import { PaddingProps } from "../../victory-theme/types";
-
-// These are all the props that are used to calculate data, domain, range, and scale
-export interface VictoryCalculatedStateProps {
-  data?: Datum[];
-  domain?: ValueOrAxes<DomainTuple>;
-  height?: number;
-  includeZero?: boolean;
-  maxDomain?: ValueOrAxes<number>;
-  minDomain?: ValueOrAxes<number>;
-  padding?: PaddingProps;
-  range?: ValueOrAxes<RangeTuple>;
-  samples?: number;
-  scale?: ValueOrAxes<ScalePropType | D3ScaleFn>;
-  sortKey?: string;
-  sortOrder?: "ascending" | "descending";
-  width?: number;
-  x?: string;
-  y?: string;
-}
-
-export interface VictoryProviderProps extends VictoryCalculatedStateProps {
-  children?: React.ReactNode;
-}

package/src/v37/victory-state/victory-provider.tsx

@@ -1,152 +0,0 @@
-import * as React from "react";
-import { createContext, useContext } from "react";
-import { D3ScaleFn, DomainTuple, ForAxes } from "../../types/prop-types";
-import { FormattedDatum, getData } from "./helpers/get-data";
-import { getDomain } from "./helpers/get-domain";
-import { getRange } from "./helpers/get-range";
-import { getScale } from "./helpers/get-scale";
-import { VictoryCalculatedStateProps, VictoryProviderProps } from "./types";
-
-type ScaleType = Required<ForAxes<D3ScaleFn>>;
-type DomainType = Required<ForAxes<DomainTuple>>;
-
-export interface ContextType {
-  data: FormattedDatum[];
-  scale: ScaleType;
-  domain: DomainType;
-  updateChildProps: (id: symbol, props: VictoryProviderProps | null) => void;
-}
-
-const VictoryContext = createContext<ContextType | null>(null);
-
-type CollectedProps = { [id: symbol]: VictoryCalculatedStateProps };
-
-function useNormalizedProps(): ContextType {
-  const [collectedProps, setCollectedProps] = React.useState<CollectedProps>(
-    {},
-  );
-
-  const updateChildProps = React.useCallback(
-    (id: symbol, newProps: VictoryCalculatedStateProps | null) => {
-      setCollectedProps((prev) => {
-        const result = { ...prev };
-        if (newProps === null) {
-          delete result[id];
-        } else {
-          result[id] = newProps;
-        }
-        return result;
-      });
-    },
-    [],
-  );
-
-  // TEMP: combine all props into a single result:
-  // TODO: instead, we should intelligently aggregate all these props
-  const props = Object.values(
-    collectedProps,
-  ).reduce<VictoryCalculatedStateProps>(
-    (result, childProps) => Object.assign(result, childProps),
-    {},
-  );
-
-  const data = React.useMemo(() => {
-    return getData(props);
-  }, [props]);
-
-  const domain = React.useMemo(() => {
-    return {
-      x: getDomain(props, "x"),
-      y: getDomain(props, "y"),
-    };
-  }, [props]);
-
-  const range = React.useMemo(
-    () => ({
-      x: getRange(props, "x"),
-      y: getRange(props, "y"),
-    }),
-    [props],
-  );
-
-  const scale = React.useMemo(() => {
-    const xBaseScaleFn = getScale(props, "x");
-    const yBaseScaleFn = getScale(props, "y");
-
-    // @ts-expect-error: This is a valid scale function
-    const xScaleFn = xBaseScaleFn().domain(domain.x).range(range.x);
-    // @ts-expect-error: This is a valid scale function
-    const yScaleFn = yBaseScaleFn().domain(domain.y).range(range.y);
-
-    return {
-      x: xScaleFn,
-      y: yScaleFn,
-    };
-  }, [props, domain, range]);
-
-  const normalizedProps = React.useMemo(
-    () => ({
-      scale,
-      data,
-      domain,
-      updateChildProps,
-    }),
-    [scale, data, domain, updateChildProps],
-  );
-
-  return normalizedProps;
-}
-
-export function VictoryProvider({
-  children,
-  // Disabled due to TODO below which will require this obj. spread
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  ...providerProps
-}: VictoryProviderProps) {
-  const value = useNormalizedProps();
-
-  // TODO: sync the providerProps
-
-  return (
-    <VictoryContext.Provider value={value}>{children}</VictoryContext.Provider>
-  );
-}
-
-export function useVictoryContextMaybe<T>(
-  selector: (value: ContextType | null) => T,
-): T {
-  const context = useContext(VictoryContext);
-  return selector(context);
-}
-
-export function useVictoryContext<T>(selector: (value: ContextType) => T): T {
-  const context = useContext(VictoryContext);
-  if (!context) {
-    throw new Error("useVictoryContext must be used within a VictoryProvider");
-  }
-  return selector(context);
-}
-
-export function useScale() {
-  return useVictoryContext<ScaleType>((value) => value.scale);
-}
-
-export function useData() {
-  return useVictoryContext<FormattedDatum[]>((value) => value.data);
-}
-
-export function useDomain() {
-  return useVictoryContext<DomainType>((value) => value.domain);
-}
-
-// This function keeps props in sync betwen the VictoryProvider and child components
-export function useVictoryProviderSync(props: VictoryCalculatedStateProps) {
-  const updateChildProps = useVictoryContext((value) => value.updateChildProps);
-  const [myId] = React.useState(() =>
-    Symbol("UniqueIdFor(VictoryProviderChild)"),
-  );
-
-  React.useEffect(() => {
-    updateChildProps(myId, props);
-  }, [updateChildProps, props, myId]);
-}

package/src/v37/victory-state/with-victory-provider.tsx

@@ -1,53 +0,0 @@
-import * as React from "react";
-import { useVictoryContextMaybe, VictoryProvider } from "./victory-provider";
-import { VictoryCommonProps } from "../../victory-util/common-props";
-import { Clone } from "../clone";
-import { VictoryProviderProps } from "./types";
-
-/* eslint-disable react/prop-types */
-
-/**
- * Ensures the component is wrapped by a VictoryProvider, if not already.
- */
-export function withVictoryProvider<
-  TComp extends React.FC<TProps>,
-  TProps extends React.PropsWithChildren<VictoryCommonProps>,
->(Comp: TComp): TComp {
-  const WithVictoryProvider = React.memo((props: TProps) => {
-    const updateChildProps = useVictoryContextMaybe(
-      (value) => value?.updateChildProps,
-    );
-    const hasParentProvider = !!updateChildProps;
-
-    React.useEffect(() => {
-      if (!hasParentProvider) return;
-
-      const id = Symbol("WithVictoryProvider");
-      updateChildProps(id, props as VictoryProviderProps);
-      // eslint-disable-next-line consistent-return
-      return () => updateChildProps(id, null);
-    });
-
-    // @ts-expect-error "TProps not assignable to LibraryManagedAttributes"
-    let result = <Comp {...props}>{props.children}</Comp>;
-
-    if (!hasParentProvider) {
-      // Wrap with a parent Provider:
-      result = (
-        <VictoryProvider>
-          <Clone element={props.containerComponent} {...props}>
-            {result}
-          </Clone>
-        </VictoryProvider>
-      );
-    }
-    return result;
-  });
-  const name = Comp.displayName || Comp.name;
-  WithVictoryProvider.displayName = name
-    ? `WithVictoryProvider(${name})`
-    : "WithVictoryProvider";
-
-  // @ts-expect-error "WithVictoryProvider does not overlap with TComp"
-  return WithVictoryProvider as TComp;
-}

package/src/v37/with-container.tsx

@@ -1,38 +0,0 @@
-import React from "react";
-import { VictoryProvider, VictoryProviderProps } from "./victory-state";
-import { VictoryContainer } from "../victory-container/victory-container";
-import { VictoryCommonProps } from "../victory-util/common-props";
-
-const defaultProviderProps = {
-  width: 450,
-  height: 300,
-  padding: 50,
-  data: [],
-};
-
-export function withContainer<Props extends VictoryCommonProps>(
-  WrappedComponent: React.FC<Props>,
-  initialProviderProps: Partial<VictoryProviderProps> = {},
-): React.FC<Props> {
-  return (props: Props) => {
-    const providerProps = {
-      ...defaultProviderProps,
-      ...initialProviderProps,
-      ...props,
-    };
-    const { standalone = true, containerComponent = <VictoryContainer /> } =
-      props;
-    if (standalone) {
-      return (
-        <VictoryProvider {...providerProps}>
-          {React.cloneElement(
-            containerComponent,
-            providerProps,
-            <WrappedComponent {...props} />,
-          )}
-        </VictoryProvider>
-      );
-    }
-    return <WrappedComponent {...props} />;
-  };
-}

package/src/v37/with-normalized-props.tsx

@@ -1,43 +0,0 @@
-import { VictoryCommonProps } from "../victory-util/common-props";
-import React from "react";
-import {
-  useVictoryContext,
-  VictoryProviderProps,
-  withVictoryProvider,
-} from "./victory-state";
-
-type FC<TProps> = (props: TProps) => JSX.Element;
-
-export function withNormalizedProps<
-  TProps extends React.PropsWithChildren<VictoryCommonProps>,
-  TDefaultPropKeys extends keyof TProps,
->(
-  config: {
-    displayName: string;
-    propTypes?: React.WeakValidationMap<Omit<TProps, keyof VictoryCommonProps>>;
-    defaultProps: Pick<TProps, TDefaultPropKeys>;
-    /** @deprecated */
-    initialProviderProps?: Partial<VictoryProviderProps>;
-  },
-  WrappedComponent: React.FC<TProps>,
-) {
-  WrappedComponent.displayName = config.displayName;
-  const WithNormalizedProps: FC<TProps> = withVictoryProvider<
-    FC<TProps>,
-    TProps
-  >((props: TProps) => {
-    const normalizedProps = useVictoryContext((v) => v);
-
-    return (
-      <WrappedComponent {...props} {...normalizedProps}>
-        {props.children}
-      </WrappedComponent>
-    );
-  });
-
-  return Object.assign(WithNormalizedProps, {
-    displayName: `WithNormalizedProps(${config.displayName}`,
-    defaultProps: config.defaultProps,
-    propTypes: config.propTypes,
-  });
-}