ja-compromise 0.0.1 → 0.1.0

package/src/01-one/numbers/api.js

@@ -0,0 +1,202 @@
+import toNumber from './kanji-number.js'
+import toKanji, { toDigits } from './to-kanji.js'
+import counters from '../../../lexicon/counters.js'
+
+const isWide = /[０-９]/
+const isKanjiNumeral = /[〇零一二三四五六七八九十百千万億兆壱弐参拾]/
+
+// pull the number out of a match, along with how it was written
+const parse = function (view) {
+  let terms = view.docs[0] || []
+  let term = terms.find(t => typeof t.number === 'number')
+  if (!term) {
+    // not computed yet - read it off the text
+    term = terms[0]
+    let num = term ? toNumber(term.text) : null
+    return { num, term, kanji: term ? isKanjiNumeral.test(term.text) : false, wide: false }
+  }
+  return {
+    num: term.number,
+    term,
+    kanji: isKanjiNumeral.test(term.text),
+    wide: isWide.test(term.text),
+  }
+}
+
+// swap a term's text in place.  .replaceWith() would put a space between the
+// number and its counter, and japanese doesn't use one - 五冊, never 五 冊
+const setText = function (term, str, num) {
+  term.text = str
+  term.normal = str.toLowerCase()
+  if (typeof num === 'number') {
+    term.number = num
+  }
+}
+
+// write a number back in the shape it was found in
+const write = function (view, num, form) {
+  let { term, kanji, wide } = parse(view)
+  if (!term || typeof num !== 'number') {
+    return view
+  }
+  let str
+  if (form === 'kanji' || (form === undefined && kanji)) {
+    str = toKanji(num)
+  } else {
+    str = toDigits(num, form === undefined ? wide : false)
+  }
+  if (str === null) {
+    return view
+  }
+  setText(term, str, num)
+  return view
+}
+
+
+const addMethod = function (View) {
+  class Numbers extends View {
+    constructor(document, pointer, groups) {
+      super(document, pointer, groups)
+      this.viewType = 'Numbers'
+    }
+    /** the parsed number, plus how it was written */
+    parse(n) {
+      return this.getNth(n).map(parse)
+    }
+    /** the value of each number - 「二十三」 gives 23 */
+    get(n) {
+      // the second .map is a plain Array.map - compromise's own .map() only
+      // unwraps to an array when the callback returns strings or objects
+      return this.getNth(n).map(parse).map(o => o.num)
+    }
+    json(n) {
+      let opts = typeof n === 'object' ? n : {}
+      return this.getNth(n).map(m => {
+        let json = m.toView().json(opts)[0]
+        let found = parse(m)
+        json.number = { num: found.num, counter: m.units().text() || null }
+        return json
+      }, [])
+    }
+    /** the 助数詞 attached to each number - 五冊 gives 冊 */
+    units() {
+      return this.growRight('#Counter').match('#Counter$')
+    }
+    /** only the ordinals - 三番目 */
+    isOrdinal() {
+      return this.if('#Ordinal')
+    }
+    /** only the cardinals */
+    isCardinal() {
+      return this.if('#Cardinal')
+    }
+    /** write each number in digits - 二十三 becomes 23 */
+    toNumber() {
+      this.forEach(m => {
+        let { num } = parse(m)
+        if (num !== null) {
+          write(m, num, 'digits')
+        }
+      })
+      return this
+    }
+    /** write each number in kanji - 23 becomes 二十三 */
+    toText() {
+      this.forEach(m => {
+        let { num } = parse(m)
+        if (num !== null) {
+          write(m, num, 'kanji')
+        }
+      })
+      return this
+    }
+    /** add thousands-separators - 1234 becomes 1,234 */
+    toLocaleString() {
+      this.forEach(m => {
+        let { num, term } = parse(m)
+        if (num === null || !term) {
+          return
+        }
+        setText(term, num.toLocaleString(), num)
+      })
+      return this
+    }
+    /** replace each number with this one, keeping its script */
+    set(n) {
+      if (typeof n !== 'number') {
+        return this
+      }
+      this.forEach(m => write(m, n))
+      return this
+    }
+    add(n) {
+      if (typeof n !== 'number') {
+        return this
+      }
+      this.forEach(m => {
+        let { num } = parse(m)
+        if (num !== null) {
+          write(m, num + n)
+        }
+      })
+      return this
+    }
+    subtract(n) {
+      return this.add(-1 * n)
+    }
+    increment() {
+      return this.add(1)
+    }
+    decrement() {
+      return this.add(-1)
+    }
+    isEqual(n) {
+      return this.filter(m => parse(m).num === n)
+    }
+    greaterThan(n) {
+      return this.filter(m => parse(m).num > n)
+    }
+    lessThan(n) {
+      return this.filter(m => parse(m).num < n)
+    }
+    between(min, max) {
+      return this.filter(m => {
+        let { num } = parse(m)
+        return num > min && num < max
+      })
+    }
+    update(pointer) {
+      let m = new Numbers(this.document, pointer)
+      m._cache = this._cache
+      return m
+    }
+  }
+
+  /** every number in the document */
+  View.prototype.numbers = function (n) {
+    let m = this.match('#Value+')
+    m = new Numbers(this.document, m.pointer)
+    return typeof n === 'number' ? m.eq(n) : m
+  }
+  /** .numbers() alias, to match english compromise */
+  View.prototype.values = View.prototype.numbers
+
+  /** every 助数詞 in the document */
+  View.prototype.counters = function (n) {
+    let m = this.match('#Counter')
+    return typeof n === 'number' ? m.eq(n) : m
+  }
+  /** every 円/ドル amount */
+  View.prototype.money = function (n) {
+    let m = this.match('#Value+ #Currency')
+    return typeof n === 'number' ? m.eq(n) : m
+  }
+  /** every percentage */
+  View.prototype.percentages = function (n) {
+    let m = this.match('#Value+ #Percent')
+    return typeof n === 'number' ? m.eq(n) : m
+  }
+}
+
+export default { api: addMethod }
+export { counters }

