@niibase/uniwind 1.6.4 → 1.8.0

package/dist/module/bundler/cli/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { UniwindBundlerConfig } from "@/bundler/config";
+import { Logger } from "@/bundler/logger";
+import { fileURLToPath } from "node:url";
+import path from "path";
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const cssArtifactPath = path.resolve(dirname, "../../uniwind.css");
+const printHelp = () => {
+  console.log([
+    "Usage: uniwind generate-artifacts --css <file> [--theme <name>...] [--dts <file>]",
+    "",
+    "Options:",
+    "  --css <file>      CSS entry file path, e.g. ./global.css",
+    "  --theme <name>    Extra theme name. Can be passed multiple times",
+    "  --dts <file>      Generated TypeScript declarations path",
+    "  --help            Show help"
+  ].join("\n"));
+};
+const readValue = (args, index, flag) => {
+  const value = args[index + 1];
+  if (value === void 0 || value.startsWith("--")) {
+    throw new Error(`Uniwind: ${flag} requires a value`);
+  }
+  return value;
+};
+const parseGenerateArtifactsArgs = (args) => {
+  const parsed = {
+    extraThemes: []
+  };
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--css":
+        parsed.cssEntryFile = readValue(args, index, arg);
+        index++;
+        break;
+      case "--theme":
+        parsed.extraThemes.push(readValue(args, index, arg));
+        index++;
+        break;
+      case "--dts":
+        parsed.dtsFile = readValue(args, index, arg);
+        index++;
+        break;
+      case "--help":
+        printHelp();
+        process.exit(0);
+      default:
+        throw new Error(`Uniwind: Unknown option ${arg}`);
+    }
+  }
+  return parsed;
+};
+const generateArtifacts = async (args) => {
+  const parsed = parseGenerateArtifactsArgs(args);
+  const bundlerConfig = UniwindBundlerConfig.fromCliConfig({
+    cssEntryFile: parsed.cssEntryFile,
+    dtsFile: parsed.dtsFile,
+    extraThemes: parsed.extraThemes
+  });
+  await bundlerConfig.generateArtifacts(cssArtifactPath);
+  Logger.info("Artifacts generated");
+};
+const main = async () => {
+  const [command, ...args] = process.argv.slice(2);
+  if (command === "--help" || command === void 0) {
+    printHelp();
+    return;
+  }
+  switch (command) {
+    case "generate-artifacts":
+      await generateArtifacts(args);
+      break;
+    default:
+      throw new Error(`Uniwind: Unknown command ${command}`);
+  }
+};
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/dist/module/bundler/config.d.ts

@@ -0,0 +1,17 @@
+import type { UniwindConfig, UniwindMetroConfig } from '@/bundler/types';
+import { Platform } from '@/common/consts';
+export declare class UniwindBundlerConfig {
+    private readonly config;
+    readonly platform: Platform;
+    static fromMetroConfig(config: UniwindMetroConfig, platform?: string | null): UniwindBundlerConfig;
+    static fromViteConfig(config: UniwindConfig): UniwindBundlerConfig;
+    static fromCliConfig(config: UniwindConfig): UniwindBundlerConfig;
+    constructor(config: UniwindMetroConfig, platform: Platform);
+    get cssPath(): any;
+    get themes(): any[];
+    get cssVisitor(): any;
+    get polyfills(): any;
+    get stringifiedThemes(): string;
+    toMetroConfig(): UniwindMetroConfig;
+    generateArtifacts(cssArtifactPath: string): Promise<void>;
+}

package/dist/module/bundler/config.js

