@holoscript/std 3.1.1 → 6.0.3

package/dist/math.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Math utilities for HoloScript
+ *
+ * Vector math, quaternion operations, interpolation, and noise functions.
+ */
+import type { Vec2, Vec3, Quat, EulerAngles, AABB } from './types.js';
+export declare const PI: number;
+export declare const TAU: number;
+export declare const HALF_PI: number;
+export declare const DEG_TO_RAD: number;
+export declare const RAD_TO_DEG: number;
+export declare const EPSILON = 0.000001;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function inverseLerp(a: number, b: number, value: number): number;
+export declare function remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+export declare function smoothstep(edge0: number, edge1: number, x: number): number;
+export declare function smootherstep(edge0: number, edge1: number, x: number): number;
+export declare function degToRad(degrees: number): number;
+export declare function radToDeg(radians: number): number;
+export declare function mod(n: number, m: number): number;
+export declare function fract(x: number): number;
+export declare function sign(x: number): number;
+export declare function step(edge: number, x: number): number;
+export declare const vec2Math: {
+    add: (a: Vec2, b: Vec2) => Vec2;
+    sub: (a: Vec2, b: Vec2) => Vec2;
+    mul: (a: Vec2, s: number) => Vec2;
+    div: (a: Vec2, s: number) => Vec2;
+    dot: (a: Vec2, b: Vec2) => number;
+    length: (v: Vec2) => number;
+    lengthSq: (v: Vec2) => number;
+    normalize: (v: Vec2) => Vec2;
+    distance: (a: Vec2, b: Vec2) => number;
+    lerp: (a: Vec2, b: Vec2, t: number) => Vec2;
+    rotate: (v: Vec2, angle: number) => Vec2;
+    angle: (v: Vec2) => number;
+    angleBetween: (a: Vec2, b: Vec2) => number;
+};
+export declare const vec3Math: {
+    zero: () => Vec3;
+    one: () => Vec3;
+    up: () => Vec3;
+    down: () => Vec3;
+    forward: () => Vec3;
+    back: () => Vec3;
+    left: () => Vec3;
+    right: () => Vec3;
+    add: (a: Vec3, b: Vec3) => Vec3;
+    sub: (a: Vec3, b: Vec3) => Vec3;
+    mul: (a: Vec3, s: number) => Vec3;
+    div: (a: Vec3, s: number) => Vec3;
+    mulVec: (a: Vec3, b: Vec3) => Vec3;
+    dot: (a: Vec3, b: Vec3) => number;
+    cross: (a: Vec3, b: Vec3) => Vec3;
+    length: (v: Vec3) => number;
+    lengthSq: (v: Vec3) => number;
+    normalize: (v: Vec3) => Vec3;
+    distance: (a: Vec3, b: Vec3) => number;
+    distanceSq: (a: Vec3, b: Vec3) => number;
+    lerp: (a: Vec3, b: Vec3, t: number) => Vec3;
+    slerp: (a: Vec3, b: Vec3, t: number) => Vec3;
+    negate: (v: Vec3) => Vec3;
+    abs: (v: Vec3) => Vec3;
+    min: (a: Vec3, b: Vec3) => Vec3;
+    max: (a: Vec3, b: Vec3) => Vec3;
+    clamp: (v: Vec3, min: Vec3, max: Vec3) => Vec3;
+    floor: (v: Vec3) => Vec3;
+    ceil: (v: Vec3) => Vec3;
+    round: (v: Vec3) => Vec3;
+    reflect: (v: Vec3, normal: Vec3) => Vec3;
+    project: (v: Vec3, onto: Vec3) => Vec3;
+    angle: (a: Vec3, b: Vec3) => number;
+    equals: (a: Vec3, b: Vec3, epsilon?: number) => boolean;
+};
+export declare const quatMath: {
+    identity: () => Quat;
+    fromAxisAngle: (axis: Vec3, angle: number) => Quat;
+    fromEuler: (euler: EulerAngles) => Quat;
+    toEuler: (q: Quat) => EulerAngles;
+    multiply: (a: Quat, b: Quat) => Quat;
+    conjugate: (q: Quat) => Quat;
+    inverse: (q: Quat) => Quat;
+    normalize: (q: Quat) => Quat;
+    dot: (a: Quat, b: Quat) => number;
+    slerp: (a: Quat, b: Quat, t: number) => Quat;
+    rotateVec3: (q: Quat, v: Vec3) => Vec3;
+    lookAt: (forward: Vec3, up?: Vec3) => Quat;
+};
+export declare const aabbMath: {
+    contains: (aabb: AABB, point: Vec3) => boolean;
+    intersects: (a: AABB, b: AABB) => boolean;
+    center: (aabb: AABB) => Vec3;
+    size: (aabb: AABB) => Vec3;
+    expand: (aabb: AABB, point: Vec3) => AABB;
+    merge: (a: AABB, b: AABB) => AABB;
+};
+export declare const noise: {
+    /**
+     * 3D Perlin noise (-1 to 1)
+     */
+    perlin3d: (x: number, y: number, z: number) => number;
+    /**
+     * 2D Perlin noise (-1 to 1)
+     */
+    perlin2d: (x: number, y: number) => number;
+    /**
+     * Fractal Brownian Motion (fBm)
+     */
+    fbm: (x: number, y: number, z: number, octaves?: number, lacunarity?: number, gain?: number) => number;
+    /**
+     * Simplex-like noise (approximation using perlin)
+     */
+    simplex: (x: number, y: number) => number;
+    /**
+     * Worley/Cellular noise
+     */
+    worley: (x: number, y: number, z: number) => number;
+};
+export declare const random: {
+    /**
+     * Random float between 0 and 1
+     */
+    float: () => number;
+    /**
+     * Random float in range [min, max)
+     */
+    range: (min: number, max: number) => number;
+    /**
+     * Random integer in range [min, max]
+     */
+    int: (min: number, max: number) => number;
+    /**
+     * Random boolean with probability
+     */
+    bool: (probability?: number) => boolean;
+    /**
+     * Random element from array
+     */
+    pick: <T>(array: T[]) => T;
+    /**
+     * Shuffle array (Fisher-Yates)
+     */
+    shuffle: <T>(array: T[]) => T[];
+    /**
+     * Random Vec3 in unit sphere
+     */
+    insideUnitSphere: () => Vec3;
+    /**
+     * Random Vec3 on unit sphere surface
+     */
+    onUnitSphere: () => Vec3;
+    /**
+     * Random Vec2 in unit circle
+     */
+    insideUnitCircle: () => Vec2;
+    /**
+     * Seeded random number generator
+     */
+    seeded: (seed: number) => () => number;
+};
+//# sourceMappingURL=math.d.ts.map

