@apollion-dsi/core 3.0.0

package/lib/factory/BorderFactory/BorderFactory.interface.d.ts

@@ -0,0 +1,47 @@
+import { BorderThemeType } from '../../themes/Border';
+import { BgColorsTypes } from '../../themes/Colors';
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Conjunto de "atalhos" semânticos para `border-radius` reconhecidos pelo
+ * `BorderFactory`.
+ *
+ * Cada chave descreve um padrão de arredondamento aplicado a cantos
+ * específicos. `round` aplica o raio em todos os cantos; as variantes
+ * `roundX` / `sharpX` permitem controle granular sem precisar montar o
+ * shorthand de `border-radius` manualmente.
+ */
+export type BorderRoundPropsType = 'round' | 'roundBottom' | 'roundTop' | 'roundRight' | 'roundLeft' | 'roundTopLeft' | 'roundTopRight' | 'roundBottomLeft' | 'roundBottomRight' | 'roundTangentRight' | 'roundTangentLeft' | 'sharpTopLeft' | 'sharpTopRight' | 'sharpBottomRight' | 'sharpBottomLeft';
+/**
+ * Mapa parcial de `BorderRoundPropsType` para o valor de raio aplicado.
+ *
+ * O valor pode ser um token do tema (`theme.border.borderRadius`) ou um
+ * número — nesse caso é interpretado como índice da escala de spacing
+ * (`theme.spacing(n)`).
+ */
+export type BorderRoundProps = Partial<Record<BorderRoundPropsType, BorderThemeType['borderRadius'] | number>>;
+/**
+ * Props consumidas pelo `BorderFactory`.
+ *
+ * Combina três grupos: bordas convencionais (cor/largura/estilo via
+ * `BorderThemeType`), atalhos semânticos de raio (`BorderRoundProps`) e
+ * controles auxiliares como `borderPosition` e `square`.
+ *
+ * `square` tem precedência sobre qualquer raio configurado.
+ */
+export type BorderFactoryProps = {
+    /** Token de cor (`theme.colors`) aplicado a `border-color`. */
+    borderColor?: BgColorsTypes;
+    /**
+     * Restringe a borda a um lado específico (ou par de lados).
+     *
+     * `vertical` aplica em `top` + `bottom`; `horizontal` em `left` + `right`.
+     */
+    borderPosition?: 'right' | 'left' | 'top' | 'bottom' | 'vertical' | 'horizontal';
+    /** Quando `true`, força `border-radius: undefined` (zera qualquer raio). */
+    square?: boolean;
+} & BorderThemeType & BorderRoundProps;
+/**
+ * Variante de `BorderFactoryProps` enriquecida com o `theme` injetado pelo
+ * `ThemeProvider`. Use em assinaturas que precisam acessar o tema corrente.
+ */
+export type BorderThemePropsType = WithTheme<BorderFactoryProps>;

package/lib/factory/BorderFactory/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Barrel público do módulo `BorderFactory`.
+ *
+ * Reexporta a fábrica (`BorderFactory`), os helpers semânticos
+ * (`BorderSemantic`, `BorderRoundSemantic`), a lista `borderKeys` e os tipos
+ * de props. Importações de fora desta pasta devem usar este barrel.
+ */
+export * from './BorderFactory';
+export * from './BorderFactory.interface';

package/lib/factory/BorderFactory/index.esm.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"../../chunks/chunk-U27SLYIV.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{d as BorderFactory,b as BorderRoundSemantic,c as BorderSemantic,a as borderKeys};

package/lib/factory/ColorFactory/ColorFactory.d.ts

