de-compromise 0.0.9 → 0.1.0

package/src/index.js

@@ -0,0 +1,53 @@
+import nlp from './_lib.js'
+import lexicon from './01-one/lexicon/plugin.js'
+import tagset from './01-one/tagset/plugin.js'
+import tokenizer from './01-one/tokenizer/plugin.js'
+import splitter from './01-one/splitter/plugin.js'
+import tagger from './02-two/preTagger/plugin.js'
+import postTagger from './02-two/postTagger/plugin.js'
+import numbers from './03-three/numbers/plugin.js'
+import verbs from './03-three/verbs/plugin.js'
+import adjectives from './03-three/adjectives/plugin.js'
+import nouns from './03-three/nouns/plugin.js'
+import version from './_version.js'
+
+nlp.plugin(tokenizer)
+nlp.plugin(tagset)
+nlp.plugin(lexicon)
+nlp.plugin(tagger)
+nlp.plugin(postTagger)
+nlp.plugin(splitter)
+nlp.plugin(numbers)
+nlp.plugin(verbs)
+nlp.plugin(adjectives)
+nlp.plugin(nouns)
+
+const de = function (txt, lex) {
+  let dok = nlp(txt, lex)
+  return dok
+}
+
+// copy constructor methods over
+Object.keys(nlp).forEach(k => {
+  if (nlp.hasOwnProperty(k)) {
+    de[k] = nlp[k]
+  }
+})
+
+// this one is hidden
+Object.defineProperty(de, '_world', {
+  value: nlp._world,
+  writable: true,
+})
+/** log the decision-making to console */
+de.verbose = function (set) {
+  let env = typeof process === 'undefined' ? self.env || {} : process.env //use window, in browser
+  env.DEBUG_TAGS = set === 'tagger' || set === true ? true : ''
+  env.DEBUG_MATCH = set === 'match' || set === true ? true : ''
+  env.DEBUG_CHUNKS = set === 'chunker' || set === true ? true : ''
+  return this
+}
+
+de.version = version
+
+export default de

package/types/index.d.ts

@@ -0,0 +1,46 @@
+import { Lexicon, Plugin, matchOptions, Match, Net } from './misc'
+import View from './view/de'
+
+/** parse a given text */
+declare function nlp(text: string, lexicon?: Lexicon): View
+
+// Constructor
+declare module nlp {
+  /** interpret text without tagging */
+  export function tokenize(text: string, lexicon?: Lexicon): View
+  /** scan through text with minimal analysis */
+  export function lazy(text: string, match?: string): View
+  /** mix-in a compromise plugin */
+  export function plugin(plugin: Plugin): any
+  /** mix-in a compromise plugin */
+  export function extend(plugin: Plugin): any
+  /** turn a match-string into json */
+  export function parseMatch(match: string, opts?: matchOptions): object[]
+  /** grab library internals */
+  export function world(): object
+  /** grab library metadata */
+  export function model(): object
+  /** grab exposed library methods */
+  export function methods(): object
+  /** which compute functions run automatically */
+  export function hooks(): string[]
+  /**  log our decision-making for debugging */
+  export function verbose(toLog?: boolean | string): any
+  /**  current semver version of the library */
+  export const version: string
+  /** connect new tags to tagset graph */
+  export function addTags(tags: object): any
+  /** add new words to internal lexicon */
+  export function addWords(words: Lexicon): any
+  /** turn a list of words into a searchable graph */
+  export function buildTrie(words: string[]): object
+  /** compile a set of match objects to a more optimized form */
+  export function buildNet(matches: Match[]): Net
+  /** add words to the autoFill dictionary */
+  export function typeahead(words: Lexicon): any
+  /** export internal methods for plugins */
+  export interface TypedPlugin<Methods extends object> extends Plugin { methods: Methods }
+}
+
+export default nlp
+

package/types/misc.ts