package/src/01-one/numbers/kanji-number.js

@@ -0,0 +1,69 @@
+// 漢数字 → a javascript number.
+// japanese numerals are positional-by-power rather than positional-by-digit:
+// 三百二十一 is (3×100) + (2×10) + 1, and 三万 is 3×10,000.
+
+const digits = {
+  '〇': 0, '零': 0, '０': 0, '0': 0,
+  '一': 1, '壱': 1, '１': 1, '1': 1,
+  '二': 2, '弐': 2, '２': 2, '2': 2,
+  '三': 3, '参': 3, '３': 3, '3': 3,
+  '四': 4, '肆': 4, '４': 4, '4': 4,
+  '五': 5, '伍': 5, '５': 5, '5': 5,
+  '六': 6, '陸': 6, '６': 6, '6': 6,
+  '七': 7, '漆': 7, '７': 7, '7': 7,
+  '八': 8, '捌': 8, '８': 8, '8': 8,
+  '九': 9, '玖': 9, '９': 9, '9': 9,
+}
+// powers that stack inside a group
+const small = { '十': 10, '拾': 10, '百': 100, '佰': 100, '千': 1000, '仟': 1000 }
+// powers that close a group off
+const large = { '万': 1e4, '萬': 1e4, '億': 1e8, '兆': 1e12, '京': 1e16 }
+
+const isNumeral = function (c) {
+  return digits[c] !== undefined || small[c] !== undefined || large[c] !== undefined
+}
+
+/** parse a japanese numeral - returns null if the string isn't one */
+const toNumber = function (str) {
+  if (!str) {
+    return null
+  }
+  let total = 0    // everything closed off by 万/億/兆
+  let section = 0  // the current group, below 10,000
+  let current = 0  // the digits seen since the last power
+  let seen = false
+
+  for (let i = 0; i < str.length; i += 1) {
+    let c = str[i]
+    if (digits[c] !== undefined) {
+      // 15 and １５ are positional, so keep multiplying up
+      current = Number(current * 10) + Number(digits[c])
+      seen = true
+      continue
+    }
+    if (small[c] !== undefined) {
+      // 十 on its own is 10, not 0
+      section += (current === 0 ? 1 : current) * small[c]
+      current = 0
+      seen = true
+      continue
+    }
+    if (large[c] !== undefined) {
+      // a bare 万 is 10,000 - but 五十万 is 50×10,000, not 51×10,000
+      let group = section + current
+      total += (group === 0 ? 1 : group) * large[c]
+      section = 0
+      current = 0
+      seen = true
+      continue
+    }
+    return null // not a numeral
+  }
+  if (!seen) {
+    return null
+  }
+  return total + section + current
+}
+
+export default toNumber
+export { isNumeral, digits, small, large }

