styled-components 5.3.6 → 5.3.11

package/native/dist/base.d.ts

@@ -3,16 +3,10 @@ import createGlobalStyle from './constructors/createGlobalStyle';
 import css from './constructors/css';
 import keyframes from './constructors/keyframes';
 import withTheme from './hoc/withTheme';
-import useTheme from './hooks/useTheme';
 import ServerStyleSheet from './models/ServerStyleSheet';
-import StyleSheetManager, { StyleSheetConsumer, StyleSheetContext } from './models/StyleSheetManager';
-import ThemeProvider, { ThemeConsumer, ThemeContext } from './models/ThemeProvider';
+import { IStyleSheetContext, IStyleSheetManager, IStylisContext, StyleSheetConsumer, StyleSheetContext, StyleSheetManager } from './models/StyleSheetManager';
+import ThemeProvider, { ThemeConsumer, ThemeContext, useTheme } from './models/ThemeProvider';
 import isStyledComponent from './utils/isStyledComponent';
-declare global {
-    interface Window {
-        '__styled-components-init__'?: number;
-    }
-}
 export * from './secretInternals';
 export { Attrs, DefaultTheme, ShouldForwardProp } from './types';
-export { createGlobalStyle, css, isStyledComponent, keyframes, ServerStyleSheet, StyleSheetConsumer, StyleSheetContext, StyleSheetManager, ThemeConsumer, ThemeContext, ThemeProvider, useTheme, SC_VERSION as version, withTheme, };
+export { createGlobalStyle, css, isStyledComponent, IStyleSheetManager, IStyleSheetContext, IStylisContext, keyframes, ServerStyleSheet, StyleSheetConsumer, StyleSheetContext, StyleSheetManager, ThemeConsumer, ThemeContext, ThemeProvider, useTheme, SC_VERSION as version, withTheme, };

package/native/dist/constructors/constructWithOptions.d.ts