@@ -0,0 +1,92 @@
+export type Document = Term[][]
+
+export type Pointer = [n?: number, start?: number, end?: number, startId?: string, endId?: string]
+
+export type outMethods = 'text' | 'normal' | 'offset' | 'terms' | 'topk' | 'json' | 'tags' | 'array' | 'debug'
+
+export type Groups = object
+
+export interface Term {
+  text: string,
+  pre: string,
+  post: string,
+  normal: string,
+
+  // in /two
+  tags?: Set<string>,
+  index?: [n?: number, start?: number],
+  id?: string,
+  chunk?: string,
+  dirty?: boolean
+
+  // other things you may find...
+  syllables?: string[],
+}
+
+// possible values to .json()
+export interface JsonProps {
+  /**  a perfect copy of the input text */
+  text?: boolean
+  /** normalized whitespace, case, unicode, punctuation */
+  normal?: boolean
+  /** lowercase, trimmed, contractions expanded. */
+  reduced?: boolean
+  /** cleanup whitespace */
+  trim?: boolean
+  /** character-position where this begins */
+  offset?: boolean
+  /** frequency of this match in the document */
+  count?: boolean
+  /**  remove duplicate results*/
+  unique?: boolean
+  /** starting term # in document */
+  index?: boolean
+  /** options for each term */
+  terms?: {
+    text?: boolean
+    normal?: boolean
+    clean?: boolean
+    implicit?: boolean
+    tags?: boolean
+    whitespace?: boolean
+    id?: boolean
+    offset?: boolean
+    bestTag?: boolean
+  }
+}
+
+// a key-value object of words, terms
+export interface Lexicon {
+  [key: string]: string
+}
+
+export interface Plugin {
+  methods?: object,
+  model?: object,
+  compute?: object,
+  hooks?: string[],
+  tags?: object,
+  words?: object,
+  lib?: () => object,
+  api?: (fn: (view: any) => {}) => void,  //should be View
+  mutate?: (fn: (world: object) => {}) => void,
+}
+
+export interface matchOptions {
+  fuzzy?: number,
+  caseSensitive?: boolean,
+}
+
+export interface Match {
+  match: string,
+  tag?: string | string[],
+  unTag?: string | string[],
+  group?: string | number,
+  reason?: string,
+}
+
+export interface Net {
+  hooks: object,
+  always?: any,
+  isNet: boolean
+}

package/types/view/de.ts

@@ -0,0 +1,61 @@
+import View from './one'
+
+
+interface Numbers extends View {
+  /** grab the parsed number */
+  parse: (n?: number) => object[]
+  /** grab the parsed number */
+  get: (n?: number) => number | number[]
+  /** grab 'kilos' from `25 kilos' */
+  // units: () => View
+  /** return only ordinal numbers */
+  isOrdinal: () => View
+  /** return only cardinal numbers */
+  isCardinal: () => View
+  /** convert number to `5` or `5th` */
+  toNumber: () => View
+  /** add commas, or nicer formatting for numbers */
+  toLocaleString: () => View
+  /** convert number to `five` or `fifth` */
+  toText: () => View
+  /** convert number to `five` or `5` */
+  toCardinal: () => View
+  /** convert number to `fifth` or `5th` */
+  toOrdinal: () => View
+  /** return numbers with this value */
+  isEqual: () => View
+  /** return numbers bigger than n */
+  greaterThan: (min: number) => View
+  /** return numbers smaller than n */
+  lessThan: (max: number) => View
+  /** return numbers between min and max */
+  between: (min: number, max: number) => View
+  /** set number to n */
+  set: (n: number) => View
+  /** increase number by n */
+  add: (n: number) => View
+  /** decrease number by n*/
+  subtract: (n: number) => View
+  /** increase number by 1 */
+  increment: () => View
+  /** decrease number by 1*/
+  decrement: () => View
+}
+
+interface Contractions extends View {
+  /**  */
+  expand(): View
+}
+
+
+
+interface FrView extends View {
+  /** return any multi-word terms, like "didn't"  */
+  contractions: (n?: number) => Contractions
+  /**  */
+  numbers(): Numbers
+  /**  */
+  topics(): View
+}
+
+export default FrView

package/types/view/one.ts