@@ -0,0 +1,31 @@
+import { ColorFactoryProps, ColorThemePropsType } from './ColorFactory.interface';
+/**
+ * Chaves de prop controladas pelo `ColorFactory`.
+ *
+ * Apenas `color` e `contrast` aparecem aqui — `opacity` propositalmente fica
+ * de fora pois é um modificador genérico que pode ser repassado para o DOM
+ * (não causa conflito).
+ */
+export declare const colorKeys: Array<keyof ColorFactoryProps>;
+/**
+ * Fábrica de estilos de cor de texto.
+ *
+ * Resolução em três passos:
+ * 1. `contrast` (se presente) vence: calcula a cor de melhor contraste sobre
+ *    aquele fundo.
+ * 2. `color` (caso contrário): resolve direto pelo token de tema.
+ * 3. `opacity`: se informado, mapeia o token semântico para um valor numérico.
+ *
+ * @example
+ * ```ts
+ * const Title = styled.h1(ColorFactory({ color: 'primary' }));
+ * const Badge = styled.span(ColorFactory({ contrast: 'primary' })); // texto sobre fundo primary
+ * ```
+ */
+export declare const ColorFactory: (customProps: ColorFactoryProps) => (contextProps: ColorThemePropsType) => {
+    color: string;
+    opacity?: undefined;
+} | {
+    color: string;
+    opacity: number;
+};

package/lib/factory/ColorFactory/ColorFactory.interface.d.ts

@@ -0,0 +1,31 @@
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Props consumidas pelo `ColorFactory`.
+ *
+ * Controlam a cor de texto e a opacidade resultante. As três opções de
+ * `opacity` são tokens semânticos — não valores arbitrários — para manter o
+ * conjunto de variações sob controle visual.
+ */
+export type ColorFactoryProps = {
+    /**
+     * Token do tema (`theme.colors`) usado como `color`. Tem precedência menor
+     * que `contrast`: se ambos forem informados, prevalece o cálculo de
+     * contraste.
+     */
+    color?: string;
+    /**
+     * Token de cor de "fundo" hipotético — a fábrica calcula a melhor cor de
+     * texto (preto/branco) para garantir contraste WCAG sobre ele.
+     */
+    contrast?: string;
+    /**
+     * Opacidade semântica aplicada à cor: `low` ≈ 0.1, `md` ≈ 0.5, `high` ≈ 0.9.
+     * Manter tokens evita uma proliferação de valores arbitrários ao longo da
+     * UI.
+     */
+    opacity?: 'low' | 'md' | 'high';
+};
+/**
+ * Variante de `ColorFactoryProps` com `theme` injetado pelo `ThemeProvider`.
+ */
+export type ColorThemePropsType = WithTheme<ColorFactoryProps>;

package/lib/factory/ColorFactory/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel público do módulo `ColorFactory`.
+ *
+ * Reexporta a fábrica (`ColorFactory`), a lista `colorKeys` e os tipos de
+ * props. Importações externas devem entrar por aqui.
+ */
+export * from './ColorFactory';
+export * from './ColorFactory.interface';

package/lib/factory/ColorFactory/index.esm.js

@@ -0,0 +1 @@
+import{a,b}from"../../chunks/chunk-JB7G6UGV.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{b as ColorFactory,a as colorKeys};

package/lib/factory/ContainerFactory/ContainerFactory.d.ts

@@ -0,0 +1,23 @@
+import { CSSObject } from 'styled-components';
+import { ContainerFactoryProps, ContainerThemePropsType } from './ContainerFactory.interface';
+/**
+ * Chaves de prop controladas pelo `ContainerFactory`.
+ *
+ * Consumida pelo `System` no `shouldForwardProp` para impedir que essas props
+ * sejam emitidas como atributos HTML.
+ */
+export declare const containerKeys: Array<keyof ContainerFactoryProps>;
+/**
+ * Fábrica de estilos "estruturais" (display/position/overflow/padding/etc.).
+ *
+ * Resolve as flags semânticas (`truncate`, `container`, `absoluteFill`,
+ * `isHidden`) em conjuntos de propriedades CSS — ver `ContainerFactoryProps`
+ * para o significado de cada flag.
+ *
+ * @example
+ * ```ts
+ * const Modal = styled.div(ContainerFactory({ position: 'fixed', absoluteFill: true }));
+ * const Title = styled.h2(ContainerFactory({ truncate: true }));
+ * ```
+ */
+export declare const ContainerFactory: (customProps: ContainerFactoryProps) => (contextProps: ContainerThemePropsType) => CSSObject;

package/lib/factory/ContainerFactory/ContainerFactory.interface.d.ts

