taffy-js 0.2.4 → 0.2.6

package/README.md

@@ -23,7 +23,8 @@ npm install taffy-js
 ## 🚀 Quick Start
 
 ```javascript
-import init, {
+import {
+  loadTaffy,
   TaffyTree,
   Style,
   Display,
@@ -33,7 +34,7 @@ import init, {
 
 async function main() {
   // Initialize WebAssembly module
-  await init();
+  await loadTaffy();
 
   // Create a layout tree
   const tree = new TaffyTree();

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Taffy-JS: TypeScript wrapper for Taffy WASM bindings
+ *
+ * This module provides the `loadTaffy` function for initializing the WASM module
+ * and re-exports all types and functions from the underlying WASM bindings.
+ *
+ * @example
+ * ```typescript
+ * import { loadTaffy, TaffyTree, Style, Display } from 'taffy-js';
+ *
+ * await loadTaffy();
+ *
+ * const tree = new TaffyTree();
+ * const style = new Style();
+ * style.display = Display.Flex;
+ * const node = tree.newLeaf(style);
+ * ```
+ */
+export * from "../pkg/taffy_wasm.js";
+export type { InitOutput } from "../pkg/taffy_wasm.js";
+import type { InitOutput } from "../pkg/taffy_wasm.js";
+/**
+ * Universal initialization function for Taffy WASM module.
+ *
+ * Automatically detects the environment (Web or Node.js) and loads the WASM accordingly.
+ * - In a **Web environment**, it uses `fetch` to load the WASM file.
+ * - In a **Node.js environment**, it uses `fs` to read the WASM file.
+ *
+ * @returns - A promise that resolves to the WASM module exports.
+ *
+ * @example
+ * ```typescript
+ * import { loadTaffy } from 'taffy-js';
+ * await loadTaffy();
+ * ```
+ */
+export declare function loadTaffy(): Promise<InitOutput>;
+export default loadTaffy;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,cAAc,sBAAsB,CAAC;AACrC,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAavD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC,CAkBrD;AAGD,eAAe,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,66 @@
+/**
+ * Taffy-JS: TypeScript wrapper for Taffy WASM bindings
+ *
+ * This module provides the `loadTaffy` function for initializing the WASM module
+ * and re-exports all types and functions from the underlying WASM bindings.
+ *
+ * @example
+ * ```typescript
+ * import { loadTaffy, TaffyTree, Style, Display } from 'taffy-js';
+ *
+ * await loadTaffy();
+ *
+ * const tree = new TaffyTree();
+ * const style = new Style();
+ * style.display = Display.Flex;
+ * const node = tree.newLeaf(style);
+ * ```
+ */
+// Re-export everything from the WASM module
+export * from "../pkg/taffy_wasm.js";
+// Import the init functions for the loader
+import init, { initSync } from "../pkg/taffy_wasm.js";
+/**
+ * Detects if running in a Node.js environment
+ */
+function isNode() {
+    return (typeof process !== "undefined" &&
+        process.versions != null &&
+        process.versions.node != null);
+}
+/**
+ * Universal initialization function for Taffy WASM module.
+ *
+ * Automatically detects the environment (Web or Node.js) and loads the WASM accordingly.
+ * - In a **Web environment**, it uses `fetch` to load the WASM file.
+ * - In a **Node.js environment**, it uses `fs` to read the WASM file.
+ *
+ * @returns - A promise that resolves to the WASM module exports.
+ *
+ * @example
+ * ```typescript
+ * import { loadTaffy } from 'taffy-js';
+ * await loadTaffy();
+ * ```
+ */
+export async function loadTaffy() {
+    if (isNode()) {
+        // Node.js environment - use fs to read the WASM file
+        const fs = await import("fs");
+        const url = await import("url");
+        const path = await import("path");
+        // Resolve WASM path relative to this module
+        const __filename = url.fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const wasmPath = path.join(__dirname, "..", "pkg", "taffy_wasm_bg.wasm");
+        const wasmBuffer = fs.readFileSync(wasmPath);
+        return initSync({ module: wasmBuffer });
+    }
+    else {
+        // Web environment - use fetch via the default init function
+        return await init();
+    }
+}
+// Default export for convenience
+export default loadTaffy;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,4CAA4C;AAC5C,cAAc,sBAAsB,CAAC;AAGrC,2CAA2C;AAC3C,OAAO,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGtD;;GAEG;AACH,SAAS,MAAM;IACb,OAAO,CACL,OAAO,OAAO,KAAK,WAAW;QAC9B,OAAO,CAAC,QAAQ,IAAI,IAAI;QACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI,IAAI,CAC9B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS;IAC7B,IAAI,MAAM,EAAE,EAAE,CAAC;QACb,qDAAqD;QACrD,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,CAAC;QAChC,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;QAElC,4CAA4C;QAC5C,MAAM,UAAU,GAAG,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,oBAAoB,CAAC,CAAC;QAEzE,MAAM,UAAU,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC7C,OAAO,QAAQ,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;IAC1C,CAAC;SAAM,CAAC;QACN,4DAA4D;QAC5D,OAAO,MAAM,IAAI,EAAE,CAAC;IACtB,CAAC;AACH,CAAC;AAED,iCAAiC;AACjC,eAAe,SAAS,CAAC"}

package/package.json

@@ -1,24 +1,79 @@
 {
   "name": "taffy-js",
-  "type": "module",
-  "collaborators": [
-    "ByteLandTechnology <github@byteland.app>"
-  ],
+  "version": "0.2.6",
   "description": "WebAssembly bindings for Taffy layout library",
-  "version": "0.2.4",
-  "license": "MIT",
+  "keywords": [
+    "layout",
+    "flexbox",
+    "css-grid",
+    "grid",
+    "ui",
+    "wasm",
+    "webassembly"
+  ],
+  "homepage": "https://github.com/ByteLandTechnology/taffy-js#readme",
+  "bugs": {
+    "url": "https://github.com/ByteLandTechnology/taffy-js/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/ByteLandTechnology/taffy-js"
+    "url": "git+https://github.com/ByteLandTechnology/taffy-js.git"
+  },
+  "license": "MIT",
+  "author": "ByteLandTechnology <github@byteland.app>",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./wasm": {
+      "types": "./pkg/taffy_wasm.d.ts",
+      "import": "./pkg/taffy_wasm.js"
+    }
   },
   "files": [
-    "taffy_js_bg.wasm",
-    "taffy_js.js",
-    "taffy_js.d.ts"
+    "dist",
+    "pkg"
   ],
-  "main": "taffy_js.js",
-  "types": "taffy_js.d.ts",
-  "sideEffects": [
-    "./snippets/*"
-  ]
+  "scripts": {
+    "build": "npm run build:wasm && npm run build:ts && npm run docs",
+    "build:wasm": "wasm-pack build --release --target web && rm -f pkg/.gitignore && npm run patch-dts",
+    "build:ts": "tsc",
+    "build:dev": "wasm-pack build --dev --target web && npm run patch-dts && npm run build:ts",
+    "docs": "typedoc && prettier --write docs",
+    "patch-dts": "npx tsx scripts/patch-dts.ts",
+    "test": "wasm-pack test --node",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.3.0",
+    "@commitlint/config-conventional": "^20.3.0",
+    "@types/node": "^22.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "tsx": "^4.0.0",
+    "typedoc": "^0.28.15",
+    "typedoc-plugin-markdown": "^4.9.0",
+    "typescript": "^5.7.0",
+    "wasm-pack": "^0.13.1"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "overrides": {
+    "axios": "^1.7.9"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "lint-staged": {
+    "*.{js,ts,jsx,tsx,json,md,yaml,yml}": "prettier --write",
+    "*.rs": "cargo fmt --"
+  }
 }

package/pkg/README.md

@@ -0,0 +1,453 @@
+# Taffy-JS
+
+[![npm version](https://badge.fury.io/js/taffy-js.svg)](https://www.npmjs.com/package/taffy-js)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+High-performance WebAssembly bindings for the [Taffy](https://github.com/DioxusLabs/taffy) layout engine, bringing CSS Flexbox and Grid layout algorithms to JavaScript with near-native performance.
+
+## ✨ Features
+
+- **🚀 High Performance**: WebAssembly-powered layout calculations
+- **📦 Complete CSS Support**: Full Flexbox and CSS Grid implementation
+- **🔧 Custom Measurement**: Support for custom text/content measurement callbacks
+- **📝 TypeScript Ready**: Complete type definitions included
+- **🌳 Tree-Based API**: Efficient tree structure for complex layouts
+- **💡 Familiar API**: CSS-like property names and values
+
+## 📦 Installation
+
+```bash
+npm install taffy-js
+```
+
+## 🚀 Quick Start
+
+```javascript
+import {
+  loadTaffy,
+  TaffyTree,
+  Style,
+  Display,
+  FlexDirection,
+  AlignItems,
+} from "taffy-js";
+
+async function main() {
+  // Initialize WebAssembly module
+  await loadTaffy();
+
+  // Create a layout tree
+  const tree = new TaffyTree();
+
+  // Create container style
+  const containerStyle = new Style();
+  containerStyle.display = Display.Flex;
+  containerStyle.flexDirection = FlexDirection.Column;
+  containerStyle.alignItems = AlignItems.Center;
+  containerStyle.size = { width: { Length: 300 }, height: { Length: 200 } };
+  containerStyle.padding = {
+    left: { Length: 10 },
+    right: { Length: 10 },
+    top: { Length: 10 },
+    bottom: { Length: 10 },
+  };
+
+  // Create child styles
+  const childStyle = new Style();
+  childStyle.flexGrow = 1;
+  childStyle.size = { width: { Percent: 100 }, height: "Auto" };
+
+  // Create nodes
+  const child1 = tree.newLeaf(childStyle);
+  const child2 = tree.newLeaf(childStyle);
+  const container = tree.newWithChildren(
+    containerStyle,
+    BigUint64Array.from([child1, child2]),
+  );
+
+  // Compute layout
+  tree.computeLayout(container, {
+    width: { Definite: 300 },
+    height: { Definite: 200 },
+  });
+
+  // Read computed layouts
+  const containerLayout = tree.getLayout(container);
+  const child1Layout = tree.getLayout(child1);
+  const child2Layout = tree.getLayout(child2);
+
+  console.log(`Container: ${containerLayout.width}x${containerLayout.height}`);
+  console.log(
+    `Child 1: ${child1Layout.width}x${child1Layout.height} at (${child1Layout.x}, ${child1Layout.y})`,
+  );
+  console.log(
+    `Child 2: ${child2Layout.width}x${child2Layout.height} at (${child2Layout.x}, ${child2Layout.y})`,
+  );
+}
+
+main();
+```
+
+## 📖 API Reference
+
+### TaffyTree
+
+The main class for managing layout trees.
+
+```typescript
+class TaffyTree {
+  // Construction
+  constructor();
+  static withCapacity(capacity: number): TaffyTree;
+
+  // Node Creation (throws TaffyError on failure)
+  newLeaf(style: Style): bigint;
+  newLeafWithContext(style: Style, context: any): bigint;
+  newWithChildren(style: Style, children: BigUint64Array): bigint;
+
+  // Tree Operations
+  clear(): void;
+  remove(node: bigint): bigint; // throws TaffyError
+  totalNodeCount(): number;
+
+  // Child Management (throws TaffyError on failure)
+  addChild(parent: bigint, child: bigint): void;
+  removeChild(parent: bigint, child: bigint): bigint;
+  setChildren(parent: bigint, children: BigUint64Array): void;
+  children(parent: bigint): BigUint64Array;
+  childCount(parent: bigint): number;
+  parent(child: bigint): bigint | undefined;
+
+  // Style Management (throws TaffyError on failure)
+  setStyle(node: bigint, style: Style): void;
+  getStyle(node: bigint): Style;
+
+  // Layout Computation (throws TaffyError on failure)
+  computeLayout(node: bigint, availableSpace: Size<AvailableSpace>): void;
+  computeLayoutWithMeasure(
+    node: bigint,
+    availableSpace: Size<AvailableSpace>,
+    measureFunc: MeasureFunction,
+  ): void;
+
+  // Layout Results (throws TaffyError on failure)
+  getLayout(node: bigint): Layout;
+  unroundedLayout(node: bigint): Layout;
+
+  // Dirty Tracking (throws TaffyError on failure)
+  markDirty(node: bigint): void;
+  dirty(node: bigint): boolean;
+
+  // Configuration
+  enableRounding(): void;
+  disableRounding(): void;
+}
+```
+
+### Style
+
+Configuration object for node layout properties.
+
+```typescript
+class Style {
+  constructor();
+
+  // Layout Mode
+  display: Display; // Block, Flex, Grid, None
+  position: Position; // Relative, Absolute
+
+  // Flexbox
+  flexDirection: FlexDirection; // Row, Column, RowReverse, ColumnReverse
+  flexWrap: FlexWrap; // NoWrap, Wrap, WrapReverse
+  flexGrow: number; // Growth factor (default: 0)
+  flexShrink: number; // Shrink factor (default: 1)
+  flexBasis: Dimension; // Initial size
+
+  // Alignment
+  alignItems: AlignItems | undefined;
+  alignSelf: AlignSelf | undefined;
+  alignContent: AlignContent | undefined;
+  justifyContent: JustifyContent | undefined;
+
+  // Sizing
+  size: Size<Dimension>; // Width and height
+  minSize: Size<Dimension>; // Minimum constraints
+  maxSize: Size<Dimension>; // Maximum constraints
+  aspectRatio: number | undefined; // Width/height ratio
+  boxSizing: BoxSizing; // BorderBox, ContentBox
+
+  // Spacing
+  margin: Rect<LengthPercentageAuto>;
+  padding: Rect<LengthPercentage>;
+  border: Rect<LengthPercentage>;
+  gap: Size<LengthPercentage>; // Row and column gap
+  inset: Rect<LengthPercentageAuto>; // For absolute positioning
+
+  // Overflow
+  overflow: Point<Overflow>;
+}
+```
+
+### Layout
+
+Read-only computed layout result.
+
+```typescript
+class Layout {
+  // Position (relative to parent)
+  readonly x: number;
+  readonly y: number;
+
+  // Size
+  readonly width: number;
+  readonly height: number;
+
+  // Content size (for scrollable content)
+  readonly contentWidth: number;
+  readonly contentHeight: number;
+
+  // Spacing
+  readonly paddingTop: number;
+  readonly paddingRight: number;
+  readonly paddingBottom: number;
+  readonly paddingLeft: number;
+
+  readonly borderTop: number;
+  readonly borderRight: number;
+  readonly borderBottom: number;
+  readonly borderLeft: number;
+
+  readonly marginTop: number;
+  readonly marginRight: number;
+  readonly marginBottom: number;
+  readonly marginLeft: number;
+
+  // Scrollbars
+  readonly scrollbarWidth: number;
+  readonly scrollbarHeight: number;
+
+  // Rendering order
+  readonly order: number;
+}
+```
+
+### Enums
+
+```typescript
+enum Display {
+  Block,
+  Flex,
+  Grid,
+  None,
+}
+enum Position {
+  Relative,
+  Absolute,
+}
+enum FlexDirection {
+  Row,
+  Column,
+  RowReverse,
+  ColumnReverse,
+}
+enum FlexWrap {
+  NoWrap,
+  Wrap,
+  WrapReverse,
+}
+enum AlignItems {
+  Start,
+  End,
+  FlexStart,
+  FlexEnd,
+  Center,
+  Baseline,
+  Stretch,
+}
+enum AlignSelf {
+  Auto,
+  Start,
+  End,
+  FlexStart,
+  FlexEnd,
+  Center,
+  Baseline,
+  Stretch,
+}
+enum AlignContent {
+  Start,
+  End,
+  FlexStart,
+  FlexEnd,
+  Center,
+  Stretch,
+  SpaceBetween,
+  SpaceAround,
+  SpaceEvenly,
+}
+enum JustifyContent {
+  Start,
+  End,
+  FlexStart,
+  FlexEnd,
+  Center,
+  Stretch,
+  SpaceBetween,
+  SpaceAround,
+  SpaceEvenly,
+}
+enum Overflow {
+  Visible,
+  Hidden,
+  Scroll,
+  Auto,
+}
+enum BoxSizing {
+  BorderBox,
+  ContentBox,
+}
+```
+
+### Types
+
+```typescript
+// Dimension values
+type Dimension = { Length: number } | { Percent: number } | "Auto";
+type LengthPercentage = { Length: number } | { Percent: number };
+type LengthPercentageAuto = { Length: number } | { Percent: number } | "Auto";
+
+// Geometry
+interface Size<T> {
+  width: T;
+  height: T;
+}
+interface Rect<T> {
+  left: T;
+  right: T;
+  top: T;
+  bottom: T;
+}
+interface Point<T> {
+  x: T;
+  y: T;
+}
+
+// Available space for layout computation
+type AvailableSpace = { Definite: number } | "MinContent" | "MaxContent";
+
+// Measure function for custom content measurement
+type MeasureFunction = (
+  knownDimensions: Size<number | null>,
+  availableSpace: Size<AvailableSpace>,
+  node: bigint,
+  context: any,
+  style: Style,
+) => Size<number>;
+```
+
+## 📐 Custom Text Measurement
+
+For text nodes or other content that needs dynamic measurement:
+
+```javascript
+const textNode = tree.newLeafWithContext(textStyle, { text: "Hello, World!" });
+
+tree.computeLayoutWithMeasure(
+  rootNode,
+  { width: { Definite: 800 }, height: "MaxContent" },
+  (known, available, node, context, style) => {
+    if (context?.text) {
+      // Your text measurement logic here
+      const width = measureTextWidth(context.text);
+      const height = measureTextHeight(context.text, available.width);
+      return { width, height };
+    }
+    return { width: 0, height: 0 };
+  },
+);
+```
+
+## 🔧 Error Handling
+
+Methods that can fail throw a `TaffyError` as a JavaScript exception. Use try-catch to handle errors:
+
+```javascript
+try {
+  const nodeId = tree.newLeaf(style);
+  console.log("Created node:", nodeId);
+} catch (error) {
+  // error is a TaffyError instance
+  console.error("Error:", error.message);
+}
+```
+
+## 🌐 Browser Support
+
+Taffy-JS works in all modern browsers that support WebAssembly:
+
+- Chrome 57+
+- Firefox 52+
+- Safari 11+
+- Edge 16+
+
+## 📚 Examples
+
+### Flexbox Row Layout
+
+```javascript
+const rowStyle = new Style();
+rowStyle.display = Display.Flex;
+rowStyle.flexDirection = FlexDirection.Row;
+rowStyle.justifyContent = JustifyContent.SpaceBetween;
+rowStyle.gap = { width: { Length: 10 }, height: { Length: 0 } };
+```
+
+### Absolute Positioning
+
+```javascript
+const absoluteStyle = new Style();
+absoluteStyle.position = Position.Absolute;
+absoluteStyle.inset = {
+  left: { Length: 10 },
+  top: { Length: 10 },
+  right: "Auto",
+  bottom: "Auto",
+};
+absoluteStyle.size = { width: { Length: 100 }, height: { Length: 50 } };
+```
+
+### Percentage Sizing
+
+```javascript
+const percentStyle = new Style();
+percentStyle.size = {
+  width: { Percent: 50 }, // 50% of parent
+  height: { Percent: 100 }, // 100% of parent
+};
+```
+
+## 🏗️ Building from Source
+
+```bash
+# Clone the repository
+git clone https://github.com/user/taffy-js.git
+cd taffy-js
+
+# Install dependencies
+npm install
+
+# Build the WebAssembly module
+npm run build
+
+# Run tests
+npm test
+```
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## 🙏 Acknowledgments
+
+- [Taffy](https://github.com/DioxusLabs/taffy) - The Rust layout engine this project wraps
+- [wasm-bindgen](https://github.com/rustwasm/wasm-bindgen) - Rust/WebAssembly interoperability

package/pkg/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "taffy-wasm",
+  "type": "module",
+  "collaborators": [
+    "ByteLandTechnology <github@byteland.app>"
+  ],
+  "description": "WebAssembly bindings for Taffy layout library",
+  "version": "0.9.4",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ByteLandTechnology/taffy-js"
+  },
+  "files": [
+    "taffy_wasm_bg.wasm",
+    "taffy_wasm.js",
+    "taffy_wasm.d.ts"
+  ],
+  "main": "taffy_wasm.js",
+  "types": "taffy_wasm.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/{taffy_js.js → pkg/taffy_wasm.js}

@@ -2853,7 +2853,7 @@ function __wbg_get_imports() {
     const ret = arg0.length;
     return ret;
   };
-  imports.wbg.__wbg_log_e4aa4f07b01ebf55 = function (arg0, arg1) {
+  imports.wbg.__wbg_log_0d6297a6179e3992 = function (arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
   };
   imports.wbg.__wbg_new_1ba21ce319a06297 = function () {
@@ -2994,7 +2994,7 @@ async function __wbg_init(module_or_path) {
   }
 
   if (typeof module_or_path === "undefined") {
-    module_or_path = new URL("taffy_js_bg.wasm", import.meta.url);
+    module_or_path = new URL("taffy_wasm_bg.wasm", import.meta.url);
   }
   const imports = __wbg_get_imports();
 

package/pkg/taffy_wasm_bg.wasm.d.ts

@@ -0,0 +1,212 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_layout_free: (a: number, b: number) => void;
+export const __wbg_style_free: (a: number, b: number) => void;
+export const __wbg_taffyerror_free: (a: number, b: number) => void;
+export const __wbg_taffytree_free: (a: number, b: number) => void;
+export const layout_borderBottom: (a: number) => number;
+export const layout_borderLeft: (a: number) => number;
+export const layout_borderRight: (a: number) => number;
+export const layout_borderTop: (a: number) => number;
+export const layout_contentHeight: (a: number) => number;
+export const layout_contentWidth: (a: number) => number;
+export const layout_height: (a: number) => number;
+export const layout_marginBottom: (a: number) => number;
+export const layout_marginLeft: (a: number) => number;
+export const layout_marginRight: (a: number) => number;
+export const layout_marginTop: (a: number) => number;
+export const layout_order: (a: number) => number;
+export const layout_paddingBottom: (a: number) => number;
+export const layout_paddingLeft: (a: number) => number;
+export const layout_paddingRight: (a: number) => number;
+export const layout_paddingTop: (a: number) => number;
+export const layout_scrollbarHeight: (a: number) => number;
+export const layout_scrollbarWidth: (a: number) => number;
+export const layout_width: (a: number) => number;
+export const layout_x: (a: number) => number;
+export const layout_y: (a: number) => number;
+export const style_alignContent: (a: number) => number;
+export const style_alignItems: (a: number) => number;
+export const style_alignSelf: (a: number) => number;
+export const style_aspectRatio: (a: number) => number;
+export const style_border: (a: number) => any;
+export const style_boxSizing: (a: number) => number;
+export const style_display: (a: number) => number;
+export const style_flexBasis: (a: number) => any;
+export const style_flexDirection: (a: number) => number;
+export const style_flexGrow: (a: number) => number;
+export const style_flexShrink: (a: number) => number;
+export const style_flexWrap: (a: number) => number;
+export const style_gap: (a: number) => any;
+export const style_inset: (a: number) => any;
+export const style_justifyContent: (a: number) => number;
+export const style_margin: (a: number) => any;
+export const style_maxSize: (a: number) => any;
+export const style_minSize: (a: number) => any;
+export const style_new: () => number;
+export const style_overflow: (a: number) => any;
+export const style_padding: (a: number) => any;
+export const style_position: (a: number) => number;
+export const style_set_alignContent: (a: number, b: any) => void;
+export const style_set_alignItems: (a: number, b: any) => void;
+export const style_set_alignSelf: (a: number, b: any) => void;
+export const style_set_aspectRatio: (a: number, b: any) => void;
+export const style_set_border: (a: number, b: any) => void;
+export const style_set_boxSizing: (a: number, b: number) => void;
+export const style_set_display: (a: number, b: number) => void;
+export const style_set_flexBasis: (a: number, b: any) => void;
+export const style_set_flexDirection: (a: number, b: number) => void;
+export const style_set_flexGrow: (a: number, b: number) => void;
+export const style_set_flexShrink: (a: number, b: number) => void;
+export const style_set_flexWrap: (a: number, b: number) => void;
+export const style_set_gap: (a: number, b: any) => void;
+export const style_set_inset: (a: number, b: any) => void;
+export const style_set_justifyContent: (a: number, b: any) => void;
+export const style_set_margin: (a: number, b: any) => void;
+export const style_set_maxSize: (a: number, b: any) => void;
+export const style_set_minSize: (a: number, b: any) => void;
+export const style_set_overflow: (a: number, b: any) => void;
+export const style_set_padding: (a: number, b: any) => void;
+export const style_set_position: (a: number, b: number) => void;
+export const style_set_size: (a: number, b: any) => void;
+export const style_size: (a: number) => any;
+export const taffyerror_message: (a: number) => [number, number];
+export const taffytree_addChild: (
+  a: number,
+  b: bigint,
+  c: bigint,
+) => [number, number];
+export const taffytree_childCount: (a: number, b: bigint) => number;
+export const taffytree_children: (
+  a: number,
+  b: bigint,
+) => [number, number, number, number];
+export const taffytree_clear: (a: number) => void;
+export const taffytree_computeLayout: (
+  a: number,
+  b: bigint,
+  c: any,
+) => [number, number];
+export const taffytree_computeLayoutWithMeasure: (
+  a: number,
+  b: bigint,
+  c: any,
+  d: any,
+) => [number, number];
+export const taffytree_dirty: (
+  a: number,
+  b: bigint,
+) => [number, number, number];
+export const taffytree_disableRounding: (a: number) => void;
+export const taffytree_enableRounding: (a: number) => void;
+export const taffytree_getChildAtIndex: (
+  a: number,
+  b: bigint,
+  c: number,
+) => [bigint, number, number];
+export const taffytree_getDisjointNodeContextMut: (
+  a: number,
+  b: number,
+  c: number,
+) => [number, number, number, number];
+export const taffytree_getLayout: (
+  a: number,
+  b: bigint,
+) => [number, number, number];
+export const taffytree_getNodeContext: (
+  a: number,
+  b: bigint,
+) => [number, number, number];
+export const taffytree_getNodeContextMut: (
+  a: number,
+  b: bigint,
+) => [number, number, number];
+export const taffytree_getStyle: (
+  a: number,
+  b: bigint,
+) => [number, number, number];
+export const taffytree_insertChildAtIndex: (
+  a: number,
+  b: bigint,
+  c: number,
+  d: bigint,
+) => [number, number];
+export const taffytree_markDirty: (a: number, b: bigint) => [number, number];
+export const taffytree_new: () => number;
+export const taffytree_newLeaf: (
+  a: number,
+  b: number,
+) => [bigint, number, number];
+export const taffytree_newLeafWithContext: (
+  a: number,
+  b: number,
+  c: any,
+) => [bigint, number, number];
+export const taffytree_newWithChildren: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+) => [bigint, number, number];
+export const taffytree_parent: (a: number, b: bigint) => [number, bigint];
+export const taffytree_printTree: (a: number, b: bigint) => void;
+export const taffytree_remove: (
+  a: number,
+  b: bigint,
+) => [bigint, number, number];
+export const taffytree_removeChild: (
+  a: number,
+  b: bigint,
+  c: bigint,
+) => [bigint, number, number];
+export const taffytree_removeChildAtIndex: (
+  a: number,
+  b: bigint,
+  c: number,
+) => [bigint, number, number];
+export const taffytree_removeChildrenRange: (
+  a: number,
+  b: bigint,
+  c: number,
+  d: number,
+) => [number, number];
+export const taffytree_replaceChildAtIndex: (
+  a: number,
+  b: bigint,
+  c: number,
+  d: bigint,
+) => [bigint, number, number];
+export const taffytree_setChildren: (
+  a: number,
+  b: bigint,
+  c: number,
+  d: number,
+) => [number, number];
+export const taffytree_setNodeContext: (
+  a: number,
+  b: bigint,
+  c: any,
+) => [number, number];
+export const taffytree_setStyle: (
+  a: number,
+  b: bigint,
+  c: number,
+) => [number, number];
+export const taffytree_totalNodeCount: (a: number) => number;
+export const taffytree_unroundedLayout: (a: number, b: bigint) => number;
+export const taffytree_withCapacity: (a: number) => number;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __externref_drop_slice: (a: number, b: number) => void;
+export const __wbindgen_start: () => void;