package/src/01-one/numbers/to-kanji.js

@@ -0,0 +1,66 @@
+// a number → 漢数字.
+//
+// japanese numerals are fully compositional - 23 is 二十三, literally
+// 'two-ten-three' - so this is arithmetic rather than a lookup table.
+// the one wrinkle is that japanese groups by 10,000 (万) and not by 1,000.
+
+const digit = ['', '一', '二', '三', '四', '五', '六', '七', '八', '九']
+// powers that stack inside a group of four digits
+const small = [['千', 1000], ['百', 100], ['十', 10]]
+// powers that close a group off
+const large = [['京', 1e16], ['兆', 1e12], ['億', 1e8], ['万', 1e4]]
+
+// one group of four digits: 千百十 plus the remaining digit
+const toGroup = function (n) {
+  let out = ''
+  for (let i = 0; i < small.length; i += 1) {
+    let [kanji, power] = small[i]
+    let d = Math.floor(n / power)
+    if (d === 0) {
+      continue
+    }
+    // 一十 and 一百 aren't written - 10 is 十, not 一十
+    out += (d === 1 ? '' : digit[d]) + kanji
+    n -= d * power
+  }
+  return out + digit[n]
+}
+
+/** 23 → 二十三 */
+const toKanji = function (num) {
+  if (typeof num !== 'number' || !Number.isFinite(num)) {
+    return null
+  }
+  if (num < 0) {
+    return 'マイナス' + toKanji(Math.abs(num))
+  }
+  num = Math.round(num)
+  if (num === 0) {
+    return '〇'
+  }
+  let out = ''
+  for (let i = 0; i < large.length; i += 1) {
+    let [kanji, power] = large[i]
+    let chunk = Math.floor(num / power)
+    if (chunk === 0) {
+      continue
+    }
+    // 万 and up keep their 一 - 10,000 is 一万, never just 万
+    out += toGroup(chunk) + kanji
+    num -= chunk * power
+  }
+  return out + toGroup(num)
+}
+
+// 23 → '23',  using the same width of digit the source used
+const fullWidth = '０１２３４５６７８９'
+const toDigits = function (num, wide) {
+  let str = String(num)
+  if (!wide) {
+    return str
+  }
+  return str.replace(/[0-9]/g, d => fullWidth[Number(d)])
+}
+
+export default toKanji
+export { toDigits }

package/src/01-one/output/compute/dict.js

@@ -0,0 +1,13 @@
+export default {
+  は: '-',
+  が: '-',
+  目: 'eye',
+  '私たち': 'we',
+  '彼': 'he',
+  '彼女': 'she',
+  '泳い': 'swim',
+  '泳ぎ': 'swimming',
+  '歩い': 'walk',
+  'する': '(do)',
+  '家': 'house'
+}

package/src/01-one/output/compute/english.js

@@ -0,0 +1,13 @@
+import dict from './dict.js'
+
+const addEnglish = function (view) {
+  view.docs.forEach(terms => {
+    terms.forEach(term => {
+      if (dict[term.normal]) {
+        term.english = dict[term.normal]
+      }
+    })
+  })
+  return view
+}
+export default addEnglish

package/src/01-one/output/compute/root.js

@@ -0,0 +1,30 @@
+import { roots } from '../../lexicon/lexicon.js'
+import { deconjugate } from '../../conjugate/index.js'
+
+const isKnown = (w) => lexicon.hasOwnProperty(w)
+
+// the dictionary-form of each word - 食べました → 食べる, 高かった → 高い
+const addRoot = function (view) {
+  view.docs.forEach(terms => {
+    terms.forEach(term => {
+      if (term.root) {
+        return
+      }
+      if (roots[term.text] !== undefined) {
+        term.root = roots[term.text]
+        return
+      }
+      // an unknown verb can still be walked back to its dictionary-form
+      if (term.tags.has('Verb')) {
+        let found = deconjugate(term.text, isKnown)
+        if (found) {
+          term.root = found.root
+          return
+        }
+      }
+      term.root = term.text
+    })
+  })
+  return view
+}
+export default addRoot

