@tamagui/theme-builder 1.116.1 → 1.116.2

package/dist/cjs/ThemeBuilder.js

@@ -0,0 +1,163 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var ThemeBuilder_exports = {};
+__export(ThemeBuilder_exports, {
+  ThemeBuilder: () => ThemeBuilder,
+  createThemeBuilder: () => createThemeBuilder
+});
+module.exports = __toCommonJS(ThemeBuilder_exports);
+var import_create_theme = require("@tamagui/create-theme");
+class ThemeBuilder {
+  constructor(state) {
+    this.state = state;
+  }
+  addPalettes(palettes) {
+    return this.state.palettes = {
+      // as {} prevents generic string key merge messing up types
+      ...this.state.palettes,
+      ...palettes
+    }, this;
+  }
+  addTemplates(templates) {
+    return this.state.templates = {
+      // as {} prevents generic string key merge messing up types
+      ...this.state.templates,
+      ...templates
+    }, this;
+  }
+  addMasks(masks) {
+    return this.state.masks = {
+      // as {} prevents generic string key merge messing up types
+      ...this.state.masks,
+      ...(0, import_create_theme.objectFromEntries)(
+        (0, import_create_theme.objectEntries)(masks).map(([key, val]) => [key, (0, import_create_theme.createMask)(val)])
+      )
+    }, this;
+  }
+  // for dev mode only really
+  _addedThemes = [];
+  addThemes(themes) {
+    return this._addedThemes.push({ type: "themes", args: [themes] }), this.state.themes = {
+      // as {} prevents generic string key merge messing up types
+      ...this.state.themes,
+      ...themes
+    }, this;
+  }
+  // these wont be typed to save some complexity and because they don't need to be typed!
+  addComponentThemes(childThemeDefinition, options) {
+    return this.addChildThemes(childThemeDefinition, options), this;
+  }
+  addChildThemes(childThemeDefinition, options) {
+    const currentThemes = this.state.themes;
+    if (!currentThemes)
+      throw new Error(
+        "No themes defined yet, use addThemes first to set your base themes"
+      );
+    this._addedThemes.push({ type: "childThemes", args: [childThemeDefinition, options] });
+    const currentThemeNames = Object.keys(currentThemes), incomingThemeNames = Object.keys(childThemeDefinition), namesWithDefinitions = currentThemeNames.flatMap((prefix) => {
+      const avoidNestingWithin = options?.avoidNestingWithin;
+      return avoidNestingWithin && avoidNestingWithin.some(
+        (avoidName) => prefix.startsWith(avoidName) || prefix.endsWith(avoidName)
+      ) ? [] : incomingThemeNames.map((subName) => {
+        const fullName = `${prefix}_${subName}`, definition = childThemeDefinition[subName];
+        return "avoidNestingWithin" in definition && definition.avoidNestingWithin.some((name) => prefix.startsWith(name) || prefix.endsWith(name)) ? null : [fullName, definition];
+      }).filter(Boolean);
+    }), childThemes = Object.fromEntries(namesWithDefinitions), next = {
+      // as {} prevents generic string key merge messing up types
+      ...this.state.themes,
+      ...childThemes
+    };
+    return this.state.themes = next, this;
+  }
+  build() {
+    if (!this.state.themes)
+      return {};
+    const out = {}, maskedThemes = [];
+    for (const themeName in this.state.themes) {
+      const nameParts = themeName.split("_"), parentName = nameParts.slice(0, nameParts.length - 1).join("_"), definitions = this.state.themes[themeName], themeDefinition = Array.isArray(definitions) ? (() => {
+        const found = definitions.find(
+          // endWith match stronger than startsWith
+          (d) => d.parent ? parentName.endsWith(d.parent) || parentName.startsWith(d.parent) : !0
+        );
+        return found || null;
+      })() : definitions;
+      if (themeDefinition)
+        if ("theme" in themeDefinition)
+          out[themeName] = themeDefinition.theme;
+        else if ("mask" in themeDefinition)
+          maskedThemes.push({ parentName, themeName, mask: themeDefinition });
+        else {
+          let {
+            palette: paletteName = "",
+            template: templateName,
+            ...options
+          } = themeDefinition;
+          const parentDefinition = this.state.themes[parentName];
+          if (!this.state.palettes)
+            throw new Error(
+              `No palettes defined for theme with palette expected: ${themeName}`
+            );
+          let palette = this.state.palettes[paletteName || ""], attemptParentName = `${parentName}_${paletteName}`;
+          for (; !palette && attemptParentName; )
+            attemptParentName in this.state.palettes ? (palette = this.state.palettes[attemptParentName], paletteName = attemptParentName) : attemptParentName = attemptParentName.split("_").slice(0, -1).join("_");
+          if (!palette) {
+            const msg = process.env.NODE_ENV !== "production" ? `: ${themeName}: ${paletteName}
+          Definition: ${JSON.stringify(themeDefinition)}
+          Parent: ${JSON.stringify(parentDefinition)}
+          Potential: (${Object.keys(this.state.palettes).join(", ")})` : "";
+            throw new Error(`No palette for theme${msg}`);
+          }
+          const template = this.state.templates?.[templateName] ?? // fall back to finding the scheme specific on if it exists
+          this.state.templates?.[`${nameParts[0]}_${templateName}`];
+          if (!template)
+            throw new Error(`No template for theme ${themeName}: ${templateName}`);
+          out[themeName] = (0, import_create_theme.createThemeWithPalettes)(
+            this.state.palettes,
+            paletteName,
+            template,
+            options,
+            themeName,
+            !0
+          );
+        }
+    }
+    for (const { mask, themeName, parentName } of maskedThemes) {
+      const parent = out[parentName];
+      if (!parent)
+        continue;
+      const { mask: maskName, ...options } = mask;
+      let maskFunction = this.state.masks?.[maskName];
+      if (!maskFunction)
+        throw new Error(`No mask ${maskName}`);
+      const parentTheme = this.state.themes[parentName];
+      if (parentTheme && "childOptions" in parentTheme) {
+        const { mask: mask2, ...childOpts } = parentTheme.childOptions;
+        mask2 && (maskFunction = this.state.masks?.[mask2]), Object.assign(options, childOpts);
+      }
+      out[themeName] = (0, import_create_theme.applyMask)(
+        parent,
+        maskFunction,
+        options,
+        parentName,
+        themeName
+      );
+    }
+    return out;
+  }
+}
+function createThemeBuilder() {
+  return new ThemeBuilder({});
+}
+//# sourceMappingURL=ThemeBuilder.js.map

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+}, __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var src_exports = {};
+__export(src_exports, {
+  masks: () => import_masks.masks
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./ThemeBuilder"), module.exports);
+__reExport(src_exports, require("@tamagui/create-theme"), module.exports);
+var import_masks = require("./masks");
+//# sourceMappingURL=index.js.map

package/dist/cjs/masks.js

@@ -0,0 +1,86 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var masks_exports = {};
+__export(masks_exports, {
+  masks: () => masks
+});
+module.exports = __toCommonJS(masks_exports);
+var import_create_theme = require("@tamagui/create-theme");
+const masks = {
+  identity: (0, import_create_theme.createIdentityMask)(),
+  soften: (0, import_create_theme.createSoftenMask)(),
+  soften2: (0, import_create_theme.createSoftenMask)({ strength: 2 }),
+  soften3: (0, import_create_theme.createSoftenMask)({ strength: 3 }),
+  strengthen: (0, import_create_theme.createStrengthenMask)(),
+  inverse: (0, import_create_theme.createInverseMask)(),
+  inverseSoften: (0, import_create_theme.combineMasks)((0, import_create_theme.createInverseMask)(), (0, import_create_theme.createSoftenMask)({ strength: 2 })),
+  inverseSoften2: (0, import_create_theme.combineMasks)((0, import_create_theme.createInverseMask)(), (0, import_create_theme.createSoftenMask)({ strength: 3 })),
+  inverseSoften3: (0, import_create_theme.combineMasks)((0, import_create_theme.createInverseMask)(), (0, import_create_theme.createSoftenMask)({ strength: 4 })),
+  inverseStrengthen2: (0, import_create_theme.combineMasks)(
+    (0, import_create_theme.createInverseMask)(),
+    (0, import_create_theme.createStrengthenMask)({ strength: 2 })
+  ),
+  strengthenButSoftenBorder: (0, import_create_theme.createMask)((template, options) => {
+    const stronger = (0, import_create_theme.createStrengthenMask)().mask(template, options), softer = (0, import_create_theme.createSoftenMask)().mask(template, options);
+    return {
+      ...stronger,
+      borderColor: softer.borderColor,
+      borderColorHover: softer.borderColorHover,
+      borderColorPress: softer.borderColorPress,
+      borderColorFocus: softer.borderColorFocus
+    };
+  }),
+  soften2Border1: (0, import_create_theme.createMask)((template, options) => {
+    const softer2 = (0, import_create_theme.createSoftenMask)({ strength: 2 }).mask(template, options), softer1 = (0, import_create_theme.createSoftenMask)({ strength: 1 }).mask(template, options);
+    return {
+      ...softer2,
+      borderColor: softer1.borderColor,
+      borderColorHover: softer1.borderColorHover,
+      borderColorPress: softer1.borderColorPress,
+      borderColorFocus: softer1.borderColorFocus
+    };
+  }),
+  soften3FlatBorder: (0, import_create_theme.createMask)((template, options) => {
+    const borderMask = (0, import_create_theme.createSoftenMask)({ strength: 2 }).mask(template, options);
+    return {
+      ...(0, import_create_theme.createSoftenMask)({ strength: 3 }).mask(template, options),
+      borderColor: borderMask.borderColor,
+      borderColorHover: borderMask.borderColorHover,
+      borderColorPress: borderMask.borderColorPress,
+      borderColorFocus: borderMask.borderColorFocus
+    };
+  }),
+  softenBorder: (0, import_create_theme.createMask)((template, options) => {
+    const plain = import_create_theme.skipMask.mask(template, options), softer = (0, import_create_theme.createSoftenMask)().mask(template, options);
+    return {
+      ...plain,
+      borderColor: softer.borderColor,
+      borderColorHover: softer.borderColorHover,
+      borderColorPress: softer.borderColorPress,
+      borderColorFocus: softer.borderColorFocus
+    };
+  }),
+  softenBorder2: (0, import_create_theme.createMask)((template, options) => {
+    const plain = import_create_theme.skipMask.mask(template, options), softer = (0, import_create_theme.createSoftenMask)({ strength: 2 }).mask(template, options);
+    return {
+      ...plain,
+      borderColor: softer.borderColor,
+      borderColorHover: softer.borderColorHover,
+      borderColorPress: softer.borderColorPress,
+      borderColorFocus: softer.borderColorFocus
+    };
+  })
+};
+//# sourceMappingURL=masks.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/theme-builder",
-  "version": "1.116.1",
+  "version": "1.116.2",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "dist/cjs",
@@ -30,11 +30,11 @@
     }
   },
   "dependencies": {
-    "@tamagui/create-theme": "1.116.1",
+    "@tamagui/create-theme": "1.116.2",
     "color2k": "^2.0.2"
   },
   "devDependencies": {
-    "@tamagui/build": "1.116.1"
+    "@tamagui/build": "1.116.2"
   },
   "publishConfig": {
     "access": "public"