@@ -0,0 +1,65 @@
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Valores aceitos pelas props `overflow`, `overflowX` e `overflowY`.
+ *
+ * Espelha o conjunto suportado pelo CSS sem `inherit`/`initial`, que raramente
+ * fazem sentido no nível de componente.
+ */
+export type OverflowType = 'visible' | 'hidden' | 'scroll' | 'auto';
+/**
+ * Valores aceitos por `cursor`.
+ *
+ * Lista exaustiva dos cursores nativos do CSS suportados pela Apollion. Limitar
+ * o conjunto a um union evita strings inválidas e dá autocompletion.
+ */
+export type CursorType = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing';
+/**
+ * Valores aceitos por `display`.
+ *
+ * Omite `table`, `list-item` e outros legados — a Apollion privilegia layout
+ * via Flex/Grid.
+ */
+export type DisplayType = 'none' | 'inline' | 'block' | 'flex' | 'grid' | 'inline-block' | 'inline-flex' | 'inline-grid';
+/**
+ * Props consumidas pelo `ContainerFactory`.
+ *
+ * Reúnem as propriedades "estruturais" de um elemento (posicionamento,
+ * overflow, padding/margin, grid-area, etc.) sob um único objeto. Trabalham
+ * em conjunto com `SizeFactory` (dimensões) e `SpacingFactory` (escala
+ * tokenizada de espaçamento).
+ *
+ * Algumas flags são atalhos de alto nível:
+ * - `truncate` adiciona `overflow:hidden + text-overflow:ellipsis + white-space:nowrap`.
+ * - `container` centraliza com `margin: 0 auto` e `maxWidth: 1366`.
+ * - `absoluteFill` faz `position:absolute + top/bottom/left/right: 0`.
+ */
+export type ContainerFactoryProps = Partial<{
+    /** Valor de `grid-area` quando o elemento está dentro de um grid nomeado. */
+    area: string;
+    padding: string | number;
+    margin: string | number;
+    /** Aplica `visibility: hidden` (mantém o espaço, ao contrário de `display:none`). */
+    isHidden: boolean;
+    /** Atalho para conteúdo single-line com elipse. */
+    truncate: boolean;
+    /** Centraliza o elemento e limita a largura ao breakpoint de container (1366px). */
+    container: boolean;
+    overflow: OverflowType;
+    overflowX: OverflowType;
+    overflowY: OverflowType;
+    /** Posiciona absolutamente e ocupa todo o pai (`top/bottom/left/right: 0`). */
+    absoluteFill: boolean;
+    position: 'relative' | 'absolute' | 'fixed' | 'sticky';
+    display: DisplayType;
+    cursor: CursorType;
+    top: string | number;
+    bottom: string | number;
+    left: string | number;
+    right: string | number;
+    zIndex: number;
+}>;
+/**
+ * Variante de `ContainerFactoryProps` com `theme` injetado pelo
+ * `ThemeProvider`. Usada nas assinaturas internas das fábricas.
+ */
+export type ContainerThemePropsType = WithTheme<ContainerFactoryProps>;

package/lib/factory/ContainerFactory/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel público do módulo `ContainerFactory`.
+ *
+ * Reexporta a fábrica (`ContainerFactory`), a lista `containerKeys` e os tipos
+ * (`ContainerFactoryProps`, `OverflowType`, `CursorType`, `DisplayType`).
+ */
+export * from './ContainerFactory';
+export * from './ContainerFactory.interface';

package/lib/factory/ContainerFactory/index.esm.js

@@ -0,0 +1 @@
+import{a,b}from"../../chunks/chunk-GP7NECT4.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{b as ContainerFactory,a as containerKeys};

package/lib/factory/DeepFactory/DeepFactory.d.ts