@@ -0,0 +1,77 @@
+import { buildCSS } from "@/bundler/artifacts/css";
+import { buildDtsFile } from "@/bundler/artifacts/dts";
+import { UniwindCSSVisitor } from "@/bundler/css-visitor";
+import { Platform } from "@/common/consts";
+import { isDefined } from "@/common/utils";
+import path from "path";
+export class UniwindBundlerConfig {
+  constructor(config, platform) {
+    this.config = config;
+    this.platform = platform;
+  }
+  static fromMetroConfig(config, platform) {
+    const getPlatform = () => {
+      if (!isDefined(platform)) {
+        return Platform.Native;
+      }
+      if (!config.isTV) {
+        return platform;
+      }
+      if (platform === Platform.Android) {
+        return Platform.AndroidTV;
+      }
+      if (platform === Platform.iOS) {
+        return Platform.AppleTV;
+      }
+      throw new Error(`Platform ${platform} not supported`);
+    };
+    if (typeof config === "undefined") {
+      throw new Error("Uniwind: You need to pass second parameter to withUniwindConfig");
+    }
+    if (typeof config.cssEntryFile === "undefined") {
+      throw new Error(
+        'Uniwind: You need to pass css css entry file to withUniwindConfig, e.g. withUniwindConfig(config, { cssEntryFile: "./global.css" })'
+      );
+    }
+    return new UniwindBundlerConfig(config, getPlatform());
+  }
+  static fromViteConfig(config) {
+    return new UniwindBundlerConfig(config, Platform.Web);
+  }
+  static fromCliConfig(config) {
+    if (typeof config.cssEntryFile === "undefined") {
+      throw new Error(
+        "Uniwind: You need to pass css entry file, e.g. uniwind generate-artifacts --css ./global.css. Run uniwind generate-artifacts --help for usage."
+      );
+    }
+    return new UniwindBundlerConfig(config, Platform.Web);
+  }
+  get cssPath() {
+    return path.join(process.cwd(), this.config.cssEntryFile);
+  }
+  get themes() {
+    return Array.from(
+      /* @__PURE__ */ new Set([
+        "light",
+        "dark",
+        ...this.config.extraThemes ?? []
+      ])
+    );
+  }
+  get cssVisitor() {
+    return new UniwindCSSVisitor(this);
+  }
+  get polyfills() {
+    return this.config.polyfills;
+  }
+  get stringifiedThemes() {
+    return `[${this.themes.map((theme) => `'${theme}'`).join(", ")}]`;
+  }
+  toMetroConfig() {
+    return this.config;
+  }
+  async generateArtifacts(cssArtifactPath) {
+    await buildCSS(this.themes, this.config.cssEntryFile, cssArtifactPath);
+    buildDtsFile(this.config.dtsFile ?? "uniwind-types.d.ts", this.stringifiedThemes);
+  }
+}

package/dist/module/bundler/css-compiler/compileCSS.d.ts

@@ -0,0 +1,2 @@
+import type { UniwindBundlerConfig } from '../config';
+export declare const compileCSS: (bundlerConfig: UniwindBundlerConfig) => Promise<string>;

package/dist/module/bundler/css-compiler/compileCSS.js

@@ -0,0 +1,11 @@
+import { Platform } from "@/common/consts";
+import { compileNativeCSS } from "./compileNativeCSS.js";
+import { compileTailwind } from "./compileTailwind.js";
+import { compileWebCSS } from "./compileWebCSS.js";
+export const compileCSS = async (bundlerConfig) => {
+  const tailwindCSS = await compileTailwind(bundlerConfig);
+  if (bundlerConfig.platform === Platform.Web) {
+    return compileWebCSS(bundlerConfig, tailwindCSS);
+  }
+  return compileNativeCSS(bundlerConfig, tailwindCSS);
+};

package/dist/module/bundler/css-compiler/compileNativeCSS.d.ts

@@ -0,0 +1,2 @@
+import type { UniwindBundlerConfig } from '../config';
+export declare const compileNativeCSS: (bundlerConfig: UniwindBundlerConfig, tailwindCSS: string) => string;

package/dist/module/bundler/css-compiler/compileNativeCSS.js

@@ -0,0 +1,33 @@
+import { addMetaToStylesTemplate, ProcessorBuilder, serializeJSObject } from "../css-processor/index.js";
+export const compileNativeCSS = (bundlerConfig, tailwindCSS) => {
+  const Processor = new ProcessorBuilder(bundlerConfig);
+  Processor.transform(tailwindCSS);
+  const stylesheet = serializeJSObject(
+    addMetaToStylesTemplate(Processor, bundlerConfig.platform),
+    (key, value) => `"${key}": ${value}`
+  );
+  const vars = serializeJSObject(
+    Processor.vars,
+    (key, value) => `"${key}": vars => ${value}`
+  );
+  const keyframes = serializeJSObject(
+    Processor.keyframes,
+    (key, value) => `get "${key}"() { return ${value} }`
+  );
+  const scopedVars = Object.fromEntries(
+    Object.entries(Processor.scopedVars).map(([scopedVarsName, scopedVars2]) => [
+      scopedVarsName,
+      serializeJSObject(scopedVars2, (key, value) => `"${key}": vars => ${value}`)
+    ])
+  );
+  const serializedScopedVars = Object.entries(scopedVars).map(([scopedVarsName, scopedVars2]) => `"${scopedVarsName}": ({ ${scopedVars2} }),`).join("");
+  const currentColorVar = `currentColor: () => rt.colorScheme === 'dark' ? '#ffffff' : '#000000',`;
+  return [
+    "({",
+    `scopedVars: ({ ${serializedScopedVars} }),`,
+    `vars: ({ ${currentColorVar} ${vars} }),`,
+    `stylesheet: ({ ${stylesheet} }),`,
+    `keyframes: ({ ${keyframes} }),`,
+    "})"
+  ].join("");
+};

