@neaps/tide-predictor 0.0.3 → 0.1.1

package/{src/harmonics/__tests__ → test/harmonics}/prediction.js

@@ -1,6 +1,8 @@
-import harmonics from '../index'
-import mockHarmonicConstituents from '../../__mocks__/constituents'
-import mockSecondaryStation from '../../__mocks__/secondary-station'
+import assert from 'assert'
+import closeTo from '../lib/close-to.js'
+import harmonics from '../../src/harmonics/index.js'
+import mockHarmonicConstituents from '../_mocks/constituents.js'
+import mockSecondaryStation from '../_mocks/secondary-station.js'
 
 const startDate = new Date()
 startDate.setFullYear(2019)
@@ -40,15 +42,15 @@ const setUpPrediction = () => {
 }
 
 describe('harmonic prediction', () => {
-  test('it creates a timeline prediction', () => {
+  it('it creates a timeline prediction', () => {
     const testPrediction = setUpPrediction()
     const results = testPrediction.getTimelinePrediction()
     const lastResult = results.pop()
-    expect(results[0].level).toBeCloseTo(-1.347125, 3)
-    expect(lastResult.level).toBeCloseTo(2.85263589, 3)
+    closeTo(results[0].level, -1.347125, 3)
+    closeTo(lastResult.level, 2.85263589, 3)
   })
 
-  test('it creates a timeline prediction with a non-default phase key', () => {
+  it('it creates a timeline prediction with a non-default phase key', () => {
     const results = harmonics({
       harmonicConstituents: mockHarmonicConstituents,
       phaseKey: 'phase_local',
@@ -57,11 +59,11 @@ describe('harmonic prediction', () => {
       .setTimeSpan(startDate, endDate)
       .prediction()
       .getTimelinePrediction()
-    expect(results[0].level).toBeCloseTo(2.7560979, 3)
-    expect(results.pop().level).toBeCloseTo(-2.9170977, 3)
+    closeTo(results[0].level, 2.7560979, 3)
+    closeTo(results.pop().level, -2.9170977, 3)
   })
 
-  test('it finds high and low tides', () => {
+  it('it finds high and low tides', () => {
     const results = harmonics({
       harmonicConstituents: mockHarmonicConstituents,
       phaseKey: 'phase_GMT',
@@ -70,7 +72,7 @@ describe('harmonic prediction', () => {
       .setTimeSpan(startDate, extremesEndDate)
       .prediction()
       .getExtremesPrediction()
-    expect(results[0].level).toBeCloseTo(-1.5650332, 4)
+    closeTo(results[0].level, -1.5650332, 4)
 
     const customLabels = {
       high: 'Super high',
@@ -85,10 +87,10 @@ describe('harmonic prediction', () => {
       .setTimeSpan(startDate, extremesEndDate)
       .prediction()
       .getExtremesPrediction({ labels: customLabels })
-    expect(labelResults[0].label).toBe(customLabels.low)
+    assert.ok(labelResults[0].label === customLabels.low)
   })
 
-  test('it finds high and low tides with high fidelity', () => {
+  it('it finds high and low tides with high fidelity', () => {
     const results = harmonics({
       harmonicConstituents: mockHarmonicConstituents,
       phaseKey: 'phase_GMT',
@@ -97,12 +99,12 @@ describe('harmonic prediction', () => {
       .setTimeSpan(startDate, extremesEndDate)
       .prediction({ timeFidelity: 60 })
       .getExtremesPrediction()
-    expect(results[0].level).toBeCloseTo(-1.5653894, 4)
+    closeTo(results[0].level, -1.5653894, 4)
   })
 })
 
 describe('Secondary stations', () => {
-  test('it can add offsets to secondary stations', () => {
+  it('it can add offsets to secondary stations', () => {
     const regularResults = harmonics({
       harmonicConstituents: mockHarmonicConstituents,
       phaseKey: 'phase_GMT',
@@ -123,24 +125,28 @@ describe('Secondary stations', () => {
 
     offsetResults.forEach((offsetResult, index) => {
       if (offsetResult.low) {
-        expect(offsetResult.level).toBeCloseTo(
+        closeTo(
+          offsetResult.level,
           regularResults[index].level * mockSecondaryStation.height_offset.low,
           4
         )
-        expect(offsetResult.time.getTime()).toBe(
-          regularResults[index].time.getTime() +
-            mockSecondaryStation.time_offset.low * 60 * 1000
+        assert.ok(
+          offsetResult.time.getTime() ===
+            regularResults[index].time.getTime() +
+              mockSecondaryStation.time_offset.low * 60 * 1000
         )
       }
       if (offsetResult.high) {
-        expect(offsetResult.level).toBeCloseTo(
+        closeTo(
+          offsetResult.level,
           regularResults[index].level * mockSecondaryStation.height_offset.high,
           4
         )
 
-        expect(offsetResult.time.getTime()).toBe(
-          regularResults[index].time.getTime() +
-            mockSecondaryStation.time_offset.high * 60 * 1000
+        assert.ok(
+          offsetResult.time.getTime() ===
+            regularResults[index].time.getTime() +
+              mockSecondaryStation.time_offset.high * 60 * 1000
         )
       }
     })

package/{src/__tests__ → test}/index.js

@@ -1,5 +1,7 @@
-import mockConstituents from '../__mocks__/constituents'
-import tidePrediction from '../index.js'
+import assert from 'assert'
+import closeTo from './lib/close-to.js'
+import mockConstituents from './_mocks/constituents.js'
+import tidePrediction from '../src/index.js'
 
 const startDate = new Date()
 startDate.setFullYear(2019)
@@ -20,63 +22,62 @@ endDate.setSeconds(0)
 endDate.setMilliseconds(0)
 
 describe('Tidal station', () => {
-  test('it is created correctly', () => {
+  it('it is created correctly', () => {
     let stationCreated = true
-    let testStation = {} // eslint-disable-line
+
     try {
-      testStation = tidePrediction(mockConstituents)
+      tidePrediction(mockConstituents)
     } catch (e) {
       stationCreated = false
     }
-    expect(stationCreated).toBeTruthy()
+    assert.ok(stationCreated)
 
-    testStation = {}
     try {
-      testStation = tidePrediction(mockConstituents)
+      tidePrediction(mockConstituents)
     } catch (e) {
       stationCreated = false
     }
-    expect(stationCreated).toBeTruthy()
+    assert.ok(stationCreated)
   })
 
-  test('it predicts the tides in a timeline', () => {
+  it('it predicts the tides in a timeline', () => {
     const results = tidePrediction(mockConstituents).getTimelinePrediction({
       start: startDate,
       end: endDate
     })
-    expect(results[0].level).toBeCloseTo(-1.34712509, 3)
-    expect(results.pop().level).toBeCloseTo(2.85263589, 3)
+    closeTo(results[0].level, -1.34712509, 3)
+    closeTo(results.pop().level, 2.85263589, 3)
   })
 
-  test('it predicts the tidal extremes', () => {
+  it('it predicts the tidal extremes', () => {
     const results = tidePrediction(mockConstituents).getExtremesPrediction({
       start: startDate,
       end: endDate
     })
-    expect(results[0].level).toBeCloseTo(-1.565033, 4)
+    closeTo(results[0].level, -1.565033, 4)
   })
 
-  test('it predicts the tidal extremes with high fidelity', () => {
+  it('it predicts the tidal extremes with high fidelity', () => {
     const results = tidePrediction(mockConstituents).getExtremesPrediction({
       start: startDate,
       end: endDate,
       timeFidelity: 60
     })
-    expect(results[0].level).toBeCloseTo(-1.565389, 4)
+    closeTo(results[0].level, -1.565389, 4)
   })
 
-  test('it fetches a single water level', () => {
+  it('it fetches a single water level', () => {
     const result = tidePrediction(mockConstituents).getWaterLevelAtTime({
       time: startDate
     })
-    expect(result.level).toBeCloseTo(-1.34712509, 4)
+    closeTo(result.level, -1.34712509, 4)
   })
 
-  test('it adds offset phases', () => {
+  it('it adds offset phases', () => {
     const results = tidePrediction(mockConstituents, {
       offset: 3
     }).getExtremesPrediction({ start: startDate, end: endDate })
 
-    expect(results[0].level).toBeCloseTo(1.43496678, 4)
+    closeTo(results[0].level, 1.43496678, 4)
   })
 })

package/test/lib/close-to.js

@@ -0,0 +1,7 @@
+import assert from 'assert'
+
+export default (received, expected, precision) => {
+  const expectedDiff = Math.pow(10, -precision) / 2
+  const receivedDiff = Math.abs(expected - received)
+  assert.ok(receivedDiff < expectedDiff)
+}

package/test/noaa.js

@@ -0,0 +1,110 @@
+import assert from 'assert'
+import fs from 'fs'
+import https from 'https'
+import tidePrediction from '../src/index.js'
+
+// Create a directory for test cache
+if (!fs.existsSync('./.test-cache')) {
+  fs.mkdirSync('./.test-cache')
+}
+
+const stations = ['9413450', '9411340', '2695535', '8761724', '8410140']
+
+const makeRequest = (url) =>
+  new Promise((resolve, reject) => {
+    https.get(url, (response) => {
+      const data = []
+
+      response.on('data', (fragment) => {
+        data.push(fragment)
+      })
+
+      response.on('end', () => {
+        const body = Buffer.concat(data)
+        resolve(JSON.parse(body.toString()))
+      })
+
+      response.on('error', (error) => {
+        reject(error)
+      })
+    })
+  })
+
+const getStation = (station, callback) => {
+  const filePath = `./.test-cache/${station}.json`
+  if (fs.existsSync(filePath)) {
+    fs.readFile(filePath, (err, data) => {
+      if (err) {
+        throw new Error('Cannot access test cache')
+      }
+      callback(JSON.parse(data))
+    })
+    return
+  }
+  const stationData = {}
+  const tasks = []
+
+  tasks.push(
+    makeRequest(
+      `https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations/${station}/harcon.json?units=metric`
+    ).then((data) => {
+      stationData.harmonics = data
+    })
+  )
+
+  tasks.push(
+    makeRequest(
+      `https://api.tidesandcurrents.noaa.gov/api/prod/datagetter?date=recent&station=${station}&product=predictions&datum=MTL&time_zone=gmt&units=metric&format=json`
+    ).then((data) => {
+      stationData.levels = data
+    })
+  )
+
+  tasks.push(
+    makeRequest(
+      `https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations/${station}/datums.json?units=metric`
+    ).then((data) => {
+      stationData.info = data
+    })
+  )
+
+  Promise.all(tasks).then(() => {
+    fs.writeFile(filePath, JSON.stringify(stationData), (error) => {
+      if (error) {
+        throw new Error('Cannot write to test cache')
+      }
+      callback(stationData)
+    })
+  })
+}
+
+describe('Results compare to NOAA', () => {
+  stations.forEach((station) => {
+    it(`it compares with station ${station}`, (done) => {
+      getStation(station, ({ harmonics, levels, info }) => {
+        let mtl = 0
+        let mllw = 0
+        info.datums.forEach((datum) => {
+          if (datum.name === 'MTL') {
+            mtl = datum.value
+          }
+          if (datum.name === 'MLLW') {
+            mllw = datum.value
+          }
+        })
+        const tideStation = tidePrediction(
+          harmonics.HarmonicConstituents,
+          mtl - mllw
+        )
+        levels.predictions.forEach((prediction) => {
+          const neapsPrediction = tideStation.getWaterLevelAtTime({
+            time: new Date(prediction.t)
+          })
+          assert.ok(parseFloat(prediction.v) >= neapsPrediction.level - 0.5)
+          assert.ok(parseFloat(prediction.v) <= neapsPrediction.level + 0.5)
+        })
+        done()
+      })
+    }).timeout(20000)
+  })
+})

package/test/node-corrections/index.js

@@ -0,0 +1,116 @@
+import assert from 'assert'
+import closeTo from '../lib/close-to.js'
+import nodeCorrections from '../../src/node-corrections/index.js'
+
+const testItems = {
+  i: {
+    value: 5
+  },
+  I: { value: 6 },
+  omega: { value: 3 },
+  nu: { value: 4 },
+  nup: { value: 4 },
+  nupp: { value: 2 },
+  P: { value: 14 },
+  xi: {
+    value: 4
+  }
+}
+
+describe('Node corrections', () => {
+  it('have correct unity', () => {
+    assert.ok(nodeCorrections.fUnity() === 1)
+  })
+
+  it('calculates Schureman equations 73, 65 (f_Mm)', () => {
+    closeTo(nodeCorrections.fMm(testItems), 0.999051998091, 4)
+  })
+
+  it('calculates Schureman equations 74, 66 (f_Mf)', () => {
+    closeTo(nodeCorrections.fMf(testItems), 4.00426673883, 4)
+  })
+
+  it('calculates Schureman equations 75, 67 (f_O1)', () => {
+    closeTo(nodeCorrections.fO1(testItems), 2.00076050158, 4)
+  })
+
+  it('calculates Schureman equations 76, 68 (f_J1)', () => {
+    closeTo(nodeCorrections.fJ1(testItems), 2.0119685329, 4)
+  })
+
+  it('calculates Schureman equations 77, 69 (f_OO1)', () => {
+    closeTo(nodeCorrections.fOO1(testItems), 8.01402871709, 4)
+  })
+
+  it('calculates Schureman equations 78, 70 (f_M2)', () => {
+    closeTo(nodeCorrections.fM2(testItems), 0.999694287563, 4)
+  })
+
+  it('calculates Schureman equations 227, 226, 68 (f_K1)', () => {
+    closeTo(nodeCorrections.fK1(testItems), 1.23843964182, 4)
+  })
+
+  it('calculates Schureman equations 215, 213, 204 (f_L2)', () => {
+    closeTo(nodeCorrections.fL2(testItems), 0.98517860327, 4)
+  })
+
+  it('calculates Schureman equations 235, 234, 71 (f_K2)', () => {
+    closeTo(nodeCorrections.fK2(testItems), 1.09775430048, 4)
+  })
+
+  it('calculates Schureman equations 206, 207, 195 (f_M1)', () => {
+    closeTo(nodeCorrections.fM1(testItems), 3.90313810168, 4)
+  })
+
+  it('calculates e.g. Schureman equation 149 (f_Modd)', () => {
+    closeTo(nodeCorrections.fModd(testItems, 3), 0.999541466395, 4)
+  })
+
+  it('has a zero for u_zero', () => {
+    assert.ok(nodeCorrections.uZero() === 0.0)
+  })
+
+  it('calculates u_Mf', () => {
+    assert.ok(nodeCorrections.uMf(testItems) === -8.0)
+  })
+
+  it('calculates u_O1', () => {
+    assert.ok(nodeCorrections.uO1(testItems) === 4.0)
+  })
+
+  it('calculates u_J1', () => {
+    assert.ok(nodeCorrections.uJ1(testItems) === -4)
+  })
+
+  it('calculates u_OO1', () => {
+    assert.ok(nodeCorrections.uOO1(testItems) === -12.0)
+  })
+
+  it('calculates u_M2', () => {
+    assert.ok(nodeCorrections.uM2(testItems) === 0.0)
+  })
+
+  it('calculates u_K1', () => {
+    assert.ok(nodeCorrections.uK1(testItems) === -4)
+  })
+
+  it('calculates u_L2', () => {
+    closeTo(nodeCorrections.uL2(testItems), -0.449812364499, 4)
+  })
+
+  it('calculates u_K2', () => {
+    assert.ok(nodeCorrections.uK2(testItems) === -4.0)
+  })
+
+  it('calculates u_K2', () => {
+    assert.ok(nodeCorrections.uK2(testItems) === -4.0)
+  })
+
+  it('calculates u_M1', () => {
+    closeTo(nodeCorrections.uM1(testItems), 7.09154172301, 4)
+  })
+
+  it('calculates u_Modd', () => {
+    assert.ok(nodeCorrections.uModd(testItems, 3) === 0)
+  })
+})

package/.circleci/config.yml

@@ -1,26 +0,0 @@
-version: 2.1
-jobs:
-  build:
-    docker:
-      - image: circleci/node:10.16.3
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - test-cache-{{ .Branch }}-
-            - test-cache-
-      - run:
-          name: install
-          command: 'yarn install --production=false'
-      - run:
-          name: test
-          command: 'yarn run circleci'
-          environment:
-            JEST_JUNIT_OUTPUT: 'reports/junit/js-test-results.xml'
-      - run:
-          name: coverage
-          command: 'yarn run coverage'
-      - save_cache:
-          key: test-cache-{{ .Branch }}
-          paths:
-            - '.test-cache'

package/.eslintrc.js

@@ -1,21 +0,0 @@
-module.exports = {
-  env: {
-    browser: true,
-    es6: true,
-    node: true,
-    'jest/globals': true
-  },
-  extends: ['standard'],
-  globals: {
-    Atomics: 'readonly',
-    SharedArrayBuffer: 'readonly'
-  },
-  plugins: ['jest'],
-  parserOptions: {
-    ecmaVersion: 2018,
-    sourceType: 'module'
-  },
-  rules: {
-    'space-before-function-paren': 0
-  }
-}

package/Gruntfile.js

@@ -1,87 +0,0 @@
-/* eslint-env node */
-/* eslint-disable no-process-env, camelcase */
-
-module.exports = function(grunt) {
-  grunt.initConfig({
-    pkg: grunt.file.readJSON('package.json'),
-    eslint: {
-      options: {},
-      files: ['src/**/*.js', 'test/**/*.js']
-    },
-    clean: ['lib', 'dist'],
-    exec: {
-      rollup: {
-        command: 'BABEL_ENV=build rollup -c'
-      },
-      test: {
-        command: 'yarn run test'
-      }
-    },
-    uglify: {
-      options: {
-        mangle: true,
-        compress: true,
-        preserveComments: 'some'
-      },
-      dist: {
-        files: [
-          {
-            cwd: 'dist/',
-            expand: true,
-            src: ['*.js', '!*.min.js'],
-            dest: 'dist/',
-            rename: function(dest, src) {
-              return dest + src.replace(/\.js$/, '.min.js')
-            }
-          }
-        ]
-      }
-    },
-    babel: {
-      cjs: {
-        files: [
-          {
-            cwd: 'src/',
-            expand: true,
-            src: ['**/*.js', '!**/__tests__/**', '!**/__mocks__/**'],
-            dest: 'lib/'
-          }
-        ]
-      }
-    },
-    watch: {
-      scripts: {
-        options: {
-          atBegin: true
-        },
-
-        files: ['src/**/*.js', 'test/**/*.js'],
-        tasks: ['eslint', 'exec:test']
-      }
-    },
-    coveralls: {
-      options: {
-        force: false
-      },
-
-      coverage: {
-        src: 'coverage/lcov.info'
-      }
-    },
-    eslint: {
-      target: ['src/**/*.js']
-    }
-  })
-  this.registerTask(
-    'build',
-    'Builds a distributable version of the current project',
-    ['clean', 'eslint', 'exec:test', 'babel', 'exec:rollup']
-  )
-  grunt.loadNpmTasks('grunt-eslint')
-  grunt.loadNpmTasks('grunt-contrib-clean')
-  grunt.loadNpmTasks('grunt-contrib-uglify')
-  grunt.loadNpmTasks('grunt-contrib-watch')
-  grunt.loadNpmTasks('grunt-babel')
-  grunt.loadNpmTasks('grunt-exec')
-  grunt.loadNpmTasks('grunt-coveralls')
-}

package/babel.config.js

@@ -1,9 +0,0 @@
-module.exports = {
-  presets: ['@babel/preset-env'],
-  env: {
-    test: {},
-    build: {
-      ignore: ['**/__tests__', '**/__mocks__']
-    }
-  }
-}

package/lib/astronomy/coefficients.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sexagesimalToDecimal = exports["default"] = void 0;
-
-// Convert a sexagesimal angle into decimal degrees
-var sexagesimalToDecimal = function sexagesimalToDecimal(degrees, arcmins, arcsecs, mas, muas) {
-  arcmins = typeof arcmins !== 'undefined' ? arcmins : 0;
-  arcsecs = typeof arcsecs !== 'undefined' ? arcsecs : 0;
-  mas = typeof mas !== 'undefined' ? mas : 0;
-  muas = typeof muas !== 'undefined' ? muas : 0;
-  return degrees + arcmins / 60.0 + arcsecs / (60.0 * 60.0) + mas / (60.0 * 60.0 * 1e3) + muas / (60.0 * 60.0 * 1e6);
-};
-
-exports.sexagesimalToDecimal = sexagesimalToDecimal;
-var coefficients = {
-  // Meeus formula 21.3
-  terrestrialObliquity: [sexagesimalToDecimal(23, 26, 21.448), -sexagesimalToDecimal(0, 0, 4680.93), -sexagesimalToDecimal(0, 0, 1.55), sexagesimalToDecimal(0, 0, 1999.25), -sexagesimalToDecimal(0, 0, 51.38), -sexagesimalToDecimal(0, 0, 249.67), -sexagesimalToDecimal(0, 0, 39.05), sexagesimalToDecimal(0, 0, 7.12), sexagesimalToDecimal(0, 0, 27.87), sexagesimalToDecimal(0, 0, 5.79), sexagesimalToDecimal(0, 0, 2.45)].map(function (number, index) {
-    return number * Math.pow(1e-2, index);
-  }),
-  solarPerigee: [280.46645 - 357.5291, 36000.76932 - 35999.0503, 0.0003032 + 0.0001559, 0.00000048],
-  solarLongitude: [280.46645, 36000.76983, 0.0003032],
-  lunarInclination: [5.145],
-  lunarLongitude: [218.3164591, 481267.88134236, -0.0013268, 1 / 538841.0 - 1 / 65194000.0],
-  lunarNode: [125.044555, -1934.1361849, 0.0020762, 1 / 467410.0, -1 / 60616000.0],
-  lunarPerigee: [83.353243, 4069.0137111, -0.0103238, -1 / 80053.0, 1 / 18999000.0]
-};
-var _default = coefficients;
-exports["default"] = _default;

package/lib/astronomy/constants.js

@@ -1,10 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.r2d = exports.d2r = void 0;
-var d2r = Math.PI / 180.0;
-exports.d2r = d2r;
-var r2d = 180.0 / Math.PI;
-exports.r2d = r2d;