@pitlane/theme 0.2.0 → 0.3.1

package/dist/schema-CRP607Pg.d.mts

@@ -0,0 +1,320 @@
+import { Issue, Schema } from "remix/data-schema";
+//#region src/brands.d.ts
+/**
+ * The twelve DTCG token types, in canonical order.
+ *
+ * @internal
+ */
+declare const TOKEN_TYPES: readonly ["color", "dimension", "duration", "fontFamily", "fontWeight", "number", "cubicBezier", "shadow", "border", "transition", "gradient", "strokeStyle"];
+/** The twelve DTCG token `$type` values. @see {@link AnyToken} */
+type TokenType = (typeof TOKEN_TYPES)[number];
+declare const COLOR: unique symbol;
+declare const DIMENSION: unique symbol;
+declare const DURATION: unique symbol;
+declare const FONT_FAMILY: unique symbol;
+declare const FONT_WEIGHT: unique symbol;
+declare const NUMBER: unique symbol;
+declare const CUBIC_BEZIER: unique symbol;
+declare const SHADOW: unique symbol;
+declare const BORDER: unique symbol;
+declare const TRANSITION: unique symbol;
+declare const GRADIENT: unique symbol;
+declare const STROKE_STYLE: unique symbol;
+/** Compile-time brand for a `color` token. */
+type ColorToken = string & {
+  readonly [COLOR]: true;
+};
+/** Compile-time brand for a `dimension` token. */
+type DimensionToken = string & {
+  readonly [DIMENSION]: true;
+};
+/** Compile-time brand for a `duration` token. */
+type DurationToken = string & {
+  readonly [DURATION]: true;
+};
+/** Compile-time brand for a `fontFamily` token. */
+type FontFamilyToken = string & {
+  readonly [FONT_FAMILY]: true;
+};
+/** Compile-time brand for a `fontWeight` token. */
+type FontWeightToken = string & {
+  readonly [FONT_WEIGHT]: true;
+};
+/** Compile-time brand for a `number` token. */
+type NumberToken = string & {
+  readonly [NUMBER]: true;
+};
+/** Compile-time brand for a `cubicBezier` token. */
+type CubicBezierToken = string & {
+  readonly [CUBIC_BEZIER]: true;
+};
+/** Compile-time brand for a `shadow` token. */
+type ShadowToken = string & {
+  readonly [SHADOW]: true;
+};
+/** Compile-time brand for a `border` token. */
+type BorderToken = string & {
+  readonly [BORDER]: true;
+};
+/** Compile-time brand for a `transition` token. */
+type TransitionToken = string & {
+  readonly [TRANSITION]: true;
+};
+/** Compile-time brand for a `gradient` token. */
+type GradientToken = string & {
+  readonly [GRADIENT]: true;
+};
+/** Compile-time brand for a `strokeStyle` token. */
+type StrokeStyleToken = string & {
+  readonly [STROKE_STYLE]: true;
+};
+/**
+ * Maps each {@link TokenType} to its token brand.
+ *
+ * @internal
+ */
+interface BrandByType {
+  color: ColorToken;
+  dimension: DimensionToken;
+  duration: DurationToken;
+  fontFamily: FontFamilyToken;
+  fontWeight: FontWeightToken;
+  number: NumberToken;
+  cubicBezier: CubicBezierToken;
+  shadow: ShadowToken;
+  border: BorderToken;
+  transition: TransitionToken;
+  gradient: GradientToken;
+  strokeStyle: StrokeStyleToken;
+}
+declare const UNTYPED: unique symbol;
+/**
+ * Compile-time brand for a token declared with `s.any()`. It carries
+ * no CSS type, so the open-grammar properties (`animation`,
+ * `aspectRatio`, `background`) accept it and the token-mapped
+ * longhands reject it.
+ */
+type UntypedToken = string & {
+  readonly [UNTYPED]: true;
+};
+/**
+ * The union of all twelve token brands. Brands are compile-time tags
+ * naming each token's type; they let {@link css} reject a dimension
+ * where a color belongs. They exist only in the type system — every
+ * ref is a plain string at runtime, so brands cost nothing — and they
+ * are theme-independent, so tokens minted by two different
+ * {@link createTheme} calls mix freely in one {@link css} call.
+ */
+type AnyToken = BrandByType[TokenType];
+//#endregion
+//#region src/schema.d.ts
+/**
+ * The tag a schema carries. The twelve {@link TokenType} values name a
+ * DTCG type; `scale` is a dimension whose accessor leaf multiplies;
+ * `any` declines to type the token at all.
+ *
+ * @internal
+ */
+type SchemaTag = "any" | "scale" | TokenType;
+/** @internal */
+declare const TAG: unique symbol;
+/** @internal */
+declare const SELF: unique symbol;
+/**
+ * A `remix/data-schema` schema that also names the token type it
+ * declares. Every factory in this module returns one.
+ *
+ * @see {@link color}
+ */
+interface TokenSchema<tag extends SchemaTag = SchemaTag> extends Schema<unknown, string> {
+  readonly [TAG]: tag;
+}
+/**
+ * A schema group: per-child schemas, optionally under a schema for the
+ * node itself. {@link group} builds one; a plain object literal is the
+ * children-only form.
+ *
+ * @see {@link group}
+ */
+interface SchemaGroup {
+  readonly [SELF]?: TokenSchema;
+  readonly [key: string]: SchemaNode | undefined;
+}
+/** A node in a schema tree. @see {@link SchemaGroup} */
+type SchemaNode = SchemaGroup | TokenSchema;
+/**
+ * Standard Schema path segments may be objects, so stringify each one
+ * rather than relying on `Array#join`.
+ *
+ * @internal
+ */
+declare function pathKey(path: NonNullable<Issue["path"]>): string;
+/**
+ * A `color` token. Accepts any CSS color, including `light-dark()`,
+ * `color-mix()`, and `currentColor`, plus DTCG's structured form.
+ *
+ * @returns A schema declaring the `color` token type
+ *
+ * @example
+ * ```ts
+ * let schema = { color: s.color() };
+ * let tokens = { color: { white: "#fff", page: lightDark("#fff", "#111") } };
+ * ```
+ */
+declare function color(): TokenSchema<"color">;
+/**
+ * A `dimension` token. Accepts any CSS length, including `clamp()`,
+ * `calc()`, `%`, and `em`.
+ *
+ * @returns A schema declaring the `dimension` token type
+ */
+declare function dimension(): TokenSchema<"dimension">;
+/**
+ * A `duration` token. Accepts `ms`, `s`, and `calc()`.
+ *
+ * @returns A schema declaring the `duration` token type
+ */
+declare function duration(): TokenSchema<"duration">;
+/**
+ * A `number` token. Accepts a finite number, which is what unitless
+ * CSS values such as `line-height` and `opacity` take.
+ *
+ * @returns A schema declaring the `number` token type
+ */
+declare function number(): TokenSchema<"number">;
+/**
+ * A `cubicBezier` token, named for the CSS property it feeds. Accepts
+ * a four-number tuple or `cubic-bezier(…)` text.
+ *
+ * @returns A schema declaring the `cubicBezier` token type
+ */
+declare function easing(): TokenSchema<"cubicBezier">;
+/**
+ * A `shadow` token. Accepts CSS shadow text, `inset` included.
+ *
+ * @returns A schema declaring the `shadow` token type
+ */
+declare function shadow(): TokenSchema<"shadow">;
+/**
+ * A `border` token. Accepts CSS border shorthand text.
+ *
+ * @returns A schema declaring the `border` token type
+ */
+declare function border(): TokenSchema<"border">;
+/**
+ * A `transition` token. Accepts CSS transition shorthand text.
+ *
+ * @returns A schema declaring the `transition` token type
+ */
+declare function transition(): TokenSchema<"transition">;
+/**
+ * A `gradient` token. Accepts CSS gradient function text.
+ *
+ * @returns A schema declaring the `gradient` token type
+ */
+declare function gradient(): TokenSchema<"gradient">;
+/**
+ * A `strokeStyle` token, named for the CSS value it holds. Accepts a
+ * line-style keyword.
+ *
+ * @returns A schema declaring the `strokeStyle` token type
+ */
+declare function stroke(): TokenSchema<"strokeStyle">;
+/**
+ * The two font token types, grouped because they share a prefix.
+ *
+ * `font.family()` accepts a font stack, as a string or an array of
+ * names; an array joins with commas and quotes what needs quoting.
+ * `font.weight()` accepts 1 to 1000 or one of DTCG's nineteen
+ * keywords, and emits the number.
+ *
+ * @example
+ * ```ts
+ * let schema = { font: s.font.family(), weight: s.font.weight() };
+ * let tokens = { font: { sans: ["Inter var", "system-ui"] }, weight: { bold: 700 } };
+ * ```
+ */
+declare let font: {
+  family(): TokenSchema<"fontFamily">;
+  weight(): TokenSchema<"fontWeight">;
+};
+/**
+ * A dimension token whose accessor leaf is a multiplier rather than a
+ * value. The token emits its own custom property; the accessor leaf is
+ * callable, and carries the base itself as `.token`.
+ *
+ * This is Tailwind's `--spacing`: one base that the whole scale
+ * multiplies, with no named steps.
+ *
+ * @returns A schema declaring a scale token
+ *
+ * @example
+ * ```ts
+ * let theme = createTheme({
+ *     schema: { spacing: s.scale() },
+ *     tokens: { spacing: "0.25rem" },
+ * });
+ *
+ * theme.token.spacing(4); // "calc(var(--spacing) * 4)"
+ * theme.token.spacing.token; // "var(--spacing)"
+ * ```
+ */
+declare function scale(): TokenSchema<"scale">;
+/**
+ * A token with no type. Its value is emitted verbatim and its accessor
+ * leaf brands as a plain `string`, which the open-grammar CSS
+ * properties accept and the token-mapped longhands still reject.
+ *
+ * This exists for CSS values with no DTCG type, such as
+ * `spin 1s linear infinite` and `16 / 9`. An untyped token may not be
+ * the target of a typed token's reference, because there is no type to
+ * check against.
+ *
+ * @returns A schema declaring an untyped token
+ */
+declare function any(): TokenSchema<"any">;
+/**
+ * A node that is itself typed and also carries per-child overrides.
+ * `self` applies to that node and to every descendant without its own
+ * entry; each key in `children` overrides it from there down.
+ *
+ * The self schema rides on a symbol key, so no token name is reserved:
+ * a token named `default` can carry its own type.
+ *
+ * @param self - The schema for this node and its unlabelled descendants
+ * @param children - Per-child schema overrides
+ * @returns A schema group
+ *
+ * @example
+ * ```ts
+ * let schema = {
+ *     control: s.group(s.dimension(), { color: s.color(), opacity: s.number() }),
+ * };
+ * // control.height.sm is a dimension; control.color.border is a color.
+ * ```
+ */
+declare function group<const self extends TokenSchema, const children extends Record<string, SchemaNode>>(self: self, children: children): children & {
+  readonly [SELF]: self;
+};
+/**
+ * True when a node declares a token type rather than grouping others.
+ *
+ * @internal
+ */
+declare function isTokenSchema(node: unknown): node is TokenSchema;
+/**
+ * The schema a node declares for itself and its unlabelled children,
+ * or `undefined` when it only groups.
+ *
+ * @internal
+ */
+declare function selfSchema(node: unknown): TokenSchema | undefined;
+/**
+ * The schema node for one child key, or `undefined` when the parent
+ * declares nothing for it.
+ *
+ * @internal
+ */
+declare function childSchema(node: unknown, key: string): unknown;
+//#endregion
+export { DimensionToken as A, UntypedToken as B, stroke as C, BrandByType as D, BorderToken as E, NumberToken as F, ShadowToken as I, StrokeStyleToken as L, FontFamilyToken as M, FontWeightToken as N, ColorToken as O, GradientToken as P, TokenType as R, shadow as S, AnyToken as T, isTokenSchema as _, TAG as a, scale as b, border as c, dimension as d, duration as f, group as g, gradient as h, SchemaTag as i, DurationToken as j, CubicBezierToken as k, childSchema as l, font as m, SchemaGroup as n, TokenSchema as o, easing as p, SchemaNode as r, any as s, SELF as t, color as u, number as v, transition as w, selfSchema as x, pathKey as y, TransitionToken as z };