@niibase/uniwind 1.0.0

package/dist/shared/uniwind.D3fvrgEG.mjs

@@ -0,0 +1,68 @@
+const name = "@niibase/uniwind";
+
+const isDefined = (value) => value !== null && value !== void 0;
+const toCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+const pipe = (data) => ((...fns) => fns.reduce((acc, fn) => fn(acc), data));
+const isNumber = (data) => {
+  if (typeof data === "number") {
+    return true;
+  }
+  if (typeof data === "string" && data !== "") {
+    return !isNaN(Number(data));
+  }
+  return false;
+};
+const smartSplit = (str, separator = " ") => {
+  const escaper = "&&&";
+  return pipe(str)(
+    (x) => x.replace(/\s\?\?\s/g, `${escaper}??${escaper}`),
+    (x) => x.replace(/\s([+\-*/])\s/g, `${escaper}$1${escaper}`),
+    (x) => x.split(separator),
+    (x) => x.map((token) => token.replace(new RegExp(escaper, "g"), " "))
+  );
+};
+const addMissingSpaces = (str) => pipe(str)(
+  (x) => x.trim(),
+  (x) => x.replace(/([^ {])this/g, "$1 this"),
+  (x) => x.replace(/\](?=\d)/g, "] "),
+  (x) => x.replace(/\)(?=\S)/g, ") "),
+  (x) => x.replace(/(?<!^)(?<!\s)"(?=\d)/g, '" ')
+);
+const uniq = (arr) => Array.from(new Set(arr));
+const isValidJSValue = (jsValueString) => {
+  try {
+    new Function(`const test = ${jsValueString}`);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const shouldBeSerialized = (value) => {
+  if (value.includes("-")) {
+    return value.split("-").some(shouldBeSerialized);
+  }
+  return [
+    isNumber(value),
+    value.startsWith("this["),
+    value.startsWith("rt."),
+    /[*/+-]/.test(value),
+    value.includes('"'),
+    value.includes(" ")
+  ].some(Boolean);
+};
+const roundToPrecision = (value, precision) => parseFloat(value.toFixed(precision));
+const deepEqual = (a, b) => {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) {
+    return false;
+  }
+  return keysA.every((key) => deepEqual(a[key], b[key]) && Object.prototype.hasOwnProperty.call(b, key));
+};
+
+export { isValidJSValue as a, addMissingSpaces as b, isDefined as c, deepEqual as d, shouldBeSerialized as e, isNumber as i, name as n, pipe as p, roundToPrecision as r, smartSplit as s, toCamelCase as t, uniq as u };

package/dist/shared/uniwind.D_6s2EM-.cjs

@@ -0,0 +1,301 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const node = require('@tailwindcss/node');
+const lightningcss = require('lightningcss');
+const common = require('./uniwind.BgZDHdUR.cjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+const red = "\x1B[91m";
+const yellow = "\x1B[33m";
+const blue = "\x1B[36m";
+const reset = "\x1B[0m";
+class Logger {
+  constructor(name) {
+    this.name = name;
+  }
+  static debug = false;
+  static log(message, meta = "") {
+    if (!Logger.debug) {
+      return;
+    }
+    console.log(`${blue}Uniwind ${meta}- ${message}${reset}`);
+  }
+  static error(message, meta = "") {
+    console.log(`${red}Uniwind Error ${meta}- ${message}${reset}`);
+  }
+  static warn(message, meta = "") {
+    if (!Logger.debug) {
+      return;
+    }
+    console.log(`${yellow}Uniwind Warning ${meta}- ${message}${reset}`);
+  }
+  log(message) {
+    Logger.log(message, `[${this.name} Processor] `);
+  }
+  error(message) {
+    Logger.error(message, `[${this.name} Processor] `);
+  }
+  warn(message) {
+    Logger.warn(message, `[${this.name} Processor] `);
+  }
+}
+
+const ONE_PX = {
+  type: "token",
+  value: { type: "dimension", unit: "px", value: 1 }
+};
+const processFunctions = {
+  pixelRatio: (fn) => {
+    return {
+      type: "function",
+      value: {
+        name: "calc",
+        arguments: [
+          fn.arguments.at(0) ?? ONE_PX,
+          { type: "token", value: { type: "delim", value: "*" } },
+          ONE_PX
+        ]
+      }
+    };
+  },
+  fontScale: (fn) => {
+    return {
+      type: "function",
+      value: {
+        name: "calc",
+        arguments: [
+          fn.arguments.at(0) ?? ONE_PX,
+          { type: "token", value: { type: "delim", value: "*" } },
+          {
+            type: "token",
+            value: { type: "dimension", value: 1, unit: "rem" }
+          }
+        ]
+      }
+    };
+  },
+  hairlineWidth: () => ONE_PX
+};
+
+const types = ["m", "p"];
+const sides = ["", "x", "y", "t", "b", "l", "r"];
+const spacing = "--spacing(--value(integer))";
+const length = "--value([length])";
+const generateCSSForInsets = () => {
+  let css = `@utility h-screen-safe {
+    height: calc(100vh - (env(safe-area-inset-top) + env(safe-area-inset-bottom)));
+}
+`;
+  const getInsetsForSide = (side) => {
+    switch (side) {
+      case "t":
+        return ["top"];
+      case "b":
+        return ["bottom"];
+      case "l":
+        return ["left"];
+      case "r":
+        return ["right"];
+      case "x":
+        return ["left", "right"];
+      case "y":
+        return ["top", "bottom"];
+      default:
+        return ["top", "bottom", "left", "right"];
+    }
+  };
+  types.forEach((type) => {
+    sides.forEach((side) => {
+      const styleName = type === "m" ? "margin" : "padding";
+      const insets = getInsetsForSide(side);
+      const styles = insets.map((inset) => `${styleName}-${inset}: env(safe-area-inset-${inset});`);
+      const safeStyles = styles.flatMap((style) => {
+        const styleWithoutSemicolon = style.replace(";", "");
+        return [
+          styleWithoutSemicolon.replace(/: (env.*)/, (_, env) => `: max(${env}, ${spacing});`),
+          styleWithoutSemicolon.replace(/: (env.*)/, (_, env) => `: max(${env}, ${length});`)
+        ];
+      });
+      const safeOffsetStyles = styles.flatMap((style) => {
+        const styleWithoutSemicolon = style.replace(";", "");
+        return [
+          styleWithoutSemicolon.replace(/: (env.*)/, (_, env) => `: calc(${env} + ${spacing});`),
+          styleWithoutSemicolon.replace(/: (env.*)/, (_, env) => `: calc(${env} + ${length});`)
+        ];
+      });
+      css += `
+                @utility ${type}${side}-safe {
+                    ${styles.join("\n    ")}
+                }
+                
+                @utility ${type}${side}-safe-or-* {
+                    ${safeStyles.join("\n    ")}
+                }
+                
+                @utility ${type}${side}-safe-offset-* {
+                    ${safeOffsetStyles.join("\n    ")}
+                }
+            `;
+    });
+  });
+  return css.replaceAll("        ", "").trim() + "\n";
+};
+
+const readFileSafe = (filePath) => {
+  try {
+    return fs__default.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+};
+const isExcludedDependency = (url) => [
+  url.includes("node_modules/tailwindcss"),
+  url.includes("node_modules/@tailwindcss"),
+  url.includes("node_modules/uniwind")
+].some(Boolean);
+const generateCSSForThemes = async (themes, input) => {
+  const themesVariables = Object.fromEntries(themes.map((theme) => [theme, /* @__PURE__ */ new Set()]));
+  const findVariantsRec = async (cssPath) => {
+    const css = readFileSafe(cssPath);
+    if (css === null) {
+      return;
+    }
+    const { dependencies } = lightningcss.transform({
+      code: Buffer.from(css),
+      filename: "uniwind.css",
+      analyzeDependencies: true,
+      visitor: {
+        Rule: (rule) => {
+          if (rule.type === "unknown" && rule.value.name === "variant") {
+            const [firstPrelude] = rule.value.prelude;
+            if (firstPrelude?.type !== "token" || firstPrelude.value.type !== "ident" || !themes.includes(firstPrelude.value.value)) {
+              return;
+            }
+            const theme = firstPrelude.value.value;
+            rule.value.block?.forEach((block) => {
+              if (block.type === "dashed-ident") {
+                themesVariables[theme]?.add(block.value);
+              }
+            });
+          }
+        }
+      }
+    });
+    if (!Array.isArray(dependencies)) {
+      return;
+    }
+    const importUrls = /* @__PURE__ */ new Set();
+    const importsCSS = dependencies.filter((dependency) => {
+      if (dependency.url.startsWith(".")) {
+        importUrls.add(path__default.resolve(path__default.dirname(cssPath), dependency.url));
+        return false;
+      }
+      return !isExcludedDependency(dependency.url);
+    }).map((dependency) => `@import "${dependency.url}";`).join("\n");
+    await node.compile(importsCSS, {
+      base: path__default.resolve(path__default.dirname(cssPath)),
+      onDependency: (dependency) => {
+        if (isExcludedDependency(dependency)) {
+          return;
+        }
+        importUrls.add(dependency);
+      }
+    });
+    for (const filePath of importUrls) {
+      await findVariantsRec(filePath);
+    }
+  };
+  await findVariantsRec(input);
+  let hasErrors = false;
+  const hasVariables = Object.values(themesVariables).some((variables) => variables.size > 0);
+  Object.values(themesVariables).forEach((variables) => {
+    Object.entries(themesVariables).forEach(([checkedTheme, checkedVariables]) => {
+      variables.forEach((variable) => {
+        if (!checkedVariables.has(variable)) {
+          Logger.error(`Theme ${checkedTheme} is missing variable ${variable}`);
+          hasErrors = true;
+        }
+      });
+    });
+  });
+  if (hasErrors) {
+    Logger.error("All themes must have the same variables");
+  }
+  const variablesCSS = hasVariables ? [
+    "",
+    "@theme {",
+    ...Array.from(Object.values(themesVariables).at(0) ?? []).map((variable) => `    ${variable}: unset;`),
+    "}"
+  ] : [];
+  const uniwindCSS = [
+    ...themes.map((theme) => `@custom-variant ${theme} (&:where(.${theme}, .${theme} *));`),
+    ...variablesCSS
+  ].join("\n");
+  return uniwindCSS;
+};
+
+const variants = ["ios", "android", "web", "native"];
+const generateCSSForVariants = () => {
+  let css = "";
+  variants.forEach((variant) => {
+    css += `@custom-variant ${variant} (${variant === "web" ? "html &" : `@media ${variant}`});
+`;
+  });
+  return css;
+};
+
+const dirname = typeof __dirname !== "undefined" ? __dirname : undefined;
+const buildCSS = async (themes, input) => {
+  const variants = generateCSSForVariants();
+  const insets = generateCSSForInsets();
+  const themesCSS = await generateCSSForThemes(themes, input);
+  const cssFilePath = path__default.join(dirname, "../../uniwind.css");
+  const oldCSSFile = fs__default.existsSync(cssFilePath) ? fs__default.readFileSync(cssFilePath, "utf-8") : "";
+  const newCssFile = [
+    variants,
+    insets,
+    themesCSS
+  ].join("\n");
+  if (oldCSSFile === newCssFile) {
+    return;
+  }
+  fs__default.writeFileSync(
+    cssFilePath,
+    newCssFile
+  );
+};
+
+const buildDtsFile = (dtsPath, stringifiedThemes) => {
+  const oldDtsContent = fs__default.existsSync(dtsPath) ? fs__default.readFileSync(dtsPath, "utf-8") : "";
+  const dtsContent = [
+    `// NOTE: This file is generated by ${common.name} and it should not be edited manually.`,
+    `/// <reference types="${common.name}/types" />`,
+    "",
+    `declare module '${common.name}' {`,
+    `    export interface UniwindConfig {`,
+    `        themes: readonly ${stringifiedThemes}`,
+    `    }`,
+    `}`,
+    "",
+    `export {}`,
+    ""
+  ].join("\n");
+  if (oldDtsContent === dtsContent) {
+    return;
+  }
+  fs__default.writeFileSync(dtsPath, dtsContent);
+};
+
+const stringifyThemes = (themes = []) => `[${themes.map((theme) => `'${theme}'`).join(", ")}]`;
+
+exports.Logger = Logger;
+exports.buildCSS = buildCSS;
+exports.buildDtsFile = buildDtsFile;
+exports.processFunctions = processFunctions;
+exports.stringifyThemes = stringifyThemes;

package/dist/vite/index.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+const node = require('@tailwindcss/node');
+const path = require('path');
+const common = require('../shared/uniwind.BgZDHdUR.cjs');
+const stringifyThemes = require('../shared/uniwind.D_6s2EM-.cjs');
+require('fs');
+require('lightningcss');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+const dirname = typeof __dirname !== "undefined" ? __dirname : undefined;
+const componentPath = path__default.resolve(
+  dirname,
+  "../module/components/web/index.js"
+);
+const uniwind = ({
+  cssEntryFile,
+  extraThemes,
+  dtsFile = "uniwind-types.d.ts"
+}) => {
+  const themes = common.uniq([
+    "light",
+    "dark",
+    ...extraThemes ?? []
+  ]);
+  const stringifiedThemes = stringifyThemes.stringifyThemes(themes);
+  return {
+    name: "uniwind",
+    config: () => ({
+      css: {
+        transformer: "lightningcss",
+        lightningcss: {
+          visitor: {
+            Function: stringifyThemes.processFunctions
+          }
+        }
+      },
+      optimizeDeps: {
+        exclude: [common.name, "react-native"]
+      },
+      resolve: {
+        alias: [
+          {
+            find: /^react-native$/,
+            replacement: componentPath,
+            customResolver: {
+              resolveId(_, importer) {
+                if (importer !== void 0 && node.normalizePath(importer).includes(`${common.name}/dist`)) {
+                  return this.resolve("react-native-web");
+                }
+                return componentPath;
+              }
+            }
+          }
+        ]
+      }
+    }),
+    transform: (code, id) => {
+      const normalizedId = node.normalizePath(id);
+      if (normalizedId.includes(`${common.name}/dist`) && normalizedId.includes("config/config.js")) {
+        return {
+          code: `${code}Uniwind.__reinit(() => ({}), ${stringifiedThemes})`
+        };
+      }
+    },
+    buildStart: async () => {
+      await stringifyThemes.buildCSS(themes, cssEntryFile);
+      stringifyThemes.buildDtsFile(dtsFile, stringifiedThemes);
+    },
+    generateBundle: async () => {
+      await stringifyThemes.buildCSS(themes, cssEntryFile);
+      stringifyThemes.buildDtsFile(dtsFile, stringifiedThemes);
+    }
+  };
+};
+
+exports.uniwind = uniwind;

package/dist/vite/index.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from 'vite'
+
+type UniwindConfig = {
+    cssEntryFile: string
+    extraThemes?: Array<string>
+    dtsFile?: string
+}
+
+export declare function uniwind(config: UniwindConfig): Plugin

package/dist/vite/index.mjs

@@ -0,0 +1,74 @@
+import { normalizePath } from '@tailwindcss/node';
+import path from 'path';
+import { u as uniq, n as name } from '../shared/uniwind.D3fvrgEG.mjs';
+import { s as stringifyThemes, p as processFunctions, a as buildCSS, b as buildDtsFile } from '../shared/uniwind.Bt3kqZo6.mjs';
+import 'fs';
+import 'lightningcss';
+
+const dirname = typeof __dirname !== "undefined" ? __dirname : import.meta.dirname;
+const componentPath = path.resolve(
+  dirname,
+  "../module/components/web/index.js"
+);
+const uniwind = ({
+  cssEntryFile,
+  extraThemes,
+  dtsFile = "uniwind-types.d.ts"
+}) => {
+  const themes = uniq([
+    "light",
+    "dark",
+    ...extraThemes ?? []
+  ]);
+  const stringifiedThemes = stringifyThemes(themes);
+  return {
+    name: "uniwind",
+    config: () => ({
+      css: {
+        transformer: "lightningcss",
+        lightningcss: {
+          visitor: {
+            Function: processFunctions
+          }
+        }
+      },
+      optimizeDeps: {
+        exclude: [name, "react-native"]
+      },
+      resolve: {
+        alias: [
+          {
+            find: /^react-native$/,
+            replacement: componentPath,
+            customResolver: {
+              resolveId(_, importer) {
+                if (importer !== void 0 && normalizePath(importer).includes(`${name}/dist`)) {
+                  return this.resolve("react-native-web");
+                }
+                return componentPath;
+              }
+            }
+          }
+        ]
+      }
+    }),
+    transform: (code, id) => {
+      const normalizedId = normalizePath(id);
+      if (normalizedId.includes(`${name}/dist`) && normalizedId.includes("config/config.js")) {
+        return {
+          code: `${code}Uniwind.__reinit(() => ({}), ${stringifiedThemes})`
+        };
+      }
+    },
+    buildStart: async () => {
+      await buildCSS(themes, cssEntryFile);
+      buildDtsFile(dtsFile, stringifiedThemes);
+    },
+    generateBundle: async () => {
+      await buildCSS(themes, cssEntryFile);
+      buildDtsFile(dtsFile, stringifiedThemes);
+    }
+  };
+};
+
+export { uniwind };

package/metro/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "../dist/metro/index.cjs"
+}

package/package.json

@@ -0,0 +1,106 @@
+{
+    "private": false,
+    "name": "@niibase/uniwind",
+    "version": "1.0.0",
+    "description": "The fastest Tailwind bindings for React Native",
+    "homepage": "https://uniwind.dev",
+    "author": "Unistack",
+    "type": "module",
+    "repository": "https://github.com/divineniiquaye/uniwind",
+    "sideEffects": false,
+    "scripts": {
+        "precommit": "bun lint",
+        "build": "unbuild",
+        "check:typescript": "tsc --noEmit",
+        "lint": "eslint src",
+        "lint:fix": "eslint src --fix",
+        "format": "dprint fmt",
+        "prepublishOnly": "bun run build",
+        "circular:check": "dpdm --no-warning --no-tree -T --exit-code circular:1 'src/**/*.ts' 'src/**/*.tsx'",
+        "build:css": "bun run src/css/index.ts",
+        "test": "jest"
+    },
+    "keywords": [
+        "unistyles",
+        "react-native-unistyles",
+        "react-native",
+        "react",
+        "native",
+        "tailwind",
+        "tailwindcss",
+        "theme",
+        "style"
+    ],
+    "license": "MIT",
+    "style": "./uniwind.css",
+    "source": "src/index",
+    "exports": {
+        ".": {
+            "style": "./uniwind.css",
+            "types": "./dist/module/index.d.ts",
+            "react-native": "./src/index.ts",
+            "import": "./dist/module/index.js",
+            "default": "./dist/common/index.js"
+        },
+        "./components": {
+            "types": "./no-types.d.ts",
+            "default": "./src/components/index.ts"
+        },
+        "./components/*": {
+            "types": "./no-types.d.ts",
+            "react-native": "./src/components/native/*.tsx",
+            "import": "./dist/module/components/web/*.js",
+            "default": "./dist/common/components/web/*.js"
+        },
+        "./metro": {
+            "types": "./dist/metro/index.d.ts",
+            "import": "./dist/metro/index.mjs",
+            "default": "./dist/metro/index.cjs"
+        },
+        "./vite": {
+            "types": "./dist/vite/index.d.ts",
+            "import": "./dist/vite/index.mjs",
+            "default": "./dist/vite/index.cjs"
+        },
+        "./types": "./types.d.ts",
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "src",
+        "dist",
+        "metro",
+        "vite",
+        "uniwind.css",
+        "types.d.ts",
+        "readme.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "@tailwindcss/node": "4.1.17",
+        "@tailwindcss/oxide": "4.1.17",
+        "culori": "4.0.2",
+        "lightningcss": "1.30.2"
+    },
+    "peerDependencies": {
+        "react": ">=19.0.0",
+        "react-native": ">=0.81.0",
+        "tailwindcss": ">=4"
+    },
+    "devDependencies": {
+        "@types/bun": "catalog:",
+        "@types/culori": "4.0.1",
+        "@types/react": "catalog:",
+        "typescript": "catalog:",
+        "metro": "0.83.3",
+        "dpdm": "3.14.0",
+        "unbuild": "3.6.1",
+        "vite": "7.2.7",
+        "jest": "30.2.0",
+        "react-test-renderer": "19.1.0",
+        "@react-native/babel-preset": "0.83.0",
+        "@testing-library/jest-native": "5.4.3",
+        "@testing-library/react-native": "13.3.3",
+        "prettier": "3.7.4",
+        "@types/jest": "30.0.0"
+    }
+}