fix(vector): cleanup jsdocs

src/degree.js

@@ -64,26 +64,16 @@ export class IDegree extends ADegree {
 const ZERO = new IDegree(0);
 
 /**
- * @typedef {(angle: number) => DegreeType} DegreeNum
- * @typedef {(angle: Degree | IDegree) => DegreeType} DegreeDeg
- * @typedef {DegreeNum & DegreeDeg}
- *
  * @param {number | Degree | IDegree} angle
  * @returns {DegreeType}
- * @hidden
  */
 export function degree(angle) {
   return new Degree(angle);
 }
 
 /**
- * @typedef {(angle: number) => IDegreeType} IDegreeNum
- * @typedef {(angle: Degree | IDegree) => IDegreeType} IDegreeDeg
- * @typedef {IDegreeNum & IDegreeDeg}
- *
  * @param {number | Degree | IDegree} angle
  * @returns {IDegreeType}
- * @hidden
  */
 export function idegree(angle) {
   if (angle instanceof IDegree) {
@@ -98,17 +88,3 @@ export function idegree(angle) {
 export function isAngle(angle) {
   return typeof angle === 'number' || angle instanceof ADegree;
 }
-
-export const Export = {
-  /**
-   * @param {number | Degree | IDegree} [angle]
-   * @returns {IDegreeType}
-   */
-  idegree: angle => idegree(angle),
-
-  /**
-   * @param {number | Degree | IDegree} [angle]
-   * @returns {DegreeType}
-   */
-  degree: angle => degree(angle),
-};

src/point.js

@@ -34,9 +34,8 @@ function square(val) {
  */
 class APoint {
   /**
-   * @param {number | [number, number, number] | Alg} [x]
+   * @param {number | [number, number] | {x: number, y: number} | Alg} [x]
    * @param {number} [y]
-   * @hidden
    */
   constructor(x, y) {
     if (typeof x === 'function') {
@@ -45,6 +44,8 @@ class APoint {
       });
     } else if (isArray(x)) {
       this[AXES] = [...x];
+    } else if (x && typeof x.x === 'number') {
+      this[AXES] = [x.x || 0, x.y || 0];
     } else {
       this[AXES] = [x || 0, y || 0];
     }
@@ -333,7 +334,6 @@ export class IPoint extends APoint {
 /**
  * @param {Alg} alg
  * @return {PointType | IPointType}
- * @hidden
  */
 export function calc(alg) {
   return operatorCalc(alg);
@@ -343,30 +343,37 @@ const pointFactory = cachedFactory(Point);
 
 /**
  * @template P
- * @typedef {() => P} Zero
+ * @typedef {() => P} PZero
  */
 /**
  * @template P
- * @typedef {(alg: Alg) => P} Algh
+ * @typedef {(alg: Alg) => P} PAlg
  */
 /**
  * @template P
- * @typedef {(x: number, y: number) => P} Con
+ * @typedef {(x: number, y: number) => P} PCon
  */
 /**
  * @template P
- * @typedef {(data: [number, number]) => P} Arr
+ * @typedef {(data: [number, number]) => P} PArr
+ */
+/**
+ * @template P
+ * @typedef {(vec: { x: number, y: number }) => P} PObj
+ */
+/**
+ * @template P
+ * @typedef {PZero<Vec> & PAlg<Vec> & PCon<Vec> & PArr<Vec> & PObj<Vec} P
  */
-
 /**
- * @type {Zero<PointType> & Algh<PointType> & Con<PointType> & Arr<PointType>}
+ * @type {P<PointType>}
  */
 export const point = (...args) => pointFactory(...args);
 
 const ipointFactory = cachedFactory(IPoint);
 
 /**
- * @type {Zero<IPointType> & Algh<IPointType> & Con<IPointType> & Arr<IPointType>}
+ * @type {P<IPointType>}
  */
 export const ipoint = (x, y) => ipointFactory(x, y);
 

src/quaternion.js

@@ -399,13 +399,7 @@ const quaternionFactory = cachedFactory(Quaternion);
  * @typedef {(dir: VectorType, up: VectorType) => Quaternion} QuatDirUp
  * @typedef {(axis: VectorType, angle: DegreeType) => Quaternion} QuatAxis
  * @typedef {(arr: [number, number, number, number]) => Quaternion} QuatArr
- * @typedef {QuatNumber & QuatDir & QuatDirUp & QuatAxis & QuatArr & QuatZero}
- *
- * @param {number | VectorType | [number, number, number, number]} [x]
- * @param {number | VectorType} [y]
- * @param {number} [z]
- * @param {number} [w]
- * @hidden
+ * @type {QuatNumber & QuatDir & QuatDirUp & QuatAxis & QuatArr & QuatZero}
  */
 export const quaternion = function (x, y, z, w) {
   return quaternionFactory(x, y, z, w);
@@ -420,17 +414,9 @@ const iquaternionFactory = cachedFactory(IQuaternion);
  * @typedef {(dir: VectorType, up: VectorType) => IQuaternion} IQuatDirUp
  * @typedef {(axis: VectorType, angle: DegreeType) => IQuaternion} IQuatAxis
  * @typedef {(arr: [number, number, number, number]) => IQuaternion} IQuatArr
- * @typedef {IQuatNumber & IQuatDir & IQuatDirUp & IQuatAxis & IQuatArr & IQuatZero}
- *
- * @param {number | VectorType | [number, number, number, number]} [x]
- * @param {number | VectorType} [y]
- * @param {number} [z]
- * @param {number} [w]
- * @hidden
+ * @type {IQuatNumber & IQuatDir & IQuatDirUp & IQuatAxis & IQuatArr & IQuatZero}
  */
-export const iquaternion = function (x, y, z, w) {
-  return iquaternionFactory(x, y, z, w);
-};
+export const iquaternion = (...args) => iquaternionFactory(...args);
 
 const LEFT90 = new IQuaternion(LEFT, degree(90));
 
@@ -452,67 +438,4 @@ export function fromOrientation({ alpha, beta, gamma }, orientation) {
   return rot;
 }
 
-export const Export = {
-
-  /**
-   * @type {QuatZero}
-   */
-  quaternion: () => quaternion(),
-
-  /**
-   * @type {QuatDir}
-   */
-  quaternion: (dir) => quaternion(dir),
-
-  /**
-   * @type {QuatDirUp}
-   */
-  quaternion: (dir, up) => quaternion(dir, up),
-
-  /**
-   * @type {QuatArr}
-   */
-  quaternion: (arr) => quaternion(arr),
-
-  /**
-   * @type {QuatAxis}
-   */
-  quaternion: (axis, angle) => quaternion(axis, angle),
-
-  /**
-   * @type {QuatNumber}
-   */
-  quaternion: (x, y, z, w) => quaternion(x, y, z, w),
-
-  /**
-   * @type {IQuatZero}
-   */
-  iquaternion: () => iquaternion(),
-
-  /**
-  * @type {IQuatDir}
-  */
-  iquaternion: (dir) => iquaternion(dir),
-
-  /**
-   * @type {IQuatDirUp}
-   */
-  iquaternion: (dir, up) => iquaternion(dir, up),
-
-  /**
-   * @type {IQuatArr}
-   */
-  iquaternion: (arr) => iquaternion(arr),
-
-  /**
-   * @type {IQuatAxis}
-   */
-  iquaternion: (axis, angle) => iquaternion(axis, angle),
-
-  /**
-   * @type {IQuatNumber}
-   */
-  iquaternion: (x, y, z, w) => iquaternion(x, y, z, w)
-};
-
 export const IDENTITY = iquaternion(0, 0, 0, 1);

src/vector.js

@@ -33,10 +33,9 @@ function square(val) {
  */
 class AVector {
   /**
-   * @param {number | [number, number, number] | Alg} [x]
+   * @param {number | [number, number, number] | {x: number, y: number, z: number}| Alg} [x]
    * @param {number} [y]
    * @param {number} [z]
-   * @hidden
    */
   constructor(x, y, z) {
     if (typeof x === 'function') {
@@ -45,6 +44,8 @@ class AVector {
       });
     } else if (isArray(x)) {
       this[AXES] = [...x];
+    } else if (x && typeof x.x === 'number') {
+      this[AXES] = [x.x || 0, x.y || 0, x.z || 0];
     } else {
       this[AXES] = [x || 0, y || 0, z || 0];
     }
@@ -480,7 +481,6 @@ export class Victor extends AVector {
 /**
  * @param {Alg} alg
  * @return {VectorType | VictorType}
- * @hidden
  */
 export function calc(alg) {
   return operatorCalc(alg);
@@ -490,30 +490,38 @@ const vectorFactory = cachedFactory(Vector);
 
 /**
  * @template Vec
- * @typedef {() => Vec} Zero
+ * @typedef {() => Vec} VecZero
  */
 /**
  * @template Vec
- * @typedef {(alg: Alg) => Vec} Algh
+ * @typedef {(alg: Alg) => Vec} VecAlg
  */
 /**
  * @template Vec
- * @typedef {(x: number, y: number, z: number) => Vec} Con
+ * @typedef {(x: number, y: number, z: number) => Vec} VecCon
  */
 /**
  * @template Vec
- * @typedef {(data: [number, number, number]) => Vec} Arr
+ * @typedef {(data: [number, number, number]) => Vec} VecArr
+ */
+/**
+ * @template Vec
+ * @typedef {(vec: { x: number, y: number, z: number }) => Vec} VecObj
+ */
+/**
+ * @template Vec
+ * @typedef {VecZero<Vec> & VecAlg<Vec> & VecCon<Vec> & VecArr<Vec> & VecObj<Vec} Vec
  */
 
 /**
- * @type {Zero<VectorType> & Algh<VectorType> & Con<VectorType> & Arr<VectorType>}
+ * @type {Vec<VectorType>}
  */
 export const vector = (...args) => vectorFactory(...args);
 
 const victorFactory = cachedFactory(Victor);
 
 /**
- * @type {Zero<VictorType> & Algh<VictorType> & Con<VictorType> & Arr<VictorType>}
+ * @type {Vec<VictorType>}
  */
 export const victor = (...args) => victorFactory(...args);