package/dist/module/bundler/css-compiler/compileTailwind.d.ts

@@ -0,0 +1,2 @@
+import type { UniwindBundlerConfig } from '../config';
+export declare const compileTailwind: (bundlerConfig: UniwindBundlerConfig) => Promise<string>;

package/dist/module/bundler/css-compiler/compileTailwind.js

@@ -0,0 +1,22 @@
+import { compile } from "@tailwindcss/node";
+import { Scanner } from "@tailwindcss/oxide";
+import fs from "fs";
+import path from "path";
+export const compileTailwind = async (bundlerConfig) => {
+  const css = await fs.promises.readFile(bundlerConfig.cssPath, "utf-8");
+  const compiler = await compile(css, {
+    base: path.dirname(bundlerConfig.cssPath),
+    onDependency: () => void 0
+  });
+  const scanner = new Scanner({
+    sources: [
+      ...compiler.sources,
+      {
+        negated: false,
+        pattern: "**/*",
+        base: path.dirname(bundlerConfig.cssPath)
+      }
+    ]
+  });
+  return compiler.build(scanner.scan());
+};

package/dist/module/bundler/css-compiler/compileWebCSS.d.ts

@@ -0,0 +1,2 @@
+import type { UniwindBundlerConfig } from '../config';
+export declare const compileWebCSS: (bundlerConfig: UniwindBundlerConfig, tailwindCSS: string) => string;

package/dist/module/bundler/css-compiler/compileWebCSS.js

@@ -0,0 +1,8 @@
+import { transform } from "lightningcss";
+export const compileWebCSS = (bundlerConfig, tailwindCSS) => {
+  return transform({
+    code: Buffer.from(tailwindCSS),
+    filename: "uniwind.css",
+    visitor: bundlerConfig.cssVisitor
+  }).code.toString();
+};

package/dist/module/bundler/css-compiler/index.d.ts

@@ -0,0 +1 @@
+export * from './compileCSS';

package/dist/module/bundler/css-compiler/index.js

@@ -0,0 +1 @@
+export * from "./compileCSS.js";

package/dist/module/bundler/css-processor/addMetaToStylesTemplate.d.ts

@@ -0,0 +1,3 @@
+import { Platform } from '@/common/consts';
+import type { ProcessorBuilder } from './processor';
+export declare const addMetaToStylesTemplate: (Processor: ProcessorBuilder, currentPlatform: Platform) => Record<string, any>;

package/dist/module/bundler/css-processor/addMetaToStylesTemplate.js