package/src/01-one/output/debug/_color.js

@@ -0,0 +1,16 @@
+// https://stackoverflow.com/questions/9781218/how-to-change-node-jss-console-font-color
+const reset = '\x1b[0m'
+
+//cheaper than requiring chalk
+const cli = {
+  green: str => '\x1b[32m' + str + reset,
+  red: str => '\x1b[31m' + str + reset,
+  blue: str => '\x1b[34m' + str + reset,
+  magenta: str => '\x1b[35m' + str + reset,
+  cyan: str => '\x1b[36m' + str + reset,
+  yellow: str => '\x1b[33m' + str + reset,
+  black: str => '\x1b[30m' + str + reset,
+  dim: str => '\x1b[2m' + str + reset,
+  i: str => '\x1b[3m' + str + reset,
+}
+export default cli

package/src/01-one/output/debug/index.js

@@ -0,0 +1,24 @@
+/* eslint-disable no-console */
+import showTags from './tags.js'
+
+function isClientSide() {
+  return typeof window !== 'undefined' && window.document
+}
+//output some helpful stuff to the console
+const debug = function (opts = {}) {
+  let view = this
+  if (typeof opts === 'string') {
+    let tmp = {}
+    tmp[opts] = true //allow string input
+    opts = tmp
+  }
+  if (isClientSide()) {
+    return view
+  }
+  if (opts.tags !== false) {
+    showTags(view)
+    console.log('\n')
+  }
+  return view
+}
+export default debug

package/src/01-one/output/debug/tags.js

@@ -0,0 +1,56 @@
+/* eslint-disable no-console */
+import cli from './_color.js'
+
+const skip = {
+  Kanji: 'dim',
+  Hiragana: 'dim',
+  Katagana: 'dim',
+  Ascii: 'dim'
+}
+const tagString = function (tags, model) {
+  if (model.one.tagSet) {
+    tags = tags.filter(str => !skip[str])
+    tags = tags.map(tag => {
+      if (!model.one.tagSet.hasOwnProperty(tag)) {
+        return tag
+      }
+      const c = model.one.tagSet[tag].color || skip[tag] || 'blue'
+      return cli[c](tag)
+    })
+  }
+  return tags.join(', ')
+}
+
+const showTags = function (view) {
+  let { docs, model } = view
+  if (docs.length === 0) {
+    console.log(cli.blue('\n     ──────'))
+  }
+  docs.forEach(terms => {
+    console.log(cli.blue('\n  ┌─────────'))
+    terms.forEach(t => {
+      let tags = [...(t.tags || [])]
+      let text = t.text || '-'
+      if (t.sense) {
+        text = `{${t.normal}/${t.sense}}`
+      }
+      if (t.implicit) {
+        text = '[' + t.implicit + ']'
+      }
+      text = cli.yellow(text)
+      let word = "'" + text + "'"
+      // word = word.padEnd(15)
+      if (t.english) {
+        word += cli.i(` {${t.english}}`.padEnd(6))
+      }
+      if (t.reference) {
+        let str = view.update([t.reference]).text('normal')
+        word += ` - ${cli.dim(cli.i('[' + str + ']'))}`
+      }
+      word = word.padEnd(18)
+      let str = cli.blue('  │ ') + cli.i(word) + '  - ' + tagString(tags, model)
+      console.log(str)
+    })
+  })
+}
+export default showTags

package/src/01-one/output/plugin.js

@@ -0,0 +1,13 @@
+import debug from './debug/index.js'
+import english from './compute/english.js'
+import root from './compute/root.js'
+
+const methods = { debug }
+
+const api = function (View) {
+  Object.assign(View.prototype, methods)
+}
+export default {
+  compute: { english, root },
+  api
+}

package/src/01-one/romanji/api.js

@@ -0,0 +1,16 @@
+export default function (View) {
+
+  /**  */
+  View.prototype.romanji = function () {
+    this.compute('romanji')
+    let out = ''
+    this.docs.forEach(terms => {
+      terms.forEach(term => {
+        out += term.pre + (term.romanji || term.text) + (term.post || ' ')
+      })
+    })
+    // convert inter-bang
+    out = out.replace(/・/, ' ')
+    return out
+  }
+}