package/dist/math.js

@@ -0,0 +1,53 @@
+import {
+  DEG_TO_RAD,
+  EPSILON,
+  HALF_PI,
+  PI,
+  RAD_TO_DEG,
+  TAU,
+  aabbMath,
+  clamp,
+  degToRad,
+  fract,
+  inverseLerp,
+  lerp,
+  mod,
+  noise,
+  quatMath,
+  radToDeg,
+  random,
+  remap,
+  sign,
+  smootherstep,
+  smoothstep,
+  step,
+  vec2Math,
+  vec3Math
+} from "./chunk-7HVUYGPS.js";
+export {
+  DEG_TO_RAD,
+  EPSILON,
+  HALF_PI,
+  PI,
+  RAD_TO_DEG,
+  TAU,
+  aabbMath,
+  clamp,
+  degToRad,
+  fract,
+  inverseLerp,
+  lerp,
+  mod,
+  noise,
+  quatMath,
+  radToDeg,
+  random,
+  remap,
+  sign,
+  smootherstep,
+  smoothstep,
+  step,
+  vec2Math,
+  vec3Math
+};
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/physics.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @holoscript/std — Physics Module
+ *
+ * Provides physics primitives: ColliderShape, RigidbodyConfig, ForceField, Joint.
+ * Runtime representations for HoloScript physics blocks.
+ *
+ * @version 0.2.0
+ * @module @holoscript/std/physics
+ */
+import type { Vec3 } from './spatial.js';
+export type ColliderShapeType = 'box' | 'sphere' | 'capsule' | 'mesh' | 'convex' | 'cylinder' | 'heightfield';
+export interface ColliderConfig {
+    shape: ColliderShapeType;
+    isTrigger: boolean;
+    friction: number;
+    restitution: number;
+    radius?: number;
+    halfExtents?: Vec3;
+    height?: number;
+    meshAsset?: string;
+}
+export declare function createBoxCollider(halfExtents: Vec3, options?: Partial<ColliderConfig>): ColliderConfig;
+export declare function createSphereCollider(radius: number, options?: Partial<ColliderConfig>): ColliderConfig;
+export declare function createCapsuleCollider(radius: number, height: number, options?: Partial<ColliderConfig>): ColliderConfig;
+export interface RigidbodyConfig {
+    mass: number;
+    useGravity: boolean;
+    linearDamping: number;
+    angularDamping: number;
+    freezePosition: [boolean, boolean, boolean];
+    freezeRotation: [boolean, boolean, boolean];
+    isKinematic: boolean;
+}
+export declare function createRigidbody(mass: number, options?: Partial<RigidbodyConfig>): RigidbodyConfig;
+export type ForceFieldType = 'directional' | 'radial' | 'vortex' | 'buoyancy';
+export interface ForceFieldConfig {
+    type: ForceFieldType;
+    strength: number;
+    direction?: Vec3;
+    falloff: 'none' | 'linear' | 'quadratic';
+    turbulence: number;
+}
+export type JointType = 'hinge' | 'slider' | 'ball_socket' | 'fixed' | 'd6' | 'spring';
+export interface JointConfig {
+    type: JointType;
+    connectedBody?: string;
+    axis?: Vec3;
+    limits?: [number, number];
+    damping: number;
+    springForce?: number;
+    breakForce?: number;
+}
+export interface RaycastHit {
+    point: Vec3;
+    normal: Vec3;
+    distance: number;
+    objectName: string;
+}
+//# sourceMappingURL=physics.d.ts.map

