@oxyhq/bloom 0.72.0 → 0.72.1

package/lib/commonjs/fonts/FontLoader.node.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FontLoader = FontLoader;
+var _react = _interopRequireDefault(require("react"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+function FontLoader({
+  children
+}) {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+    children: children
+  });
+}
+//# sourceMappingURL=FontLoader.node.js.map

package/lib/commonjs/fonts/FontLoader.node.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_jsxRuntime","e","__esModule","default","FontLoader","children","jsx","Fragment"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.node.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA0B,IAAAC,WAAA,GAAAD,OAAA;AAAA,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAU1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,UAAUA,CAAC;EAAEC;AAA0B,CAAC,EAAE;EACxD,oBAAO,IAAAL,WAAA,CAAAM,GAAA,EAAAN,WAAA,CAAAO,QAAA;IAAAF,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}

package/lib/commonjs/fonts/index.node.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FONT_ASSETS", {
+  enumerable: true,
+  get: function () {
+    return _fontAssets.FONT_ASSETS;
+  }
+});
+Object.defineProperty(exports, "FontLoader", {
+  enumerable: true,
+  get: function () {
+    return _FontLoaderNode.FontLoader;
+  }
+});
+Object.defineProperty(exports, "applyFontFaces", {
+  enumerable: true,
+  get: function () {
+    return _applyFontFaces.applyFontFaces;
+  }
+});
+Object.defineProperty(exports, "fontCssVars", {
+  enumerable: true,
+  get: function () {
+    return _tokens.fontCssVars;
+  }
+});
+Object.defineProperty(exports, "fontFamilies", {
+  enumerable: true,
+  get: function () {
+    return _tokens.fontFamilies;
+  }
+});
+var _tokens = require("./tokens.js");
+var _applyFontFaces = require("./apply-font-faces");
+var _fontAssets = require("./font-assets");
+var _FontLoaderNode = require("./FontLoader.node.js");
+//# sourceMappingURL=index.node.js.map

package/lib/commonjs/fonts/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_tokens","require","_applyFontFaces","_fontAssets","_FontLoaderNode"],"sourceRoot":"../../../src","sources":["fonts/index.node.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,eAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAF,OAAA;AACA,IAAAG,eAAA,GAAAH,OAAA","ignoreList":[]}

package/lib/module/fonts/FontLoader.node.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import React from 'react';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+export function FontLoader({
+  children
+}) {
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: children
+  });
+}
+//# sourceMappingURL=FontLoader.node.js.map

package/lib/module/fonts/FontLoader.node.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","Fragment","_Fragment","jsx","_jsx","FontLoader","children"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.node.tsx"],"mappings":";;AAAA,OAAOA,KAAK,MAAM,OAAO;AAAC,SAAAC,QAAA,IAAAC,SAAA,EAAAC,GAAA,IAAAC,IAAA;AAU1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CAAC;EAAEC;AAA0B,CAAC,EAAE;EACxD,oBAAOF,IAAA,CAAAF,SAAA;IAAAI,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}

package/lib/module/fonts/index.node.js

@@ -0,0 +1,22 @@
+"use strict";
+
+// Node variant of the `./fonts` barrel, selected by the `node` export
+// condition. Same surface as `./index.ts`, with every member resolved to the
+// inert implementation:
+//
+// - `./apply-font-faces` is the no-op stub. The web one is unreachable here on
+//   purpose: it imports `font-urls.web`, whose `.woff2` imports Node feeds to
+//   the JS parser, so loading it throws `SyntaxError` before any runtime guard
+//   can help.
+// - `./font-assets` is the empty map — there is no native font registry.
+// - `./FontLoader.node` renders children and nothing else.
+//
+// Both platform-forked members are named OUTRIGHT rather than left
+// extensionless, for the same reason `index.web.ts` does it: Node performs no
+// platform-extension resolution, so a bare specifier would fall through to
+// whichever file happens to sit at that path.
+export { fontFamilies, fontCssVars } from "./tokens.js";
+export { applyFontFaces } from './apply-font-faces';
+export { FONT_ASSETS } from './font-assets';
+export { FontLoader } from "./FontLoader.node.js";
+//# sourceMappingURL=index.node.js.map

package/lib/module/fonts/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fontFamilies","fontCssVars","applyFontFaces","FONT_ASSETS","FontLoader"],"sourceRoot":"../../../src","sources":["fonts/index.node.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,YAAY,EAAEC,WAAW,QAAQ,aAAU;AAEpD,SAASC,cAAc,QAAQ,oBAAoB;AACnD,SAASC,WAAW,QAAQ,eAAe;AAC3C,SAASC,UAAU,QAAQ,sBAAmB","ignoreList":[]}

