@block_factory/lib 0.0.1

package/esbuild.config.mjs

@@ -0,0 +1,18 @@
+import esbuild from "esbuild";
+/** @type { esbuild.BuildOptions } */
+const options = {
+    format: "esm",
+    bundle: true,
+    target: [ "es2021" ],
+    platform: "neutral",
+    entryPoints: [ "index.ts" ],
+    outfile: "index.js",
+    sourcemap: false,
+    external: [
+        "@minecraft/server",
+        "@minecraft/server-ui",
+    ],
+    logLevel: "info"
+};
+
+esbuild.build(options);

package/index.d.ts

@@ -0,0 +1,16 @@
+import { MathUtils } from "./util/Math";
+import { Signal } from "./util/Signal";
+import { Vec2, Vec3 } from "./util/Vector";
+import { RawText } from "./util/RawText";
+import { Command } from "./util/Command";
+
+export { MathUtils, Signal, Vec2, Vec3, RawText, Command }
+
+export declare const BlockFactory: {
+    MathUtils: typeof MathUtils;
+    Signal: typeof Signal;
+    Vec2: typeof Vec2;
+    Vec3: typeof Vec3;
+    RawText: typeof RawText;
+    Command: typeof Command;
+};

package/index.js

@@ -0,0 +1,526 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// util/Math.ts
+var MathUtils;
+((MathUtils2) => {
+  function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+  }
+  MathUtils2.clamp = clamp;
+  ;
+  function lerp(start, end, factor) {
+    return start + (end - start) * clamp(factor, 0, 1);
+  }
+  MathUtils2.lerp = lerp;
+  ;
+  function toRadians(degrees) {
+    return degrees * (Math.PI / 180);
+  }
+  MathUtils2.toRadians = toRadians;
+  ;
+  function toDegrees(radians) {
+    return radians * (180 / Math.PI);
+  }
+  MathUtils2.toDegrees = toDegrees;
+  ;
+  function fromRotation(rotation) {
+    const rotationH = toRadians(rotation.y * -1);
+    const z0 = Math.cos(rotationH);
+    const x0 = Math.sin(rotationH);
+    const rotationV = toRadians(rotation.x * -1);
+    const h = Math.cos(rotationV);
+    const v = Math.sin(rotationV);
+    return {
+      x: h * x0,
+      y: v,
+      z: h * z0
+    };
+  }
+  MathUtils2.fromRotation = fromRotation;
+  ;
+  function rotateOffset(offset, yawDegrees) {
+    const yaw = -yawDegrees * Math.PI / 180;
+    const cos = Math.cos(yaw);
+    const sin = Math.sin(yaw);
+    return {
+      x: offset.x * cos - offset.z * sin,
+      y: offset.y,
+      z: offset.x * sin + offset.z * cos
+    };
+  }
+  MathUtils2.rotateOffset = rotateOffset;
+  ;
+  function distance3D(pointA, pointB) {
+    const dx = pointB.x - pointA.x;
+    const dy = pointB.y - pointA.y;
+    const dz = pointB.z - pointA.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  MathUtils2.distance3D = distance3D;
+  ;
+  function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+  MathUtils2.randomInt = randomInt;
+  ;
+  function randomFloat(min, max) {
+    return Math.random() * (max - min) + min;
+  }
+  MathUtils2.randomFloat = randomFloat;
+  ;
+})(MathUtils || (MathUtils = {}));
+
+// util/Signal.ts
+var Signal = class {
+  constructor() {
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+  }
+  /** Connect a listener */
+  connect(callback) {
+    this.listeners.add(callback);
+  }
+  /** Disconnect a listener */
+  disconnect(callback) {
+    if (callback) {
+      this.listeners.delete(callback);
+      return true;
+    } else {
+      this.listeners.clear();
+      return false;
+    }
+  }
+  /** Connect a listener that runs only once */
+  once(callback) {
+    const wrapper = (data) => {
+      this.disconnect(wrapper);
+      callback(data);
+    };
+    this.connect(wrapper);
+  }
+  /** Emit signal to all listeners */
+  emit(data) {
+    for (const cb of [...this.listeners]) {
+      cb(data);
+    }
+  }
+};
+
+// util/Vector.ts
+var _Vec2 = class _Vec2 {
+  /**
+   * Creates a new Vec2.
+   * @param x X component
+   * @param y Y component
+   */
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  /**
+   * Adds a vector or scalar to a vector.
+   * @param a Base vector
+   * @param b Vector or scalar to add
+   */
+  static add(a, b) {
+    if (typeof b === "number") return new _Vec2(a.x + b, a.y + b);
+    else return new _Vec2(a.x + b.x, a.y + b.y);
+  }
+  /**
+   * Subtracts a vector or scalar from a vector.
+   * @param a Base vector
+   * @param b Vector or scalar to subtract
+   */
+  static subtract(a, b) {
+    if (typeof b === "number") return new _Vec2(a.x - b, a.y - b);
+    else return new _Vec2(a.x - b.x, a.y - b.y);
+  }
+  /**
+   * Multiplies a vector by another vector (component-wise) or scalar.
+   */
+  static multiply(a, b) {
+    if (typeof b === "number") return new _Vec2(a.x * b, a.y * b);
+    else return new _Vec2(a.x * b.x, a.y * b.y);
+  }
+  /**
+   * Divides a vector by another vector (component-wise) or scalar.
+   */
+  static divide(a, b) {
+    if (typeof b === "number") return new _Vec2(a.x / b, a.y / b);
+    else return new _Vec2(a.x / b.x, a.y / b.y);
+  }
+  /**
+   * Linearly interpolates between two vectors.
+   * @param t Interpolation factor (0–1)
+   */
+  static lerp(a, b, t) {
+    return new _Vec2(
+      a.x + (b.x - a.x) * t,
+      a.y + (b.y - a.y) * t
+    );
+  }
+  /**
+   * Clamps a vector between a minimum and maximum vector.
+   */
+  static clamp(v, min, max) {
+    return new _Vec2(
+      Math.min(Math.max(v.x, min.x), max.x),
+      Math.min(Math.max(v.y, min.y), max.y)
+    );
+  }
+  /**
+   * Dot product of two vectors.
+   */
+  static dot(a, b) {
+    return a.x * b.x + a.y * b.y;
+  }
+  /**
+   * Length (magnitude) of a vector.
+   */
+  static magnitude(a) {
+    return Math.sqrt(a.x * a.x + a.y * a.y);
+  }
+  /**
+   * Returns a normalized (unit length) vector.
+   * If magnitude is zero, returns (0, 0).
+   */
+  static normalize(a) {
+    const mag = _Vec2.magnitude(a);
+    return mag === 0 ? new _Vec2(0, 0) : new _Vec2(a.x / mag, a.y / mag);
+  }
+  /**
+   * Distance between two vectors.
+   */
+  static distance(a, b) {
+    return _Vec2.magnitude(_Vec2.subtract(a, b));
+  }
+  /**
+   * Returns the negated vector.
+   */
+  static negate(a) {
+    return new _Vec2(-a.x, -a.y);
+  }
+  /**
+   * Checks exact equality between two vectors.
+   */
+  static equals(a, b) {
+    return a.x === b.x && a.y === b.y;
+  }
+  /**
+   * Checks approximate equality between two vectors.
+   * @param epsilon Allowed difference threshold
+   */
+  static approxEquals(a, b, epsilon = 1e-4) {
+    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon;
+  }
+  /**
+   * Returns the angle (in radians) between two vectors.
+   * Returns 0 if either vector has zero length.
+   */
+  static angle(a, b) {
+    const magA = _Vec2.magnitude(a);
+    const magB = _Vec2.magnitude(b);
+    const denom = magA * magB;
+    if (denom === 0) return 0;
+    let c = _Vec2.dot(a, b) / denom;
+    c = Math.max(-1, Math.min(1, c));
+    return Math.acos(c);
+  }
+  /**
+   * Returns a perpendicular vector (-y, x).
+   */
+  static perpendicular(a) {
+    return new _Vec2(-a.y, a.x);
+  }
+};
+/** Constant zero vector (0, 0) */
+__publicField(_Vec2, "ZERO", new _Vec2(0, 0));
+/** Up direction (0, 1) */
+__publicField(_Vec2, "UP", new _Vec2(0, 1));
+/** Down direction (0, -1) */
+__publicField(_Vec2, "DOWN", new _Vec2(0, -1));
+/** Left direction (-1, 0) */
+__publicField(_Vec2, "LEFT", new _Vec2(-1, 0));
+/** Right direction (1, 0) */
+__publicField(_Vec2, "RIGHT", new _Vec2(1, 0));
+var Vec2 = _Vec2;
+var _Vec3 = class _Vec3 {
+  /**
+   * Creates a new Vec3.
+   * @param x X component
+   * @param y Y component
+   * @param z Z component
+   */
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  /**
+   * Adds a vector or scalar to a vector.
+   * @param a Base vector
+   * @param b Vector or scalar to add
+   */
+  static add(a, b) {
+    if (typeof b === "number") return new _Vec3(a.x + b, a.y + b, a.z + b);
+    else return new _Vec3(a.x + b.x, a.y + b.y, a.z + b.z);
+  }
+  /**
+   * Subtracts a vector or scalar from a vector.
+   * @param a Base vector
+   * @param b Vector or scalar to subtract
+   */
+  static subtract(a, b) {
+    if (typeof b === "number") return new _Vec3(a.x - b, a.y - b, a.z - b);
+    else return new _Vec3(a.x - b.x, a.y - b.y, a.z - b.z);
+  }
+  /**
+   * Multiplies a vector by another vector (component-wise) or scalar.
+   */
+  static multiply(a, b) {
+    if (typeof b === "number") return new _Vec3(a.x * b, a.y * b, a.z * b);
+    else return new _Vec3(a.x * b.x, a.y * b.y, a.z * b.z);
+  }
+  /**
+   * Divides a vector by another vector (component-wise) or scalar.
+   */
+  static divide(a, b) {
+    if (typeof b === "number") return new _Vec3(a.x / b, a.y / b, a.z / b);
+    else return new _Vec3(a.x / b.x, a.y / b.y, a.z / b.z);
+  }
+  /**
+   * Linearly interpolates between two vectors.
+   * @param t Interpolation factor (0–1)
+   */
+  static lerp(a, b, t) {
+    return new _Vec3(
+      a.x + (b.x - a.x) * t,
+      a.y + (b.y - a.y) * t,
+      a.z + (b.z - a.z) * t
+    );
+  }
+  /**
+   * Clamps a vector between a minimum and maximum vector.
+   */
+  static clamp(v, min, max) {
+    return new _Vec3(
+      Math.min(Math.max(v.x, min.x), max.x),
+      Math.min(Math.max(v.y, min.y), max.y),
+      Math.min(Math.max(v.z, min.z), max.z)
+    );
+  }
+  /**
+   * Dot product of two vectors.
+   */
+  static dot(a, b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+  }
+  /**
+   * Cross product of two vectors.
+   * Returns a vector perpendicular to both inputs.
+   */
+  static cross(a, b) {
+    return new _Vec3(
+      a.y * b.z - a.z * b.y,
+      a.z * b.x - a.x * b.z,
+      a.x * b.y - a.y * b.x
+    );
+  }
+  /**
+   * Length (magnitude) of a vector.
+   */
+  static magnitude(a) {
+    return Math.sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
+  }
+  /**
+   * Returns a normalized (unit length) vector.
+   * If magnitude is zero, returns (0, 0, 0).
+   */
+  static normalize(a) {
+    const mag = _Vec3.magnitude(a);
+    return mag === 0 ? new _Vec3(0, 0, 0) : new _Vec3(a.x / mag, a.y / mag, a.z / mag);
+  }
+  /**
+   * Distance between two vectors.
+   */
+  static distance(a, b) {
+    return _Vec3.magnitude(_Vec3.subtract(a, b));
+  }
+  /**
+   * Returns the negated vector.
+   */
+  static negate(a) {
+    return new _Vec3(-a.x, -a.y, -a.z);
+  }
+  /**
+   * Checks exact equality between two vectors.
+   */
+  static equals(a, b) {
+    return a.x === b.x && a.y === b.y && a.z === b.z;
+  }
+  /**
+   * Checks approximate equality between two vectors.
+   * @param epsilon Allowed difference threshold
+   */
+  static approxEquals(a, b, epsilon = 1e-4) {
+    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon && Math.abs(a.z - b.z) < epsilon;
+  }
+  /**
+   * Returns the angle (in radians) between two vectors.
+   * Returns 0 if either vector has zero length.
+   */
+  static angle(a, b) {
+    const magA = _Vec3.magnitude(a);
+    const magB = _Vec3.magnitude(b);
+    const denom = magA * magB;
+    if (denom === 0) return 0;
+    let c = _Vec3.dot(a, b) / denom;
+    c = Math.max(-1, Math.min(1, c));
+    return Math.acos(c);
+  }
+  /**
+   * Projects vector `a` onto vector `onto`.
+   * If `onto` has zero length, returns (0, 0, 0).
+   */
+  static project(a, onto) {
+    const denom = _Vec3.dot(onto, onto);
+    if (denom === 0) return new _Vec3(0, 0, 0);
+    const scale = _Vec3.dot(a, onto) / denom;
+    return _Vec3.multiply(onto, scale);
+  }
+  /**
+   * Converts spherical coordinates to cartesian coordinates.
+   * @param radius Distance from origin
+   * @param theta Azimuth angle (radians)
+   * @param phi Polar angle (radians)
+   */
+  static cartesian(radius, theta, phi) {
+    return new _Vec3(
+      radius * Math.sin(phi) * Math.cos(theta),
+      radius * Math.sin(phi) * Math.sin(theta),
+      radius * Math.cos(phi)
+    );
+  }
+};
+/** Constant zero vector (0, 0, 0) */
+__publicField(_Vec3, "ZERO", new _Vec3(0, 0, 0));
+/** Up direction (0, 1, 0) */
+__publicField(_Vec3, "UP", new _Vec3(0, 1, 0));
+/** Down direction (0, -1, 0) */
+__publicField(_Vec3, "DOWN", new _Vec3(0, -1, 0));
+/** Left direction (-1, 0, 0) */
+__publicField(_Vec3, "LEFT", new _Vec3(-1, 0, 0));
+/** Right direction (1, 0, 0) */
+__publicField(_Vec3, "RIGHT", new _Vec3(1, 0, 0));
+/** Forward direction (0, 0, 1) */
+__publicField(_Vec3, "FORWARD", new _Vec3(0, 0, 1));
+/** Backward direction (0, 0, -1) */
+__publicField(_Vec3, "BACK", new _Vec3(0, 0, -1));
+/** West direction (-1, 0, 0) */
+__publicField(_Vec3, "WEST", new _Vec3(-1, 0, 0));
+/** East direction (1, 0, 0) */
+__publicField(_Vec3, "EAST", new _Vec3(1, 0, 0));
+/** North direction (0, 0, 1) */
+__publicField(_Vec3, "NORTH", new _Vec3(0, 0, 1));
+/** South direction (0, 0, -1) */
+__publicField(_Vec3, "SOUTH", new _Vec3(0, 0, -1));
+var Vec3 = _Vec3;
+
+// util/RawText.ts
+var RawText;
+((RawText2) => {
+  RawText2.TEXT = (value) => ({
+    text: value
+  });
+  RawText2.TRANSLATE = (key, ...params) => ({
+    translate: key,
+    with: params.length ? params : void 0
+  });
+  RawText2.SCORE = (name, objective) => ({
+    score: {
+      name,
+      objective
+    }
+  });
+  RawText2.MESSAGE = (...rawText) => ({
+    rawtext: rawText
+  });
+  RawText2.FORMAT = {
+    DarkRed: (0, RawText2.TEXT)("\xA74"),
+    Red: (0, RawText2.TEXT)("\xA7c"),
+    Gold: (0, RawText2.TEXT)("\xA76"),
+    Yellow: (0, RawText2.TEXT)("\xA7e"),
+    Green: (0, RawText2.TEXT)("\xA72"),
+    Lime: (0, RawText2.TEXT)("\xA7a"),
+    Aqua: (0, RawText2.TEXT)("\xA7b"),
+    Cyan: (0, RawText2.TEXT)("\xA73"),
+    DarkBlue: (0, RawText2.TEXT)("\xA71"),
+    Blue: (0, RawText2.TEXT)("\xA79"),
+    Magenta: (0, RawText2.TEXT)("\xA7d"),
+    Purple: (0, RawText2.TEXT)("\xA75"),
+    White: (0, RawText2.TEXT)("\xA7f"),
+    Gray: (0, RawText2.TEXT)("\xA77"),
+    DarkGray: (0, RawText2.TEXT)("\xA78"),
+    Black: (0, RawText2.TEXT)("\xA70"),
+    Obfuscated: (0, RawText2.TEXT)("\xA7k"),
+    Bold: (0, RawText2.TEXT)("\xA7l"),
+    StrikeThrough: (0, RawText2.TEXT)("\xA7m"),
+    Italic: (0, RawText2.TEXT)("\xA7o"),
+    Reset: (0, RawText2.TEXT)("\xA7r"),
+    NewLine: (0, RawText2.TEXT)("\n")
+  };
+})(RawText || (RawText = {}));
+
+// util/Command.ts
+import {
+  system
+} from "@minecraft/server";
+var Command;
+((Command2) => {
+  class ICustomCommand {
+    constructor() {
+      __publicField(this, "cheatsRequired");
+      __publicField(this, "mandatoryParameters");
+      __publicField(this, "optionalParameters");
+    }
+  }
+  Command2.ICustomCommand = ICustomCommand;
+  ;
+  Command2.customCommands = [];
+  function RegisterCustomCommand(customCommand) {
+    const instance = new customCommand();
+    Command2.customCommands.push(instance);
+  }
+  Command2.RegisterCustomCommand = RegisterCustomCommand;
+  ;
+})(Command || (Command = {}));
+system.beforeEvents.startup.subscribe(
+  (event) => {
+    const { customCommandRegistry } = event;
+    for (const command of Command.customCommands) {
+      customCommandRegistry.registerCommand(command, command.execute);
+    }
+    ;
+  }
+);
+
+// index.ts
+var BlockFactory;
+((BlockFactory2) => {
+  MathUtils;
+  Signal;
+  Vec2;
+  Vec3;
+  RawText;
+  Command;
+})(BlockFactory || (BlockFactory = {}));
+export {
+  BlockFactory,
+  Command,
+  MathUtils,
+  RawText,
+  Signal,
+  Vec2,
+  Vec3
+};