package/dist/spatial.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @holoscript/std — Spatial Module
+ *
+ * Provides spatial math utilities: Vec3, Quaternion, Transform, Ray, AABB, distance.
+ * Used by the HoloScript runtime for spatial computing operations.
+ *
+ * @version 0.2.0
+ * @module @holoscript/std/spatial
+ */
+export declare class Vec3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    static zero(): Vec3;
+    static one(): Vec3;
+    static up(): Vec3;
+    static down(): Vec3;
+    static forward(): Vec3;
+    static right(): Vec3;
+    add(other: Vec3): Vec3;
+    sub(other: Vec3): Vec3;
+    mul(s: number): Vec3;
+    div(s: number): Vec3;
+    dot(other: Vec3): number;
+    cross(other: Vec3): Vec3;
+    length(): number;
+    lengthSquared(): number;
+    normalize(): Vec3;
+    distanceTo(other: Vec3): number;
+    lerp(other: Vec3, t: number): Vec3;
+    toArray(): [number, number, number];
+    static fromArray(arr: number[]): Vec3;
+    equals(other: Vec3, epsilon?: number): boolean;
+    toString(): string;
+}
+export declare class Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    static identity(): Quaternion;
+    static fromEuler(x: number, y: number, z: number): Quaternion;
+    static fromAxisAngle(axis: Vec3, angle: number): Quaternion;
+    multiply(other: Quaternion): Quaternion;
+    rotateVec3(v: Vec3): Vec3;
+    slerp(other: Quaternion, t: number): Quaternion;
+    normalize(): Quaternion;
+    toEuler(): Vec3;
+}
+export declare class Transform {
+    position: Vec3;
+    rotation: Quaternion;
+    scale: Vec3;
+    constructor(position?: Vec3, rotation?: Quaternion, scale?: Vec3);
+    static identity(): Transform;
+    transformPoint(point: Vec3): Vec3;
+    transformDirection(dir: Vec3): Vec3;
+}
+export declare class Ray {
+    origin: Vec3;
+    direction: Vec3;
+    constructor(origin: Vec3, direction: Vec3);
+    pointAt(t: number): Vec3;
+}
+export declare class AABB {
+    min: Vec3;
+    max: Vec3;
+    constructor(min: Vec3, max: Vec3);
+    contains(point: Vec3): boolean;
+    intersects(other: AABB): boolean;
+    center(): Vec3;
+    size(): Vec3;
+    intersectsRay(ray: Ray): number | null;
+}
+export declare function distance(a: Vec3, b: Vec3): number;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function clamp(v: number, min: number, max: number): number;
+export declare function degToRad(deg: number): number;
+export declare function radToDeg(rad: number): number;
+//# sourceMappingURL=spatial.d.ts.map

package/dist/string.basic.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Basic test to verify formatBytes function
+ */
+export {};
+//# sourceMappingURL=string.basic.test.d.ts.map

package/dist/string.basic.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.basic.test.d.ts","sourceRoot":"","sources":["../src/string.basic.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}