package/lib/typescript/commonjs/fonts/FontLoader.node.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+export interface FontLoaderProps {
+    /** Ignored — there is nothing to load. Kept so the API matches every platform. */
+    enabled: boolean;
+    /** Ignored — nothing is ever pending, so children render immediately. */
+    fallback?: React.ReactNode;
+    children: React.ReactNode;
+}
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+export declare function FontLoader({ children }: FontLoaderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FontLoader.node.d.ts.map

package/lib/typescript/commonjs/fonts/FontLoader.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontLoader.node.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.node.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAEvD"}

package/lib/typescript/commonjs/fonts/index.node.d.ts

@@ -0,0 +1,7 @@
+export { fontFamilies, fontCssVars } from './tokens';
+export type { FontFamilyName } from './tokens';
+export { applyFontFaces } from './apply-font-faces';
+export { FONT_ASSETS } from './font-assets';
+export { FontLoader } from './FontLoader.node';
+export type { FontLoaderProps } from './FontLoader.node';
+//# sourceMappingURL=index.node.d.ts.map

package/lib/typescript/commonjs/fonts/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../../../../src/fonts/index.node.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACrD,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/lib/typescript/module/fonts/FontLoader.node.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+export interface FontLoaderProps {
+    /** Ignored — there is nothing to load. Kept so the API matches every platform. */
+    enabled: boolean;
+    /** Ignored — nothing is ever pending, so children render immediately. */
+    fallback?: React.ReactNode;
+    children: React.ReactNode;
+}
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+export declare function FontLoader({ children }: FontLoaderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FontLoader.node.d.ts.map

package/lib/typescript/module/fonts/FontLoader.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontLoader.node.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.node.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAEvD"}

package/lib/typescript/module/fonts/index.node.d.ts

@@ -0,0 +1,7 @@
+export { fontFamilies, fontCssVars } from './tokens';
+export type { FontFamilyName } from './tokens';
+export { applyFontFaces } from './apply-font-faces';
+export { FONT_ASSETS } from './font-assets';
+export { FontLoader } from './FontLoader.node';
+export type { FontLoaderProps } from './FontLoader.node';
+//# sourceMappingURL=index.node.d.ts.map

package/lib/typescript/module/fonts/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../../../../src/fonts/index.node.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACrD,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/bloom",
-  "version": "0.72.0",
+  "version": "0.72.1",
   "description": "Bloom UI — Oxy ecosystem component library for React Native + Expo + Web",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -1233,6 +1233,11 @@
         "import": "./lib/module/fonts/index.web.js",
         "require": "./lib/commonjs/fonts/index.web.js"
       },
+      "node": {
+        "types": "./lib/typescript/module/fonts/index.node.d.ts",
+        "import": "./lib/module/fonts/index.node.js",
+        "require": "./lib/commonjs/fonts/index.node.js"
+      },
       "import": {
         "types": "./lib/typescript/module/fonts/index.d.ts",
         "default": "./lib/module/fonts/index.js"

package/src/fonts/FontLoader.node.tsx

@@ -0,0 +1,30 @@
+import React from 'react';
+
+export interface FontLoaderProps {
+  /** Ignored — there is nothing to load. Kept so the API matches every platform. */
+  enabled: boolean;
+  /** Ignored — nothing is ever pending, so children render immediately. */
+  fallback?: React.ReactNode;
+  children: React.ReactNode;
+}
+
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+export function FontLoader({ children }: FontLoaderProps) {
+  return <>{children}</>;
+}

package/src/fonts/index.node.ts

@@ -0,0 +1,21 @@
+// Node variant of the `./fonts` barrel, selected by the `node` export
+// condition. Same surface as `./index.ts`, with every member resolved to the
+// inert implementation:
+//
+// - `./apply-font-faces` is the no-op stub. The web one is unreachable here on
+//   purpose: it imports `font-urls.web`, whose `.woff2` imports Node feeds to
+//   the JS parser, so loading it throws `SyntaxError` before any runtime guard
+//   can help.
+// - `./font-assets` is the empty map — there is no native font registry.
+// - `./FontLoader.node` renders children and nothing else.
+//
+// Both platform-forked members are named OUTRIGHT rather than left
+// extensionless, for the same reason `index.web.ts` does it: Node performs no
+// platform-extension resolution, so a bare specifier would fall through to
+// whichever file happens to sit at that path.
+export { fontFamilies, fontCssVars } from './tokens';
+export type { FontFamilyName } from './tokens';
+export { applyFontFaces } from './apply-font-faces';
+export { FONT_ASSETS } from './font-assets';
+export { FontLoader } from './FontLoader.node';
+export type { FontLoaderProps } from './FontLoader.node';