@tduyng/pi-timbre 0.0.0-stage → 0.0.1

package/src/stats.ts

@@ -0,0 +1,112 @@
+export function sentences(text: string): string[] {
+    return text
+        .split(/(?<=[.!?])\s+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0)
+}
+
+export type Burstiness = {
+    cov: number
+    mean: number
+    count: number
+    monotoneRun: number
+}
+
+export function burstiness(text: string): Burstiness {
+    const lens = sentences(text).map((s) => s.split(/\s+/).length)
+    const count = lens.length
+    if (count === 0) return { cov: 0, mean: 0, count: 0, monotoneRun: 0 }
+
+    const mean = lens.reduce((a, b) => a + b, 0) / count
+    const variance = lens.reduce((a, b) => a + (b - mean) ** 2, 0) / count
+    const cov = mean === 0 ? 0 : Math.sqrt(variance) / mean
+
+    let run = 1
+    let best = 1
+    for (let i = 1; i < count; i++) {
+        run = Math.abs(lens[i]! - lens[i - 1]!) <= 3 ? run + 1 : 1
+        best = Math.max(best, run)
+    }
+
+    return { cov, mean, count, monotoneRun: count === 1 ? 1 : best }
+}
+
+export function wordCount(text: string): number {
+    return text.split(/\s+/).filter((w) => w !== '').length
+}
+
+export function isMonotone(b: Burstiness): boolean {
+    return b.count >= 6 && b.cov < 0.35
+}
+
+export function hasStaccatoRun(text: string): boolean {
+    const lens = sentences(text).map((s) => s.split(/\s+/).length)
+    let run = 0
+    for (const n of lens) {
+        run = n < 9 ? run + 1 : 0
+        if (run >= 4) return true
+    }
+    return false
+}
+
+export function openingOf(sentence: string): string {
+    const words = sentence.toLowerCase().match(/[a-z0-9']+/g) ?? []
+    if (words.length < 2) return ''
+    return `${words[0]} ${words[1]}`
+}
+
+export function repeatedOpening(text: string, run = 3): string | null {
+    const openings = sentences(text).map(openingOf)
+    let count = 0
+    let prev = ''
+    for (const o of openings) {
+        count = o !== '' && o === prev ? count + 1 : 1
+        prev = o
+        if (o !== '' && count >= run) return o
+    }
+    return null
+}
+
+const SUBORDINATORS = [
+    'who',
+    'whom',
+    'whose',
+    'which',
+    'although',
+    'because',
+    'since',
+    'whereas',
+    'despite',
+    'unless',
+    'until'
+] as const
+
+const SUBORDINATOR_RE = new RegExp(
+    `\\b(?:${SUBORDINATORS.join('|')})\\b|\\bin order to\\b|\\bresulting in\\b|\\bleading to\\b`,
+    'gi'
+)
+
+function subordinatorCount(sentence: string): number {
+    SUBORDINATOR_RE.lastIndex = 0
+    return (sentence.match(SUBORDINATOR_RE) ?? []).length
+}
+
+export function hasClauseStack(text: string, perSentence = 3, minSentences = 2): boolean {
+    let stacked = 0
+    for (const s of sentences(text)) {
+        if (subordinatorCount(s) >= perSentence) {
+            stacked++
+            if (stacked >= minSentences) return true
+        }
+    }
+    return false
+}
+export function hasLongSentenceRun(text: string, limit = 28, run = 3): boolean {
+    const lens = sentences(text).map((s) => s.split(/\s+/).length)
+    let count = 0
+    for (const n of lens) {
+        count = n > limit ? count + 1 : 0
+        if (count >= run) return true
+    }
+    return false
+}