package/index.ts

@@ -0,0 +1,16 @@
+import { MathUtils } from "./util/Math";
+import { Signal } from "./util/Signal";
+import { Vec2, Vec3 } from "./util/Vector";
+import { RawText } from "./util/RawText";
+import { Command } from "./util/Command";
+
+export { MathUtils, Signal, Vec2, Vec3, RawText, Command }
+
+export namespace BlockFactory {
+    MathUtils;
+    Signal;
+    Vec2;
+    Vec3;
+    RawText;
+    Command;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@block_factory/lib",
+  "version": "0.0.1",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "description": "Typescript Library for Minecraft Bedrock Edition",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Block-Factory-Studio/bf-lib.git"
+  },
+  "author": "Block Factory x Donthedev",
+  "contributors": [
+    {
+      "name": "Donthedev",
+      "email": "donthedev@blockfactory.studio"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Block-Factory-Studio/bf-lib/issues"
+  },
+  "homepage": "https://github.com/Block-Factory-Studio/bf-lib#readme",
+  "dependencies": {
+    "@minecraft/server": "^2.4.0",
+    "@minecraft/server-ui": "^2.0.0",
+    "all": "^0.0.0",
+    "esbuild": "^0.27.2"
+  },
+  "scripts": {
+    "build": "node esbuild.config.mjs"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "outDir": ".",
+    "rootDir": ".",
+    "declaration": true,
+    "declarationMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "lib": [
+      "ES2020",
+      "DOM"
+    ],
+    "allowJs": false
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/util/Command.d.ts

@@ -0,0 +1,23 @@
+import type {
+    CustomCommand,
+    CommandPermissionLevel,
+    CustomCommandParameter,
+    CustomCommandOrigin,
+    CustomCommandResult
+} from "@minecraft/server";
+
+export declare namespace Command {
+    export abstract class ICustomCommand implements CustomCommand {
+        public abstract description: string;
+        public abstract name: string;
+        public abstract permissionLevel: CommandPermissionLevel;
+        public cheatsRequired?: boolean;
+        public mandatoryParameters?: CustomCommandParameter[];
+        public optionalParameters?: CustomCommandParameter[];
+        public abstract execute(origin: CustomCommandOrigin, ...args: any[]): CustomCommandResult | undefined;
+    }
+
+    export const customCommands: ICustomCommand[];
+
+    export function RegisterCustomCommand<T extends { new(): ICustomCommand }>(customCommand: T): void;
+}