@@ -0,0 +1,26 @@
+import { CSSObject } from 'styled-components';
+import { DeepFactoryProps, DeepThemePropsType } from './DeepFactory.interface';
+/**
+ * Chaves de prop controladas pelo `DeepFactory`.
+ *
+ * Consumida pelo `System` para impedir vazamento dessas props para o DOM.
+ */
+export declare const deepKeys: Array<keyof DeepFactoryProps>;
+/**
+ * Fábrica de elevação (`box-shadow`) baseada em níveis semânticos.
+ *
+ * O nível `deep` indexa em uma escala (-1 → 6) onde cada degrau combina
+ * distância/proximidade/intensidade do tema. `deepColor` permite trocar a cor
+ * base por um token do tema (convertido para RGB).
+ *
+ * Casos especiais:
+ * - `deep === undefined` ou `noShadow`: retorna `null` (sem sombra).
+ * - `deep === -1`: sombra interna (`inset`).
+ *
+ * @example
+ * ```ts
+ * const Card = styled.div(DeepFactory({ deep: 3 }));
+ * const Toast = styled.div(DeepFactory({ deep: 4, deepColor: 'primary' }));
+ * ```
+ */
+export declare const DeepFactory: (customProps: DeepFactoryProps) => (contextProps: DeepThemePropsType) => CSSObject;

package/lib/factory/DeepFactory/DeepFactory.interface.d.ts

@@ -0,0 +1,41 @@
+import { DeepThemeInterface } from '../../themes/Deep';
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Forma "resolvida" do slice `deep` do tema — cada chave é um único valor
+ * final (string ou number).
+ *
+ * É usada internamente por `getBoxShadow` para montar o shorthand de
+ * `box-shadow`. Os valores ainda vêm do tema; este tipo é só um alias de
+ * conveniência.
+ */
+export type DeepThemeType = Record<keyof DeepThemeInterface, string | number>;
+/**
+ * Níveis semânticos de profundidade aceitos pela prop `deep`.
+ *
+ * - `-1`: sombra interna (afundado).
+ * - `0`: linha base (sem sombra visível).
+ * - `1`–`6`: graduação de elevação crescente.
+ *
+ * Manter uma escala discreta evita um mar de `box-shadow` ad-hoc e dá
+ * consistência cinética às camadas da UI.
+ */
+export type DeepStylesTypes = -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Props consumidas pelo `DeepFactory`.
+ *
+ * `noShadow` é um override explícito quando o componente precisa anular a
+ * sombra herdada de uma variante. `deepColor` muda a cor base da sombra (útil
+ * para sombras coloridas em variantes "primary"/"danger").
+ */
+export type DeepFactoryProps = {
+    /** Nível de profundidade aplicado. Vide `DeepStylesTypes`. */
+    deep?: DeepStylesTypes;
+    /** Token de cor (`theme.colors`) usado como cor base do `box-shadow`. */
+    deepColor?: string;
+    /** Quando `true`, suprime qualquer sombra mesmo que `deep` esteja definido. */
+    noShadow?: boolean;
+};
+/**
+ * Variante de `DeepFactoryProps` com `theme` injetado pelo `ThemeProvider`.
+ */
+export type DeepThemePropsType = WithTheme<DeepFactoryProps>;

package/lib/factory/DeepFactory/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel público do módulo `DeepFactory`.
+ *
+ * Reexporta a fábrica de elevação (`DeepFactory`), a lista `deepKeys` e os
+ * tipos auxiliares (`DeepStylesTypes`, `DeepFactoryProps`).
+ */
+export * from './DeepFactory';
+export * from './DeepFactory.interface';

package/lib/factory/DeepFactory/index.esm.js

@@ -0,0 +1 @@
+import{a,b}from"../../chunks/chunk-WAHR5LIT.esm.js";import"../../chunks/chunk-QUHHEZMP.esm.js";import"../../chunks/chunk-44EW3LMK.esm.js";import"../../chunks/chunk-V5AWVNU6.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{b as DeepFactory,a as deepKeys};

package/lib/factory/FlexFactory/FlexFactory.d.ts

