Geometry.jsm

// This file was autogenerated by some hot garbage in the `uniffi` crate.
// Trust me, you don't want to mess with it!

"use strict";

var EXPORTED_SYMBOLS = [];

// UniFFIRustCallResult.code values
const CALL_SUCCESS = 0;
const CALL_ERROR = 1;
const CALL_INTERNAL_ERROR = 2;

// Write/Read data to/from an ArrayBuffer
class ArrayBufferDataStream {
    constructor(arrayBuffer) {
      this.dataView = new DataView(arrayBuffer);
      this.pos = 0;
    }
  
    readFloat64() {
      let rv = this.dataView.getFloat64(this.pos);
      this.pos += 8;
      return rv;
    }
  
    writeFloat64(value) {
      this.dataView.setFloat64(this.pos, value);
      this.pos += 8;
    }
  
    readUint8() {
      let rv = this.dataView.getUint8(this.pos);
      this.pos += 1;
      return rv;
    }
  
  
    // TODO: write more methods
  }


  function handleRustResult(result, liftCallback, liftErrCallback) {
    switch (result.code) {
      case CALL_SUCCESS:
        return liftCallback(result.data);

      case CALL_ERROR:
        throw liftErrCallback(result.data);

      case CALL_INTERNAL_ERROR:
        let message = result.internalErrorMessage;
        if (message) {
          throw new UniFFIInternalError(message);
        } else {
          throw new UniFFIInternalError("Unknown error");
        }

      default:
        throw new UniFFIError(`Unexpected status code: ${result.code}`);
    }
  }

  class UniFFIError {
    constructor(message) {
      this.message = message;
    }
  }
  class UniFFIInternalError extends UniFFIError {}

class FfiConverterDouble {
    static lift(value) {
        return value;
    }
    static lower(value) {
        return value;
    }
    static computeSize() {
        return 8;
    }
    static write(dataStream, double) {
        dataStream.writeFloat64(double)
    }

    static read(dataStream) {
        return dataStream.readFloat64()
    }
}




class Point {
    constructor(coordX,coordY) {
        this.coordX = coordX;
        this.coordY = coordY;
    }
}

class FfiConverterPoint {
    static lift(buf) {
        return this.read(new ArrayBufferDataStream(buf));
    }
    static lower(value) {
        const buf = new ArrayBuffer(this.computeSize());
        const dataStream = new ArrayBufferDataStream(buf);
        this.write(dataStream, value);
        return buf;
    }
    static read(dataStream) {
        return new Point(
            FfiConverterDouble.read(dataStream), 
            FfiConverterDouble.read(dataStream) 
        );
    }
    static write(dataStream, value) {
        FfiConverterDouble.write(dataStream, value.coordX);
        FfiConverterDouble.write(dataStream, value.coordY);
    }

    static computeSize() {
        let totalSize = 0;
        totalSize += FfiConverterDouble.computeSize();
        totalSize += FfiConverterDouble.computeSize();
        return totalSize
    }
}

class FfiConverterOptionalPoint {
    static lift(buf) {
        return this.read(new ArrayBufferDataStream(buf));
    }

    static lower(value) {
        const buf = new ArrayBuffer(this.computeSize());
        const dataStream = new ArrayBufferDataStream(buf);
        this.write(dataStream, value);
        return buf;
    }

    static read(dataStream) {
        const code = dataStream.readUint8(0);
        switch (code) {
            case 0:
                return null
            case 1:
                return FfiConverterPoint.read(dataStream);
            default:
                throw UniFFIError(`Unexpected code: ${code}`);
        }
    }

    static write(dataStream, value) {
        if (!value) {
            dataStream.writeUint8(0);
            return buf;
        }
        dataStream.writeUint8(1);
        FfiConverterPoint.write(dataStream, value);
        return buf;
    }

    static computeSize() {
        return 1 + FfiConverterPoint.computeSize();
    }
}

EXPORTED_SYMBOLS.push("Point");

class Line {
    constructor(start,end) {
        this.start = start;
        this.end = end;
    }
}

class FfiConverterLine {
    static lift(buf) {
        return this.read(new ArrayBufferDataStream(buf));
    }
    static lower(value) {
        const buf = new ArrayBuffer(this.computeSize());
        const dataStream = new ArrayBufferDataStream(buf);
        this.write(dataStream, value);
        return buf;
    }
    static read(dataStream) {
        return new Line(
            FfiConverterPoint.read(dataStream), 
            FfiConverterPoint.read(dataStream) 
        );
    }
    static write(dataStream, value) {
        FfiConverterPoint.write(dataStream, value.start);
        FfiConverterPoint.write(dataStream, value.end);
    }

    static computeSize() {
        let totalSize = 0;
        totalSize += FfiConverterPoint.computeSize();
        totalSize += FfiConverterPoint.computeSize();
        return totalSize
    }
}

class FfiConverterOptionalLine {
    static lift(buf) {
        return this.read(new ArrayBufferDataStream(buf));
    }

    static lower(value) {
        const buf = new ArrayBuffer(this.computeSize());
        const dataStream = new ArrayBufferDataStream(buf);
        this.write(dataStream, value);
        return buf;
    }

    static read(dataStream) {
        const code = dataStream.readUint8(0);
        switch (code) {
            case 0:
                return null
            case 1:
                return FfiConverterLine.read(dataStream);
            default:
                throw UniFFIError(`Unexpected code: ${code}`);
        }
    }

    static write(dataStream, value) {
        if (!value) {
            dataStream.writeUint8(0);
            return buf;
        }
        dataStream.writeUint8(1);
        FfiConverterLine.write(dataStream, value);
        return buf;
    }

    static computeSize() {
        return 1 + FfiConverterLine.computeSize();
    }
}

EXPORTED_SYMBOLS.push("Line");


function gradient(ln) {
    const liftResult = (result) => FfiConverterDouble.lift(result)
    const liftError = null; // TODO
    const callResult = GeometryScaffolding.geometryEb69Gradient(FfiConverterLine.lower(ln),
    )
    return callResult.then((result) => handleRustResult(result,  liftResult, liftError));
}

EXPORTED_SYMBOLS.push("gradient");
function intersection(ln1,ln2) {
    const liftResult = (result) => FfiConverterOptionalPoint.lift(result)
    const liftError = null; // TODO
    const callResult = GeometryScaffolding.geometryEb69Intersection(FfiConverterLine.lower(ln1),FfiConverterLine.lower(ln2),
    )
    return callResult.then((result) => handleRustResult(result,  liftResult, liftError));
}

EXPORTED_SYMBOLS.push("intersection");