package/src/01-one/romanji/compute/index.js

@@ -0,0 +1,36 @@
+import toRomanji from './toRomanji/index.js'
+import toReading from './kanji-reading/index.js'
+import { roots } from '../../lexicon/lexicon.js'
+
+// は, へ and を are pronounced wa, e and o when they're particles
+const particleSound = { 'は': 'wa', 'へ': 'e', 'を': 'o' }
+
+const romanji = function (view) {
+  view.document.forEach(terms => {
+    terms.forEach(term => {
+      if (particleSound[term.text] && term.tags.has('Particle')) {
+        term.romanji = particleSound[term.text]
+        return
+      }
+      let word = term.normal
+      // any kanji in the word needs sounding-out first
+      if (/[一-龯]/.test(word)) {
+        word = toReading(word, null, term.root || roots[word])
+      }
+      term.romanji = toRomanji(word)
+    })
+  })
+  return view
+}
+
+const readings = function (view) {
+  view.document.forEach(terms => {
+    terms.forEach(term => {
+      if (/[一-龯]/.test(term.text)) {
+        term.reading = toReading(term.normal, null, term.root || roots[term.normal])
+      }
+    })
+  })
+  return view
+}
+export default { romanji, readings }

package/src/01-one/romanji/compute/kanji-reading/index.js

@@ -0,0 +1,91 @@
+import readings from './readings.js'
+import words from './words.js'
+
+// the reading-table is written in katakana - fold it to hiragana so the
+// romanizer only has to know one script
+const toHiragana = function (str) {
+  let out = ''
+  for (let i = 0; i < str.length; i += 1) {
+    let c = str[i]
+    out += c >= 'ァ' && c <= 'ヶ' ? String.fromCharCode(c.charCodeAt(0) - 0x60) : c
+  }
+  return out
+}
+
+const isKanji = (c) => c >= '一' && c <= '龯'
+
+// the kun-reading is written 'い.く' - the part before the dot is what the
+// kanji itself spells;  the rest is the okurigana already in the text
+const kunStem = (kun) => kun.split('.')[0]
+
+const soundOut = function (char, type) {
+  let r = readings[char]
+  if (!r) {
+    return char
+  }
+  let [kun, on] = r.split('|')
+  let pick = type === 'kun' ? kun || on : on || kun
+  return toHiragana(kunStem(pick || char))
+}
+
+/**
+ * sound-out a word's kanji.
+ * a lone kanji followed by okurigana (行き, 読む) is a native verb, so it
+ * takes its kun-reading.  a run of two or more kanji (勉強) is a sino-japanese
+ * compound, and takes the on-reading.
+ */
+/**
+ * 食べました isn't in the override table, but its dictionary-form 食べる is.
+ * the root tells us what its kanji spells (食 → た), and the okurigana is
+ * already right there in the text.
+ */
+const fromRoot = function (word, root) {
+  let reading = words[root]
+  if (!reading) {
+    return null
+  }
+  // the kanji sit at the front of both the word and its root
+  let stem = root.split('').findIndex(c => !isKanji(c))
+  if (stem <= 0) {
+    return null
+  }
+  let okurigana = root.slice(stem)
+  if (!reading.endsWith(okurigana)) {
+    return null
+  }
+  let kanjiSound = reading.slice(0, reading.length - okurigana.length)
+  return word.startsWith(root.slice(0, stem)) ? kanjiSound + word.slice(stem) : null
+}
+
+const spellKanji = function (word, type, root) {
+  if (words[word] !== undefined) {
+    return words[word]
+  }
+  if (root && root !== word) {
+    let viaRoot = fromRoot(word, root)
+    if (viaRoot) {
+      return viaRoot
+    }
+  }
+  let out = ''
+  let i = 0
+  while (i < word.length) {
+    if (!isKanji(word[i])) {
+      out += word[i]
+      i += 1
+      continue
+    }
+    // how long is this run of kanji?
+    let run = ''
+    while (i < word.length && isKanji(word[i])) {
+      run += word[i]
+      i += 1
+    }
+    let use = type || (run.length > 1 ? 'on' : 'kun')
+    run.split('').forEach(c => {
+      out += soundOut(c, use)
+    })
+  }
+  return out
+}
+export default spellKanji