@@ -0,0 +1,22 @@
+import { CSSObject } from 'styled-components';
+import { FlexFactoryProps, FlexThemeProps } from './FlexFactory.interface';
+/**
+ * Chaves de prop controladas pelo `FlexFactory`.
+ *
+ * Consumida pelo `System` para impedir vazamento dessas props para o DOM.
+ */
+export declare const flexKeys: Array<keyof FlexFactoryProps>;
+/**
+ * Fábrica de estilos de flexbox.
+ *
+ * Combina os atalhos semânticos (`flex`, `justifyContent`, `alignItems`,
+ * `wrap`, `alignSelf`, `order`, `grow`/`shrink`) com a resolução de `gap` via
+ * `gapFn`. `flexDirection` cai em `column` por padrão (alinhado à preferência
+ * da Apollion de stacking vertical implícito).
+ *
+ * @example
+ * ```ts
+ * const Row = styled.div(FlexFactory({ flexDirection: 'row', gap: 'sm', alignItems: 'center' }));
+ * ```
+ */
+export declare const FlexFactory: (customProps: FlexFactoryProps) => ({ theme, ...contextProps }: FlexThemeProps) => CSSObject;

package/lib/factory/FlexFactory/FlexFactory.interface.d.ts

@@ -0,0 +1,63 @@
+import { SpacingInterface } from '../../themes/Spacing';
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Atalhos semânticos aceitos pela prop `flex`.
+ *
+ * Cada chave mapeia para um shorthand de `flex`:
+ * - `auto`: `1 1 auto` (cresce/encolhe baseado no conteúdo).
+ * - `fluid`: `1 1 0%` (distribui espaço igualmente, ignora conteúdo).
+ * - `initial`: `0 1 auto` (não cresce, encolhe se necessário).
+ * - `none`: `none` (não cresce nem encolhe).
+ */
+export type Flex = 'fluid' | 'initial' | 'auto' | 'none';
+/** Direção do eixo principal do flex container. */
+export type FlexDirection = 'row' | 'row-reverse' | 'column' | 'column-reverse';
+/**
+ * Tokens semânticos para `justify-content`. Encurtam os valores nativos do CSS
+ * (`flex-start` → `start`, `space-between` → `between`, etc.).
+ */
+export type FlexJustify = 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
+/** Tokens semânticos para `align-items`. */
+export type FlexAlignItems = 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+/**
+ * Tokens semânticos para `flex-wrap`. `reverse` aplica `wrap-reverse`.
+ */
+export type FlexWrap = 'wrap' | 'reverse' | 'nowrap';
+/**
+ * Valor de `order`. Aceita número direto ou tokens semânticos:
+ * - `first`: `-999` (puxa o item para o começo).
+ * - `last`: `999` (manda para o fim).
+ */
+export type FlexOrder = number | 'first' | 'last';
+/** Tokens semânticos para `align-self`. */
+export type AlignSelf = 'start' | 'end' | 'center' | 'auto' | 'stretch';
+/** Mesmo conjunto de tokens de `AlignSelf` — reaproveitado para `justify-self`. */
+export type JustifySelf = AlignSelf;
+/**
+ * Props consumidas pelo `FlexFactory`.
+ *
+ * Todas opcionais — quando ausentes, não emitem o atributo CSS correspondente
+ * (exceto `flexDirection`, que tem fallback para `column` na fábrica).
+ *
+ * `gap` recebe um token da escala de spacing (`SpacingInterface`); a fábrica
+ * cuida da resolução pelo tema E aplica fallback de `margin` em navegadores
+ * antigos sem suporte a `gap` em flexbox.
+ */
+export type FlexFactoryProps = Partial<{
+    flex: Flex;
+    gap?: SpacingInterface;
+    flexDirection: FlexDirection;
+    flexBasis: string | number;
+    justifyContent: FlexJustify;
+    alignItems: FlexAlignItems;
+    wrap: FlexWrap;
+    alignSelf: AlignSelf;
+    grow: boolean;
+    shrink: boolean;
+    order: FlexOrder;
+    justifySelf: JustifySelf;
+}>;
+/**
+ * Variante de `FlexFactoryProps` com `theme` injetado pelo `ThemeProvider`.
+ */
+export type FlexThemeProps = WithTheme<FlexFactoryProps>;