@@ -0,0 +1,136 @@
+import { Platform, StyleDependency } from "@/common/consts";
+import { isDefined } from "@/common/utils";
+import { serialize } from "./serialize.js";
+import { toCamelCase } from "./utils.js";
+const extractVarsFromString = (value) => {
+  const varsIndexes = [...value.matchAll(/vars\[/g)].map((m) => m.index);
+  return varsIndexes.map((index) => {
+    const afterIndex = value.slice(index + 5);
+    const closingIndex = afterIndex.indexOf("]");
+    const varName = afterIndex.slice(0, closingIndex);
+    return varName.replace(/[`"\\]/g, "");
+  });
+};
+const makeSafeForSerialization = (value) => {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
+  return value;
+};
+const hasThemedVarDependency = (varName, Processor, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(varName)) {
+    return false;
+  }
+  visited.add(varName);
+  const isScopedVar = Object.values(Processor.scopedVars).some((scopedVars) => varName in scopedVars);
+  if (isScopedVar) {
+    return true;
+  }
+  const globalVarValue = Processor.vars[varName];
+  if (typeof globalVarValue !== "string") {
+    return false;
+  }
+  return extractVarsFromString(globalVarValue).some((usedVarName) => {
+    return hasThemedVarDependency(usedVarName, Processor, visited);
+  });
+};
+export const addMetaToStylesTemplate = (Processor, currentPlatform) => {
+  const stylesheetsEntries = Object.entries(Processor.stylesheets).map(([className, stylesPerMediaQuery]) => {
+    const styles = stylesPerMediaQuery.map((style, index) => {
+      const {
+        platform,
+        rtl,
+        theme,
+        orientation,
+        minWidth,
+        maxWidth,
+        colorScheme,
+        important: _,
+        importantProperties,
+        active,
+        focus,
+        disabled,
+        dataAttributes,
+        ...rest
+      } = style;
+      const entries = Object.entries(rest).flatMap(([property, value]) => Processor.RN.cssToRN(property, value)).map(([property, value]) => [`"${property}"`, `function(vars) { return ${serialize(value)} }`]);
+      if (platform) {
+        const isTV = currentPlatform === Platform.AndroidTV || currentPlatform === Platform.AppleTV;
+        const commonPlatform = isTV ? Platform.TV : Platform.Native;
+        if (platform !== commonPlatform && platform !== currentPlatform) {
+          return null;
+        }
+      }
+      if (entries.length === 0) {
+        return null;
+      }
+      const dependencies = [];
+      const stringifiedEntries = JSON.stringify(entries);
+      const usedVars = extractVarsFromString(stringifiedEntries);
+      const isUsingThemedVar = usedVars.some((usedVarName) => hasThemedVarDependency(usedVarName, Processor));
+      if (usedVars.length > 0) {
+        dependencies.push(StyleDependency.Variables);
+      }
+      if (theme !== null || isUsingThemedVar || stringifiedEntries.includes("rt.lightDark")) {
+        dependencies.push(StyleDependency.Theme);
+      }
+      if (orientation !== null) {
+        dependencies.push(StyleDependency.Orientation);
+      }
+      if (rtl !== null) {
+        dependencies.push(StyleDependency.Rtl);
+      }
+      if (Number(minWidth) !== 0 || Number(maxWidth) !== Number.MAX_VALUE || stringifiedEntries.includes("rt.makeResponsive") || stringifiedEntries.includes("rt.screen")) {
+        dependencies.push(StyleDependency.Dimensions);
+      }
+      if (stringifiedEntries.includes("rt.insets")) {
+        dependencies.push(StyleDependency.Insets);
+      }
+      if (stringifiedEntries.includes("rt.fontScale")) {
+        dependencies.push(StyleDependency.FontScale);
+      }
+      return {
+        entries,
+        minWidth,
+        maxWidth,
+        theme: makeSafeForSerialization(theme),
+        orientation: makeSafeForSerialization(orientation),
+        rtl,
+        colorScheme: makeSafeForSerialization(colorScheme),
+        native: platform !== null,
+        dependencies: dependencies.length > 0 ? dependencies : null,
+        index,
+        className: makeSafeForSerialization(className),
+        active,
+        focus,
+        disabled,
+        importantProperties: importantProperties?.map((property) => property.startsWith("--") ? property : toCamelCase(property)).map(makeSafeForSerialization) ?? [],
+        dataAttributes,
+        complexity: [
+          minWidth !== 0,
+          theme !== null,
+          orientation !== null,
+          rtl !== null,
+          platform !== null,
+          active !== null,
+          focus !== null,
+          disabled !== null,
+          dataAttributes !== null
+        ].filter(Boolean).length
+      };
+    });
+    const filteredStyles = styles.filter(isDefined);
+    if (filteredStyles.length === 0) {
+      return null;
+    }
+    return [
+      className,
+      filteredStyles
+    ];
+  }).filter(isDefined);
+  const stylesheets = Object.fromEntries(stylesheetsEntries);
+  return stylesheets;
+};

package/dist/module/bundler/css-processor/animation.d.ts

@@ -0,0 +1,6 @@
+import type { TokenOrValue } from 'lightningcss';
+import type { DeclarationValues } from './types';
+type GetProcessedValue = (value: DeclarationValues) => any;
+export declare const getProcessedVarAnimation: (declarationValue: string, styles: Record<string, any>, updateVar: (value: string) => void) => void;
+export declare const getProcessedAnimation: (declarationValue: Array<TokenOrValue>, getProcessedValue: GetProcessedValue) => any;
+export {};

package/dist/module/bundler/css-processor/animation.js

@@ -0,0 +1,112 @@
+import { toCamelCase } from "./utils.js";
+const STATIC_TIMING_FUNCTIONS = /* @__PURE__ */ new Set([
+  "linear",
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "step-start",
+  "step-end"
+]);
+const DIRECTION_VALUES = /* @__PURE__ */ new Set(["normal", "reverse", "alternate", "alternate-reverse"]);
+const FILL_MODE_VALUES = /* @__PURE__ */ new Set(["none", "forwards", "backwards", "both"]);
+const PLAY_STATE_VALUES = /* @__PURE__ */ new Set(["running", "paused"]);
+const isTimeString = (x) => {
+  if (typeof x === "number") return true;
+  return typeof x === "string" && /^-?\d*(?:\.\d+)?(?:e[+-]?\d+)?(ms|s)$/.test(x.trim());
+};
+const isTimingFunctionCustom = (x) => {
+  if (typeof x !== "string") return false;
+  return x.startsWith("rt.cubicBezier(") || x.startsWith("rt.steps(") || x.startsWith("rt.linear(");
+};
+export const getProcessedVarAnimation = (declarationValue, styles, updateVar) => {
+  const tokens = declarationValue.replace(/\)/g, ") ").split(" ");
+  let duration = false;
+  for (const unprocessedToken of tokens) {
+    const token = unprocessedToken.replace(/^"|"$/g, "");
+    if (isTimeString(token) && !duration) {
+      styles["animation-duration"] = unprocessedToken;
+      duration = true;
+    } else if (isTimeString(token) && duration) {
+      styles["animation-delay"] = unprocessedToken;
+    } else if (STATIC_TIMING_FUNCTIONS.has(token)) {
+      styles["animation-timing-function"] = unprocessedToken;
+    } else if (isTimingFunctionCustom(token)) {
+      styles["animation-timing-function"] = unprocessedToken;
+    } else if (token === "infinite" || /^\d+$/.test(token)) {
+      styles["animation-iteration-count"] = unprocessedToken;
+    } else if (DIRECTION_VALUES.has(token)) {
+      styles["animation-direction"] = unprocessedToken;
+    } else if (FILL_MODE_VALUES.has(token)) {
+      styles["animation-fill-mode"] = unprocessedToken;
+    } else if (PLAY_STATE_VALUES.has(token)) {
+      styles["animation-play-state"] = unprocessedToken;
+    } else {
+      updateVar(`"${token}"`);
+    }
+  }
+};
+const parseValues = (tokens, getProcessedValue) => {
+  const groups = [];
+  let group = [];
+  for (const token of tokens) {
+    if (token.type === "token" && token.value.type === "delim" && token.value.value === "|") {
+      if (group.length > 0) {
+        groups.push(group);
+        group = [];
+      }
+      continue;
+    }
+    group.push(token);
+  }
+  if (group.length > 0) {
+    groups.push(group);
+  }
+  const values = groups.map((groupTokens) => tokensToText(groupTokens, getProcessedValue));
+  return values.length > 1 ? values : values[0];
+};
+const tokensToText = (tokens, getProcessedValue) => {
+  return tokens.map((token) => {
+    const value = getProcessedValue(token);
+    if (typeof value === "string") {
+      return /^"[^"]+"$/.test(value) ? value : `"${value}"`;
+    }
+    return value;
+  }).join(" ").trim();
+};
+export const getProcessedAnimation = (declarationValue, getProcessedValue) => {
+  const segments = [];
+  const result = [];
+  let current = [];
+  for (const token of declarationValue) {
+    if (token.type === "var") {
+      return getProcessedValue(token);
+    }
+    if (token.type === "token" && token.value.type === "comma") {
+      if (current.length > 0) {
+        segments.push(current);
+        current = [];
+      }
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) {
+    segments.push(current);
+  }
+  for (const segment of segments) {
+    const colonIndex = segment.findIndex((token) => token.type === "token" && token.value.type === "colon");
+    if (colonIndex === -1) {
+      const nameValue = parseValues(segment, getProcessedValue);
+      result.push(["name", Array.isArray(nameValue) ? nameValue : [nameValue]]);
+      continue;
+    }
+    const keyTokens = segment.slice(0, colonIndex);
+    const valueTokens = segment.slice(colonIndex + 1);
+    const rawKey = tokensToText(keyTokens, getProcessedValue);
+    const value = parseValues(valueTokens, getProcessedValue);
+    const key = toCamelCase(rawKey);
+    result.push([key, value]);
+  }
+  return result;
+};

package/dist/module/bundler/css-processor/color.d.ts

@@ -0,0 +1,12 @@
+import type { CssColor, UnresolvedColor } from 'lightningcss';
+import type { ProcessorBuilder } from './processor';
+export declare class Color {
+    private readonly Processor;
+    private toRgb;
+    private readonly black;
+    private readonly logger;
+    constructor(Processor: ProcessorBuilder);
+    processColor(color: CssColor | UnresolvedColor): string;
+    isColor(value: unknown): value is CssColor;
+    private format;
+}

package/dist/module/bundler/css-processor/color.js

@@ -0,0 +1,63 @@
+import { converter, formatHex, formatHex8, parse } from "culori";
+import { Logger } from "../logger.js";
+import { pipe } from "./utils.js";
+export class Color {
+  constructor(Processor) {
+    this.Processor = Processor;
+  }
+  toRgb = converter("rgb");
+  black = "#000000";
+  logger = new Logger("Color");
+  processColor(color) {
+    if (typeof color === "string") {
+      const parsed = parse(color);
+      if (parsed === void 0) {
+        const colorFunction = color.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/)?.[1];
+        if (colorFunction === void 0) {
+          this.logger.error(`Failed to convert color ${color}`);
+          return this.black;
+        }
+        const colorValue = color.replace(colorFunction, "").slice(1, -1);
+        return `rt.parseColor("${colorFunction}", ${colorValue})`;
+      }
+      return this.format(parsed);
+    }
+    try {
+      if (color.type === "currentcolor") {
+        return 'vars["currentColor"]?.(vars)';
+      }
+      if (color.type === "rgb" || color.type === "srgb") {
+        const alpha = typeof color.alpha === "number" ? color.alpha : pipe(color.alpha)(
+          (x) => this.Processor.CSS.processValue(x),
+          Number,
+          (x) => isNaN(x) ? 1 : x
+        );
+        return this.format({
+          r: color.r / 255,
+          g: color.g / 255,
+          b: color.b / 255,
+          alpha,
+          mode: "rgb"
+        });
+      }
+      const colorType = color.type === "display-p3" ? "p3" : color.type;
+      const result = this.toRgb({
+        mode: colorType,
+        ...color
+      });
+      return this.format(result);
+    } catch {
+      this.logger.error(`Failed to convert color ${JSON.stringify(color)}`);
+      return this.black;
+    }
+  }
+  isColor(value) {
+    return typeof value === "string" && parse(value) !== void 0;
+  }
+  format(color) {
+    if (color.alpha === 1 || color.alpha === void 0) {
+      return formatHex(color);
+    }
+    return formatHex8(color);
+  }
+}

package/dist/module/bundler/css-processor/css.d.ts

@@ -0,0 +1,23 @@
+import type { Animation, TokenOrValue } from 'lightningcss';
+import type { ProcessorBuilder } from './processor';
+import type { DeclarationProperty, DeclarationValues } from './types';
+export declare class CSS {
+    private readonly Processor;
+    private readonly logger;
+    constructor(Processor: ProcessorBuilder);
+    processValue(declarationValue: DeclarationValues, declarationProperty?: DeclarationProperty): any;
+    processAnimation(declarationValue: Array<TokenOrValue | Animation>): any;
+    processAnimationVar(declarationValue: string, styles: Record<string, string>, updateVar: (value: string) => void): void;
+    private processFilters;
+    private getProcessedValue;
+    private static readonly TRANSFORM_TYPES;
+    private isTransformArray;
+    private isOverflow;
+    /**
+     * Between some tokens there isn't a comma but it should be.
+     * For example this applies to Array of shadows
+     */
+    private addComaBetweenTokens;
+    private logUnsupported;
+    private makeSafeForSerialization;
+}