@clary-so/measure 0.4.5 → 0.4.7

package/node_modules/yoga-layout-prebuilt/yoga-layout/dist/entry-common.js.flow

@@ -0,0 +1,360 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ * @format
+ */
+
+const CONSTANTS = require('./YGEnums');
+import type {
+  Yoga$Edge,
+  Yoga$FlexWrap,
+  Yoga$Align,
+  Yoga$FlexDirection,
+  Yoga$Direction,
+  Yoga$PositionType,
+  Yoga$Overflow,
+  Yoga$JustifyContent,
+  Yoga$Display,
+  Yoga$ExperimentalFeature,
+} from './YGEnums';
+
+class Layout {
+  left: number;
+  right: number;
+  top: number;
+  bottom: number;
+  width: number;
+  height: number;
+
+  constructor(left, right, top, bottom, width, height) {
+    this.left = left;
+    this.right = right;
+    this.top = top;
+    this.bottom = bottom;
+    this.width = width;
+    this.height = height;
+  }
+
+  fromJS(expose) {
+    expose(
+      this.left,
+      this.right,
+      this.top,
+      this.bottom,
+      this.width,
+      this.height,
+    );
+  }
+
+  toString() {
+    return `<Layout#${this.left}:${this.right};${this.top}:${this.bottom};${
+      this.width
+    }:${this.height}>`;
+  }
+}
+
+class Size {
+  static fromJS({width, height}) {
+    return new Size(width, height);
+  }
+
+  width: number;
+  height: number;
+
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+  }
+
+  fromJS(expose) {
+    expose(this.width, this.height);
+  }
+
+  toString() {
+    return `<Size#${this.width}x${this.height}>`;
+  }
+}
+
+class Value {
+  unit: number;
+  value: number;
+
+  constructor(unit, value) {
+    this.unit = unit;
+    this.value = value;
+  }
+
+  fromJS(expose) {
+    expose(this.unit, this.value);
+  }
+
+  toString() {
+    switch (this.unit) {
+      case CONSTANTS.UNIT_POINT:
+        return String(this.value);
+      case CONSTANTS.UNIT_PERCENT:
+        return `${this.value}%`;
+      case CONSTANTS.UNIT_AUTO:
+        return 'auto';
+      default: {
+        return `${this.value}?`;
+      }
+    }
+  }
+
+  valueOf() {
+    return this.value;
+  }
+}
+
+export type Yoga$Config = {
+  isExperimentalFeatureEnabled(feature: Yoga$ExperimentalFeature): boolean,
+  setExperimentalFeatureEnabled(
+    feature: Yoga$ExperimentalFeature,
+    enabled: boolean,
+  ): void,
+  setPointScaleFactor(factor: number): void,
+};
+
+export type Yoga$Node = {
+  calculateLayout(
+    width?: number,
+    height?: number,
+    direction?: Yoga$Direction,
+  ): void,
+  copyStyle(node: Yoga$Node): void,
+  free(): void,
+  freeRecursive(): void,
+  getAlignContent(): Yoga$Align,
+  getAlignItems(): Yoga$Align,
+  getAlignSelf(): Yoga$Align,
+  getAspectRatio(): number,
+  getBorder(edge: Yoga$Edge): number,
+  getChild(index: number): Yoga$Node,
+  getChildCount(): number,
+  getComputedBorder(edge: Yoga$Edge): number,
+  getComputedBottom(): number,
+  getComputedHeight(): number,
+  getComputedLayout(): Layout,
+  getComputedLeft(): number,
+  getComputedMargin(edge: Yoga$Edge): number,
+  getComputedPadding(edge: Yoga$Edge): number,
+  getComputedRight(): number,
+  getComputedTop(): number,
+  getComputedWidth(): number,
+  getDisplay(): Yoga$Display,
+  getFlexBasis(): number,
+  getFlexDirection(): Yoga$FlexDirection,
+  getFlexGrow(): number,
+  getFlexShrink(): number,
+  getFlexWrap(): Yoga$FlexWrap,
+  getHeight(): Value,
+  getJustifyContent(): Yoga$JustifyContent,
+  getMargin(edge: Yoga$Edge): Value,
+  getMaxHeight(): Value,
+  getMaxWidth(): Value,
+  getMinHeight(): Value,
+  getMinWidth(): Value,
+  getOverflow(): Yoga$Overflow,
+  getPadding(edge: Yoga$Edge): Value,
+  getParent(): ?Yoga$Node,
+  getPosition(edge: Yoga$Edge): Value,
+  getPositionType(): Yoga$PositionType,
+  getWidth(): Value,
+  insertChild(child: Yoga$Node, index: number): void,
+  isDirty(): boolean,
+  markDirty(): void,
+  removeChild(child: Yoga$Node): void,
+  reset(): void,
+  setAlignContent(alignContent: Yoga$Align): void,
+  setAlignItems(alignItems: Yoga$Align): void,
+  setAlignSelf(alignSelf: Yoga$Align): void,
+  setAspectRatio(aspectRatio: number): void,
+  setBorder(edge: Yoga$Edge, borderWidth: number): void,
+  setDisplay(display: Yoga$Display): void,
+  setFlex(flex: number): void,
+  setFlexBasis(flexBasis: number | string): void,
+  setFlexBasisPercent(flexBasis: number): void,
+  setFlexDirection(flexDirection: Yoga$FlexDirection): void,
+  setFlexGrow(flexGrow: number): void,
+  setFlexShrink(flexShrink: number): void,
+  setFlexWrap(flexWrap: Yoga$FlexWrap): void,
+  setHeight(height: number | string): void,
+  setHeightAuto(): void,
+  setHeightPercent(height: number): void,
+  setJustifyContent(justifyContent: Yoga$JustifyContent): void,
+  setMargin(edge: Yoga$Edge, margin: number): void,
+  setMarginAuto(edge: Yoga$Edge): void,
+  setMarginPercent(edge: Yoga$Edge, margin: number): void,
+  setMaxHeight(maxHeight: number | string): void,
+  setMaxHeightPercent(maxHeight: number): void,
+  setMaxWidth(maxWidth: number | string): void,
+  setMaxWidthPercent(maxWidth: number): void,
+  setMeasureFunc(measureFunc: ?Function): void,
+  setMinHeight(minHeight: number | string): void,
+  setMinHeightPercent(minHeight: number): void,
+  setMinWidth(minWidth: number | string): void,
+  setMinWidthPercent(minWidth: number): void,
+  setOverflow(overflow: Yoga$Overflow): void,
+  setPadding(edge: Yoga$Edge, padding: number | string): void,
+  setPaddingPercent(edge: Yoga$Edge, padding: number): void,
+  setPosition(edge: Yoga$Edge, position: number | string): void,
+  setPositionPercent(edge: Yoga$Edge, position: number): void,
+  setPositionType(positionType: Yoga$PositionType): void,
+  setWidth(width: number | string): void,
+  setWidthAuto(): void,
+  setWidthPercent(width: number): void,
+  unsetMeasureFun(): void,
+};
+
+type Yoga = {
+  Config: {
+    create(): Yoga$Config,
+    destroy(config: Yoga$Config): any,
+  },
+  Node: {
+    create(): Yoga$Node,
+    createDefault(): Yoga$Node,
+    createWithConfig(config: Yoga$Config): Yoga$Node,
+    destroy(node: Yoga$Node): any,
+  },
+  Layout: Layout,
+  Size: Size,
+  Value: Value,
+  getInstanceCount(): number,
+  ...typeof CONSTANTS,
+};
+
+module.exports = (bind: any, lib: any): Yoga => {
+  function patch(prototype, name, fn) {
+    let original = prototype[name];
+
+    prototype[name] = function(...args) {
+      return fn.call(this, original, ...args);
+    };
+  }
+
+  for (let fnName of [
+    'setPosition',
+    'setMargin',
+    'setFlexBasis',
+    'setWidth',
+    'setHeight',
+    'setMinWidth',
+    'setMinHeight',
+    'setMaxWidth',
+    'setMaxHeight',
+    'setPadding',
+  ]) {
+    let methods = {
+      [CONSTANTS.UNIT_POINT]: lib.Node.prototype[fnName],
+      [CONSTANTS.UNIT_PERCENT]: lib.Node.prototype[`${fnName}Percent`],
+      [CONSTANTS.UNIT_AUTO]: lib.Node.prototype[`${fnName}Auto`],
+    };
+
+    patch(lib.Node.prototype, fnName, function(original, ...args) {
+      // We patch all these functions to add support for the following calls:
+      // .setWidth(100) / .setWidth("100%") / .setWidth(.getWidth()) / .setWidth("auto")
+
+      let value = args.pop();
+      let unit, asNumber;
+
+      if (value === 'auto') {
+        unit = CONSTANTS.UNIT_AUTO;
+        asNumber = undefined;
+      } else if (value instanceof Value) {
+        unit = value.unit;
+        asNumber = value.valueOf();
+      } else {
+        unit =
+          typeof value === 'string' && value.endsWith('%')
+            ? CONSTANTS.UNIT_PERCENT
+            : CONSTANTS.UNIT_POINT;
+        asNumber = parseFloat(value);
+        if (!Number.isNaN(value) && Number.isNaN(asNumber)) {
+          throw new Error(`Invalid value ${value} for ${fnName}`);
+        }
+      }
+
+      if (!methods[unit])
+        throw new Error(
+          `Failed to execute "${fnName}": Unsupported unit '${value}'`,
+        );
+
+      if (asNumber !== undefined) {
+        return methods[unit].call(this, ...args, asNumber);
+      } else {
+        return methods[unit].call(this, ...args);
+      }
+    });
+  }
+
+  patch(lib.Config.prototype, 'free', function() {
+    // Since we handle the memory allocation ourselves (via lib.Config.create),
+    // we also need to handle the deallocation
+    lib.Config.destroy(this);
+  });
+
+  patch(lib.Node, 'create', function(_, config) {
+    // We decide the constructor we want to call depending on the parameters
+    return config
+      ? lib.Node.createWithConfig(config)
+      : lib.Node.createDefault();
+  });
+
+  patch(lib.Node.prototype, 'free', function() {
+    // Since we handle the memory allocation ourselves (via lib.Node.create),
+    // we also need to handle the deallocation
+    lib.Node.destroy(this);
+  });
+
+  patch(lib.Node.prototype, 'freeRecursive', function() {
+    for (let t = 0, T = this.getChildCount(); t < T; ++t) {
+      this.getChild(0).freeRecursive();
+    }
+    this.free();
+  });
+
+  patch(lib.Node.prototype, 'setMeasureFunc', function(original, measureFunc) {
+    // This patch is just a convenience patch, since it helps write more
+    // idiomatic source code (such as .setMeasureFunc(null))
+    // We also automatically convert the return value of the measureFunc
+    // to a Size object, so that we can return anything that has .width and
+    // .height properties
+    if (measureFunc) {
+      return original.call(this, (...args) =>
+        Size.fromJS(measureFunc(...args)),
+      );
+    } else {
+      return this.unsetMeasureFunc();
+    }
+  });
+
+  patch(lib.Node.prototype, 'calculateLayout', function(
+    original,
+    width = NaN,
+    height = NaN,
+    direction = CONSTANTS.DIRECTION_LTR,
+  ) {
+    // Just a small patch to add support for the function default parameters
+    return original.call(this, width, height, direction);
+  });
+
+  return {
+    Config: lib.Config,
+    Node: lib.Node,
+    Layout: bind('Layout', Layout),
+    Size: bind('Size', Size),
+    Value: bind('Value', Value),
+    getInstanceCount(...args) {
+      return lib.getInstanceCount(...args);
+    },
+    ...CONSTANTS,
+  };
+};

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@clary-so/measure",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "author": {
     "name": "Almouro",
     "email": "alexandrem@bam.tech"
   },
   "license": "MIT",
   "bin": {
-    "perf-profiler-measure": "dist/bin-bundled.js"
+    "perf-profiler-measure": "dist/server/bin.js"
   },
+  "bundledDependencies": [
+    "react",
+    "ink"
+  ],
   "dependencies": {
     "@clary-so/e2e": "^0.11.3",
     "@clary-so/logger": "^0.3.3",
@@ -20,7 +24,7 @@
     "cors": "^2.8.5",
     "express": "^4.19.2",
     "ink": "^3.2.0",
-    "react": "^18.0.0",
+    "react": "18.3.1",
     "socket.io": "^4.7.5"
   },
   "devDependencies": {
@@ -38,7 +42,7 @@
     "supertest": "^6.3.4"
   },
   "scripts": {
-    "build": "yarn parcel build src/webapp/index.html && node esbuild-bin.mjs",
+    "build": "yarn parcel build src/webapp/index.html",
     "start": "yarn parcel src/webapp/index.html"
   },
   "publishConfig": {