package/lib/factory/FlexFactory/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Barrel público do módulo `FlexFactory`.
+ *
+ * Reexporta a fábrica (`FlexFactory`), `flexKeys` e os tipos de props
+ * principais. Demais tokens auxiliares (ex.: `FlexDirection`) ficam internos
+ * — exporte aqui caso passem a ser usados fora.
+ */
+export * from './FlexFactory';
+export type { FlexThemeProps, FlexFactoryProps } from './FlexFactory.interface';

package/lib/factory/FlexFactory/index.esm.js

@@ -0,0 +1 @@
+import{a,b}from"../../chunks/chunk-OEH5ARPF.esm.js";import"../../chunks/chunk-V5AWVNU6.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{b as FlexFactory,a as flexKeys};

package/lib/factory/FontFactory/FontFactory.d.ts

@@ -0,0 +1,21 @@
+import { CSSObject } from 'styled-components';
+import { FontFactoryProps, FontThemePropsType } from './FontFactory.interface';
+/**
+ * Chaves de prop controladas pelo `FontFactory`.
+ *
+ * Consumida pelo `System` para impedir vazamento dessas props para o DOM.
+ */
+export declare const fontKeys: Array<keyof FontFactoryProps>;
+/**
+ * Fábrica de estilos tipográficos.
+ *
+ * Resolve cada token através do slice `theme.font.*` correspondente — isso
+ * permite que componentes referenciem "tamanhos semânticos" (ex.: `sm`,
+ * `md`, `xl`) em vez de valores literais em px/rem.
+ *
+ * @example
+ * ```ts
+ * const Title = styled.h1(FontFactory({ fontSize: 'xl', fontWeight: 'bold', textAlign: 'center' }));
+ * ```
+ */
+export declare const FontFactory: (customProps: FontFactoryProps) => (contextProps: FontThemePropsType) => CSSObject;

package/lib/factory/FontFactory/FontFactory.interface.d.ts

@@ -0,0 +1,32 @@
+import { FontThemeInterface } from '../../themes/Font';
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Estratégias de quebra de palavra.
+ *
+ * - `normal`: comportamento padrão do navegador.
+ * - `words`: quebra entre palavras (overflow-wrap: break-word).
+ * - `all`: quebra dentro de palavras se necessário (word-break: break-all).
+ */
+export type WordBreakType = 'normal' | 'words' | 'all';
+/**
+ * Props consumidas pelo `FontFactory`.
+ *
+ * As chaves tokenizadas (fontSize, fontWeight, fontFamily, letterSpacing,
+ * lineHeight, fontStyle, textTransform) referenciam o slice `theme.font` —
+ * ou seja, são chaves de cada sub-objeto do tema (não valores CSS livres).
+ *
+ * As demais chaves (`textAlign`, `textDecoration`, `whiteSpace`, `wordBreak`)
+ * são CSS direto, mantendo o nível baixo onde tokenização não traz ganho.
+ */
+export type FontFactoryProps = Partial<{
+    [K in keyof FontThemeInterface]: keyof FontThemeInterface[K];
+} & {
+    textAlign: 'start' | 'end' | 'left' | 'right' | 'center' | 'justify' | 'match-parent';
+    textDecoration: 'none' | 'overline' | 'underline' | 'line-through';
+    whiteSpace: 'normal' | 'pre' | 'nowrap' | 'pre-wrap' | 'pre-line' | 'break-spaces';
+    wordBreak: WordBreakType;
+}>;
+/**
+ * Variante de `FontFactoryProps` com `theme` injetado pelo `ThemeProvider`.
+ */
+export type FontThemePropsType = WithTheme<FontFactoryProps>;

package/lib/factory/FontFactory/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel público do módulo `FontFactory`.
+ *
+ * Reexporta a fábrica (`FontFactory`), `fontKeys` e os tipos auxiliares
+ * (`FontFactoryProps`, `WordBreakType`).
+ */
+export * from './FontFactory';
+export * from './FontFactory.interface';

package/lib/factory/FontFactory/index.esm.js

@@ -0,0 +1 @@
+import{a,b}from"../../chunks/chunk-752Z7BQF.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{b as FontFactory,a as fontKeys};

package/lib/factory/ResponsiveFactory/ResponsiveFactory.d.ts