@@ -0,0 +1,235 @@
+import { Document, Pointer, Groups, JsonProps, outMethods, matchOptions, Term, Net } from '../misc'
+
+class View {
+  // Utils
+  /** is this document empty? */
+  found: boolean
+  /** get a list of term objects for this view */
+  docs: Document
+  /** get the full parsed text */
+  document: Document
+  /** the indexes for the current view */
+  pointer: Pointer[] | null
+  /** explicit indexes for the current view */
+  fullPointer: Pointer[]
+  /** access internal library methods */
+  methods: object
+  /** access internal library data */
+  model: object
+  /** which compute methods run by default */
+  hooks: string[]
+  /** helper for detecting a compromise object */
+  isView: boolean
+  /** count the # of characters of each match */
+  length: number
+
+  /** create a new view, from this document */
+  update: (pointer: Pointer | null) => View
+  /** turn a Verb or Noun view into a normal one */
+  toView: (pointer: Pointer | null) => View
+  /** create a new document */
+  fromText: (text: string) => View
+  /** .docs [alias] */
+  termList: () => Term[]
+
+  /** run a named operation on the document */
+  compute: (method: string | string[]) => View
+  /** deep-copy the document, so that no references remain */
+  clone: (shallow?: boolean) => View
+
+  // Loops
+  /** run a function on each phrase, as an individual document */
+  forEach: (fn: (m: View) => void) => View
+  /** run each phrase through a function, and create a new document */
+  map: (fn: (m: View) => any, emptyResult?: any) => View | []
+  /** return only the phrases that return true */
+  filter: (fn: (m: View) => boolean) => View
+  /** return a document with only the first phrase that matches */
+  find: (fn: (m: View) => boolean) => View | undefined
+  /** return true or false if there is one matching phrase */
+  some: (fn: (m: View) => boolean) => View
+  /** sample a subset of the results */
+  random: (n?: number) => View
+
+  // Accessors    
+  /** split-up results by each individual term */
+  terms: (n?: number) => View
+  /** grab a specific named capture group */
+  groups: (name?: string) => View | Groups
+  /** use only the nth result */
+  eq: (n: number) => View
+  /** use only the first result(s) */
+  first: (n?: number) => View
+  /** use only the last result(s) */
+  last: (n?: number) => View
+  /** get the first word in each match */
+  firstTerms: () => View
+  /** get the end word in each match */
+  lastTerms: () => View
+  /** grab a subset of the results */
+  slice: (start: number, end?: number) => View
+  /** return the whole original document ('zoom out') */
+  all: () => View
+  /** return the full original sentence for each match */
+  fullSentences: () => View
+  /** return an empty view */
+  none: () => View
+  /** are these two views of the same document? */
+  isDoc: (view?: View) => boolean
+  /** count the # of terms in each match */
+  wordCount: () => number
+
+  // Match
+  /** return matching patterns in this doc */
+  match: (match: string | View | Net, group?: string | number, options?: matchOptions) => View
+  /** return only the first match */
+  matchOne: (match: string | View | Net, group?: string | number, options?: matchOptions) => View
+  /** Return a boolean if this match exists */
+  has: (match: string | View | Net, group?: string | number, options?: matchOptions) => boolean
+  /** return each current phrase, only if it contains this match */
+  if: (match: string | View | Net, group?: string | number, options?: matchOptions) => View
+  /** Filter-out any current phrases that have this match */
+  ifNo: (match: string | View | Net, group?: string | number, options?: matchOptions) => View
+
+  /** return the terms before each match */
+  before: (match: string | View, group?: string | number, options?: matchOptions) => View
+  /** return the terms after each match */
+  after: (match: string | View, group?: string | number, options?: matchOptions) => View
+  /** add any immediately-preceding matches to the view*/
+  growLeft: (match: string | View, group?: string | number, options?: matchOptions) => View
+  /** add any immediately-following matches to the view*/
+  growRight: (match: string | View, group?: string | number, options?: matchOptions) => View
+  /** expand the view with any left-or-right matches*/
+  grow: (match: string | View, group?: string | number, options?: matchOptions) => View
+  /** apply a sequence of match objects to the document */
+  sweep: (match: Net, opts?: object) => { view: View, found: object[] }
+
+  /** .split() [alias] */
+  splitOn: (match?: string, group?: string | number) => View
+  /** separate everything after the match as a new phrase */
+  splitBefore: (match?: string, group?: string | number) => View
+  /** separate everything before the word, as a new phrase */
+  splitAfter: (match?: string, group?: string | number) => View
+  /** splitAfter() alias */
+  split: (match?: string, group?: string | number) => View
+
+  // Case
+  /** turn every letter of every term to lower-cse */
+  toLowerCase: () => View
+  /** turn every letter of every term to upper case */
+  toUpperCase: () => View
+  /** upper-case the first letter of each term */
+  toTitleCase: () => View
+  /** remove whitespace and title-case each term */
+  toCamelCase: () => View
+
+  // Insert
+  /** add these new things to the end */
+  concat: (input: string | View) => View
+  /** add these words before each match */
+  insertBefore: (input: string | View) => View
+  /** insertBefore() alias */
+  prepend: (input: string | View) => View
+  /** add these words after each match */
+  insertAfter: (text: string | View) => View
+  /** insertAfter() alias */
+  append: (text: string | View) => View
+  /** insertAfter() alias */
+  insert: (text: string | View) => View
+  /** fully remove these terms from the document */
+  remove: (match: string | View) => View
+  /** alias for .remove() */
+  delete: (match: string | View) => View
+  /** search and replace match with new content */
+  replace: (from: string | View, to?: string | Function, keep?: object) => View
+  /** substitute-in new content */
+  replaceWith: (to: string | Function, keep?: object) => View
+
+  /** remove any duplicate matches */
+  unique: () => View
+  /**reverse the order of the matches, but not the words */
+  reverse: () => View
+  /**re-arrange the order of the matches (in place) */
+  sort: (method?: string | Function) => View
+
+  // Whitespace
+  /** add this punctuation or whitespace before each match */
+  pre: (str?: string, concat?: boolean) => View
+  /** add this punctuation or whitespace after each match */
+  post: (str?: string, concat?: boolean) => View
+  /** remove start and end whitespace */
+  trim: () => View
+  /** connect words with hyphen, and remove whitespace */
+  hyphenate: () => View
+  /** remove hyphens between words, and set whitespace */
+  dehyphenate: () => View
+  /** alias for .dehyphenate() */
+  deHyphenate: () => View
+  /** add quotation marks around selections */
+  toQuotations: (start?: string, end?: string) => View
+  /** alias for toQuotations() */
+  toQuotation: (start?: string, end?: string) => View
+  /** add parentheses around selections */
+  toParentheses: (start?: string, end?: string) => View
+
+
+  // Output
+  /** return the document as text */
+  text: (options?: string | object) => string
+  /** pull out desired metadata from the document */
+  json: (options?: JsonProps | string) => any
+  /** pretty-print the current document and its tags */
+  debug: () => View
+  /** some named output formats */
+  out: (format?: outMethods) => any
+  /** produce an html string */
+  html: (toHighlight: object) => string
+  /** produce an html string */
+  wrap: (matches: object) => string
+
+
+  // ### Pointers
+  /** return all matches without duplicates */
+  union: (match: string | View) => View
+  /** .union() alias */
+  and: (match: string | View) => View
+  /** return only duplicate matches */
+  intersection: (match: string | View) => View
+  /** return all results except for this */
+  not: (match: string | View, options?: any) => View
+  /** .not() alias */
+  difference: (match: string | View, options?: any) => View
+  /** get everything that is not a match */
+  complement: (match: string | View) => View
+  /** remove overlaps in matches */
+  settle: (match: string | View) => View
+
+
+  // Tag
+  /** Give all terms the given tag */
+  tag: (tag: string, reason?: string) => View
+  /** Only apply tag to terms if it is consistent with current tags */
+  tagSafe: (tag: string, reason?: string) => View
+  /** Remove this term from the given terms */
+  unTag: (tag: string, reason?: string) => View
+  /** return only the terms that can be this tag */
+  canBe: (tag: string) => View
+
+  // Cache
+  /** freeze the current state of the document, for speed-purposes */
+  cache: (options?: object) => View
+  /** un-freezes the current state of the document, so it may be transformed */
+  uncache: (options?: object) => View
+  /* 
+   harden: () => View
+   soften: () => View
+   */
+
+  /** quick find for an array of string matches */
+  lookup: (trie: object | string[], opts?: object) => View
+  /** assume any type-ahead prefixes */
+  autoFill: () => View
+
+}
+
+export default View