@@ -1,15 +1,40 @@
-/// <reference types="react" />
-import { Attrs, ExecutionContext, ExtensibleObject, Interpolation, IStyledComponent, IStyledComponentFactory, KnownTarget, Runtime, StyledOptions, StyledTarget, Styles } from '../types';
-export interface Styled<R extends Runtime, Target extends StyledTarget<R>, DerivedProps = Target extends KnownTarget ? React.ComponentProps<Target> : unknown, OuterProps extends {} = {}, OuterStatics = unknown> {
-    <Props = unknown, Statics = unknown>(initialStyles: Styles<DerivedProps & OuterProps & Props>, ...interpolations: Interpolation<ExecutionContext & DerivedProps & OuterProps & Props>[]): IStyledComponent<R, Target, DerivedProps & OuterProps & Props> & OuterStatics & Statics;
-    attrs(attrs: Attrs<ExtensibleObject & DerivedProps & OuterProps>): Styled<R, Target, DerivedProps, OuterProps, OuterStatics>;
-    withConfig(config: StyledOptions<R, DerivedProps & OuterProps>): Styled<R, Target, DerivedProps, OuterProps, OuterStatics>;
-}
-export default function constructWithOptions<R extends Runtime, Target extends StyledTarget<R>, DerivedProps = Target extends KnownTarget ? React.ComponentProps<Target> : unknown, OuterProps = unknown, // used for styled<{}>().attrs() so attrs() gets the generic prop context
-OuterStatics = unknown>(componentConstructor: IStyledComponentFactory<R, any, any, any>, tag: Target, options?: StyledOptions<R, DerivedProps & OuterProps>): {
-    <Props extends {} = {}, Statics = unknown>(initialStyles: Styles<DerivedProps & OuterProps & Props>, ...interpolations: Interpolation<ExecutionContext & DerivedProps & OuterProps & Props>[]): IStyledComponent<R, Target, DerivedProps & OuterProps & Props> & OuterStatics & Statics;
-    attrs(attrs: Attrs<ExtensibleObject & DerivedProps & OuterProps>): any;
-    /**
-     * If config methods are called, wrap up a new template function and merge options */
-    withConfig(config: StyledOptions<R, DerivedProps & OuterProps>): any;
+import React from 'react';
+import { Attrs, DataAttributes, ExecutionContext, ExecutionProps, Interpolation, IStyledComponent, IStyledComponentFactory, KnownTarget, NoInfer, Runtime, StyledOptions, StyledTarget, Styles, SubsetOnly } from '../types';
+/**
+ * for types a and b, if b shares a field with a, mark a's field as optional
+ */
+type OptionalIntersection<A, B> = {
+    [K in Extract<keyof A, keyof B>]?: A[K];
 };
+type AttrsResult<T extends Attrs> = T extends (...args: any) => infer P ? P : T;
+type ExtractAttrsTarget<R extends Runtime, P extends ExecutionProps, DefaultTarget extends StyledTarget<R>> = P['as'] extends KnownTarget ? P['as'] : DefaultTarget;
+/**
+ * If attrs type is a function (no type provided, inferring from usage), extract the return value
+ * and merge it with the existing type to hole-punch any required fields that are satisfied as
+ * a result of running attrs. Otherwise if we have a definite type then union the base props
+ * with the passed attr type to capture any intended overrides.
+ */
+type PropsSatisfiedByAttrs<T extends Attrs, Props extends object, Result extends ExecutionProps = AttrsResult<T>> = Omit<Props, keyof Result> & OptionalIntersection<Props, Result> & Partial<Omit<Result, keyof Props | 'as'>>;
+/**
+ * Rejects an attr factory function argument (T) if it returns any properties not defined in Props.
+ */
+type StrictAttrFactory<T, Props> = T extends ((props: ExecutionContext & Props) => infer TResult) ? TResult extends SubsetOnly<TResult, (Partial<Props> & ExecutionProps & DataAttributes & React.AriaAttributes)> ? (props: ExecutionContext & Props) => TResult : never : never;
+export interface Styled<R extends Runtime, Target extends StyledTarget<R>, OuterProps extends object = object, OuterStatics extends object = object, RuntimeInjectedProps extends ExecutionProps = object> {
+    <Props extends object = object, Statics extends object = object>(initialStyles: Styles<OuterProps & RuntimeInjectedProps & NoInfer<Props>>, ...interpolations: Interpolation<OuterProps & RuntimeInjectedProps & NoInfer<Props>>[]): // @ts-expect-error KnownTarget is a subset of StyledTarget<R>
+    IStyledComponent<R, ExtractAttrsTarget<R, RuntimeInjectedProps, Target>, OuterProps & Props> & OuterStatics & Statics;
+    /**
+     * This is a chainable method that attaches some props to a styled component.
+     * @param props An object containing prop values that will be merged into the rest of the component's props
+     * @argument Props Additional props being injected in `props`
+     */
+    attrs<Props extends object = object, PropValues extends Partial<OuterProps> & ExecutionProps & DataAttributes & React.AriaAttributes & NoInfer<Props> = Partial<OuterProps> & ExecutionProps & DataAttributes & React.AriaAttributes & NoInfer<Props>>(props: PropValues & SubsetOnly<PropValues, Partial<OuterProps> & ExecutionProps & DataAttributes & React.AriaAttributes & NoInfer<Props>>): Styled<R, Target, PropsSatisfiedByAttrs<PropValues, OuterProps>, OuterStatics, Omit<RuntimeInjectedProps, keyof PropValues> & PropValues>;
+    /**
+     * This is a chainable method that attaches some props to a styled component.
+     * @param propFactory A function that receives the props that are passed into the component and computes a value, that is then going to be merged into the existing component props.
+     * @argument Props Additional props being returned by `propFactory`
+     */
+    attrs<Props extends object = object, Factory extends ((...args: any[]) => any) = (...args: any[]) => any, TTarget extends StyledTarget<R> = ExtractAttrsTarget<R, AttrsResult<Factory>, Target>>(propFactory: Factory & StrictAttrFactory<Factory, OuterProps & NoInfer<Props>>): Styled<R, TTarget, PropsSatisfiedByAttrs<Factory, OuterProps>, OuterStatics, Omit<RuntimeInjectedProps, keyof AttrsResult<Factory>> & AttrsResult<Factory>>;
+    withConfig: (config: StyledOptions<R, OuterProps>) => Styled<R, Target, OuterProps, OuterStatics>;
+}
+export default function constructWithOptions<R extends Runtime, Target extends StyledTarget<R>, OuterProps extends object = Target extends KnownTarget ? React.ComponentPropsWithRef<Target> : object, OuterStatics extends object = object>(componentConstructor: IStyledComponentFactory<R, Target, OuterProps, OuterStatics>, tag: Target, options?: StyledOptions<R, OuterProps>): Styled<R, Target, OuterProps, OuterStatics>;
+export {};

package/native/dist/constructors/createGlobalStyle.d.ts

@@ -1,3 +1,3 @@
 import React from 'react';
-import { ExtensibleObject, Interpolation, Styles } from '../types';
-export default function createGlobalStyle<Props = unknown>(strings: Styles<Props>, ...interpolations: Array<Interpolation<Props>>): React.NamedExoticComponent<ExtensibleObject>;
+import { ExecutionProps, Interpolation, Styles } from '../types';
+export default function createGlobalStyle<Props extends object>(strings: Styles<Props>, ...interpolations: Array<Interpolation<Props>>): React.NamedExoticComponent<ExecutionProps & Props>;

package/native/dist/constructors/css.d.ts

@@ -1,4 +1,4 @@
-import { Interpolation, StyledObject, StyleFunction, Styles } from '../types';
-export default function css<Props>(styles: Styles<Props>, ...interpolations: Interpolation<Props>[]): string | number | false | import("../types").Keyframes | import("../types").IStyledComponent<"web", any, any> | TemplateStringsArray | StyledObject<Props> | StyleFunction<Props> | (Interpolation<Props>[] & {
-    isCss?: boolean | undefined;
-}) | null | undefined;
+import { Interpolation, RuleSet, Styles } from '../types';
+declare function css(styles: Styles<object>, ...interpolations: Interpolation<object>[]): RuleSet<object>;
+declare function css<Props extends object>(styles: Styles<Props>, ...interpolations: Interpolation<Props>[]): RuleSet<Props>;
+export default css;

package/native/dist/constructors/keyframes.d.ts

@@ -1,3 +1,3 @@
 import Keyframes from '../models/Keyframes';
 import { Interpolation, Styles } from '../types';
-export default function keyframes<Props = unknown>(strings: Styles<Props>, ...interpolations: Array<Interpolation<Props>>): Keyframes;
+export default function keyframes<Props extends object = object>(strings: Styles<Props>, ...interpolations: Array<Interpolation<Props>>): Keyframes;