@@ -0,0 +1,22 @@
+import { CSSObject } from 'styled-components';
+import { ResponsiveProps } from './ResponsiveFactory.interface';
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Fábrica que materializa props prefixadas por breakpoint (`sm_*`, `md_*`,
+ * `lg_*`, `xl_*`) em media queries `@media (min-width: ...)`.
+ *
+ * Algoritmo:
+ * 1. Sai cedo se `ignoreResponsive` estiver ligado.
+ * 2. Particiona as props em `mediaProps[breakpoint]` agrupando por prefixo.
+ * 3. Se `enableBreakpoint` for informado, mescla aquele grupo no estilo base.
+ * 4. Para cada breakpoint, gera uma media query com `theme.breakpoints.up(bp)`
+ *    e aplica o conjunto de fábricas via `getStyles`.
+ *
+ * @example
+ * ```tsx
+ * <Box padding="sm" sm_padding="md" lg_padding="xl">
+ *   Padding cresce com o tamanho da viewport.
+ * </Box>
+ * ```
+ */
+export declare const ResponsiveFactory: (customProps: ResponsiveProps) => (context: WithTheme<ResponsiveProps>) => CSSObject;

package/lib/factory/ResponsiveFactory/ResponsiveFactory.interface.d.ts

@@ -0,0 +1,42 @@
+import { BreakpointTypes } from '../../themes/Breakpoints';
+import { BackgroundFactoryProps } from '../BackgroundFactory';
+import { BorderFactoryProps } from '../BorderFactory';
+import { ColorFactoryProps } from '../ColorFactory';
+import { ContainerFactoryProps } from '../ContainerFactory';
+import { DeepFactoryProps } from '../DeepFactory';
+import { FlexFactoryProps } from '../FlexFactory';
+import { FontFactoryProps } from '../FontFactory';
+import { SizeFactoryProps } from '../SizeFactory';
+import { SpacingFactoryProps } from '../SpacingFactory';
+/**
+ * Utilitário que produz a versão "responsiva" de qualquer conjunto de props.
+ *
+ * Para cada chave `K` do tipo `T`, emite quatro novas chaves prefixadas com
+ * o breakpoint: `sm_K`, `md_K`, `lg_K`, `xl_K`. Isso permite escrever, por
+ * exemplo, `sm_padding="md"` num componente para aplicar `padding` somente em
+ * telas a partir do breakpoint `sm`.
+ */
+export type Responsive<T = Record<string, any>> = {
+    [K in keyof T as `sm_${string & K}` | `md_${string & K}` | `lg_${string & K}` | `xl_${string & K}`]: T[K];
+};
+/**
+ * Conjunto agregado das props responsivas suportadas pela Apollion.
+ *
+ * Combina as variantes `sm_/md_/lg_/xl_` de todas as fábricas (Flex, Border,
+ * Background, Color, Container, Deep, Font, Size, Spacing). É a forma de
+ * estender qualquer componente styled para suportar breakpoints sem precisar
+ * declarar cada combinação manualmente.
+ */
+export interface ResponsiveProps extends Responsive<FlexFactoryProps>, Responsive<BorderFactoryProps>, Responsive<BackgroundFactoryProps>, Responsive<ColorFactoryProps>, Responsive<ContainerFactoryProps>, Responsive<DeepFactoryProps>, Responsive<FontFactoryProps>, Responsive<SizeFactoryProps>, Responsive<SpacingFactoryProps> {
+    /**
+     * Quando `true`, desliga completamente a fábrica responsiva (útil em testes
+     * ou em componentes que querem mostrar um único snapshot fixo).
+     */
+    ignoreResponsive?: boolean;
+    /**
+     * Força a aplicação de um conjunto de props como se o breakpoint indicado
+     * estivesse ativo, independentemente do tamanho real da viewport. Útil para
+     * stories/storyshots ou para previews controlados.
+     */
+    enableBreakpoint?: BreakpointTypes;
+}

package/lib/factory/ResponsiveFactory/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel público do módulo `ResponsiveFactory`.
+ *
+ * Reexporta a fábrica (`ResponsiveFactory`) e os tipos `ResponsiveProps` /
+ * `Responsive<T>`. Importações externas devem entrar por aqui.
+ */
+export * from './ResponsiveFactory';
+export * from './ResponsiveFactory.interface';

package/lib/factory/ResponsiveFactory/index.esm.js

@@ -0,0 +1 @@
+import{a}from"../../chunks/chunk-TGTH3E4X.esm.js";import"../../chunks/chunk-752Z7BQF.esm.js";import"../../chunks/chunk-BNB3KNKE.esm.js";import"../../chunks/chunk-W663AGNE.esm.js";import"../../chunks/chunk-A6Z2M2XU.esm.js";import"../../chunks/chunk-JB7G6UGV.esm.js";import"../../chunks/chunk-GP7NECT4.esm.js";import"../../chunks/chunk-WAHR5LIT.esm.js";import"../../chunks/chunk-QUHHEZMP.esm.js";import"../../chunks/chunk-44EW3LMK.esm.js";import"../../chunks/chunk-OEH5ARPF.esm.js";import"../../chunks/chunk-V5AWVNU6.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{a as ResponsiveFactory};

package/lib/factory/SizeFactory/SizeFactory.d.ts

@@ -0,0 +1,23 @@
+import { CSSObject } from 'styled-components';
+import { SizeFactoryProps } from './SizeFactory.interface';
+/**
+ * Chaves de prop controladas pelo `SizeFactory`.
+ *
+ * Consumida pelo `System` para impedir vazamento dessas props para o DOM.
+ *
+ * Embora `SizeThemeProps` exista, este factory não acessa o tema — por isso
+ * o callback aceita um objeto vazio como padrão.
+ */
+export declare const sizeKeys: Array<keyof SizeFactoryProps>;
+/**
+ * Fábrica de estilos de dimensão (`width`/`height` + min/max).
+ *
+ * Apenas mescla `customProps` com `contextProps` e retorna como CSSObject —
+ * sem tokenização. É o factory mais simples do conjunto.
+ *
+ * @example
+ * ```ts
+ * const Box = styled.div(SizeFactory({ maxWidth: 480, minHeight: '100vh' }));
+ * ```
+ */
+export declare const SizeFactory: (customProps: SizeFactoryProps) => (contextProps?: SizeFactoryProps) => CSSObject;

package/lib/factory/SizeFactory/SizeFactory.interface.d.ts

@@ -0,0 +1,26 @@
+import { WithTheme } from '../../themes/ThemeProvider';
+/**
+ * Props consumidas pelo `SizeFactory`.
+ *
+ * Lida apenas com dimensões "puras" (não tokenizadas) — qualquer string CSS
+ * válida (`'100%'`, `'24rem'`, `'fit-content'`) ou número (interpretado como
+ * pixels pelo styled-components).
+ *
+ * Tokenização (ex.: `xl`, `xxl`) é responsabilidade do `SpacingFactory` para
+ * margens/paddings, não desta fábrica.
+ */
+export interface SizeFactoryProps {
+    width?: string | number;
+    height?: string | number;
+    maxWidth?: string | number;
+    maxHeight?: string | number;
+    minWidth?: string | number;
+    minHeight?: string | number;
+}
+/**
+ * Variante de `SizeFactoryProps` com `theme` injetado pelo `ThemeProvider`.
+ *
+ * Apesar de o `SizeFactory` não usar o tema diretamente, este alias é mantido
+ * por consistência com as demais fábricas.
+ */
+export type SizeThemeProps = WithTheme<SizeFactoryProps>;

package/lib/factory/SizeFactory/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel público do módulo `SizeFactory`.
+ *
+ * Reexporta a fábrica (`SizeFactory`), `sizeKeys` e o tipo `SizeFactoryProps`.
+ */
+export * from './SizeFactory';
+export * from './SizeFactory.interface';

package/lib/factory/SizeFactory/index.esm.js

@@ -0,0 +1 @@
+import{a,b}from"../../chunks/chunk-BNB3KNKE.esm.js";import"../../chunks/chunk-GZONWSRB.esm.js";export{b as SizeFactory,a as sizeKeys};