synset 0.9.4 → 0.9.6

package/README.md

@@ -88,15 +88,44 @@ import { exportToSQLite } from 'synset'
 // Export to SQLite
 exportToSQLite(lexicon, 'dictionary.db', {
   onProgress: ({ phase, current, total }) => {
+    // phases: words, synsets, word_synsets, synset_relations, sense_relations
     console.log(`${phase}: ${current}/${total}`)
   }
 })
 ```
 
-Schema (`words`, `synsets`, `word_synsets` tables) is available as:
+Schema is available as:
 - `import { SCHEMA } from 'synset'` - SQL string constant
 - `synset/schema.sql` - standalone file via package exports
 
+Tables:
+- `words` - unique words with display form
+- `synsets` - definitions with part of speech
+- `word_synsets` - word → synset mappings
+- `synset_relations` - hypernym, hyponym, meronym, etc. links between synsets
+- `sense_relations` - antonym, derivation, pertainym, etc. links between word senses
+
+Example queries:
+```sql
+-- Hypernyms via synset relations (dog → canine, domestic animal)
+SELECT w2.word_display, s2.definition
+FROM words w
+JOIN word_synsets ws ON w.id = ws.word_id
+JOIN synset_relations sr ON ws.synset_id = sr.source_id
+JOIN synsets s2 ON sr.target_id = s2.id
+JOIN word_synsets ws2 ON s2.id = ws2.synset_id
+JOIN words w2 ON ws2.word_id = w2.id
+WHERE w.word = 'dog' AND sr.rel_type = 'hypernym';
+
+-- Antonyms via sense relations (happy → unhappy)
+SELECT w2.word_display, s2.definition
+FROM words w
+JOIN sense_relations sr ON w.id = sr.source_word_id
+JOIN words w2 ON sr.target_word_id = w2.id
+JOIN synsets s2 ON sr.target_synset_id = s2.id
+WHERE w.word = 'happy' AND sr.rel_type = 'antonym';
+```
+
 ## Runtime
 
 - **Bun**: Full support

package/dist/cli.cjs

@@ -26,6 +26,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/export-sqlite.ts
 var import_libsql = __toESM(require("libsql"), 1);
 
+// src/helpers.ts
+var import_entities = require("entities");
+
 // src/types.ts
 var import_zod = require("zod");
 var LexiconId = import_zod.z.string();
@@ -327,10 +330,7 @@ function LexiconNode(node) {
   };
   return Lexicon.parse(extendWithRestAttr(node, obj, (s) => s));
 }
-var decodeXmlEntities = (s) => {
-  if (s === void 0) return void 0;
-  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&apos;/g, "'").replace(/&quot;/g, '"');
-};
+var decodeXmlEntities = (s) => s === void 0 ? void 0 : (0, import_entities.decodeXML)(s);
 var attr = (node, attrName) => {
   const value = decodeXmlEntities(node.attributes[attrName]);
   if (value === void 0) {
@@ -378,6 +378,25 @@ CREATE TABLE IF NOT EXISTS word_synsets (
   PRIMARY KEY (word_id, synset_id)
 );
 CREATE INDEX IF NOT EXISTS idx_ws_word ON word_synsets(word_id);
+
+CREATE TABLE IF NOT EXISTS synset_relations (
+  source_id TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  rel_type TEXT NOT NULL,
+  PRIMARY KEY (source_id, target_id, rel_type)
+);
+CREATE INDEX IF NOT EXISTS idx_sr_source ON synset_relations(source_id);
+CREATE INDEX IF NOT EXISTS idx_sr_target ON synset_relations(target_id);
+
+CREATE TABLE IF NOT EXISTS sense_relations (
+  source_word_id INTEGER NOT NULL,
+  source_synset_id TEXT NOT NULL,
+  target_word_id INTEGER NOT NULL,
+  target_synset_id TEXT NOT NULL,
+  rel_type TEXT NOT NULL,
+  PRIMARY KEY (source_word_id, source_synset_id, target_word_id, target_synset_id, rel_type)
+);
+CREATE INDEX IF NOT EXISTS idx_sense_rel_source ON sense_relations(source_word_id, source_synset_id);
 `;
 function exportToSQLite(lexicon, outputPath, options = {}) {
   const { onProgress } = options;
@@ -446,33 +465,127 @@ function exportToSQLite(lexicon, outputPath, options = {}) {
     }
   }
   db.exec("COMMIT");
-  const insertRelation = db.prepare(
+  const insertWordSynset = db.prepare(
     "INSERT OR IGNORE INTO word_synsets (word_id, synset_id) VALUES (?, ?)"
   );
-  let relationCount = 0;
-  const totalRelations = Array.from(wordToEntries.values()).reduce(
+  let wsCount = 0;
+  const totalWordSynsets = Array.from(wordToEntries.values()).reduce(
     (sum, entries) => sum + entries.reduce((s, e) => s + e.senses.length, 0),
     0
   );
   db.exec("BEGIN TRANSACTION");
   for (const [word, entries] of wordToEntries) {
-    const wordId2 = wordIds.get(word);
-    if (!wordId2) continue;
+    const wId = wordIds.get(word);
+    if (!wId) continue;
     for (const entry of entries) {
       for (const sense of entry.senses) {
-        insertRelation.run(wordId2, sense.synset);
-        relationCount++;
-        if (onProgress && relationCount % 1e4 === 0) {
+        insertWordSynset.run(wId, sense.synset);
+        wsCount++;
+        if (onProgress && wsCount % 1e4 === 0) {
           onProgress({
-            phase: "relations",
-            current: relationCount,
-            total: totalRelations
+            phase: "word_synsets",
+            current: wsCount,
+            total: totalWordSynsets
           });
         }
       }
     }
   }
   db.exec("COMMIT");
+  const insertSynsetRelation = db.prepare(
+    "INSERT OR IGNORE INTO synset_relations (source_id, target_id, rel_type) VALUES (?, ?, ?)"
+  );
+  let totalSynsetRelations = 0;
+  for (const synsetId of usedSynsetIds) {
+    const synset = synsetMap.get(synsetId);
+    if (synset) {
+      for (const rel of synset.synsetRelations) {
+        if (usedSynsetIds.has(rel.target)) {
+          totalSynsetRelations++;
+        }
+      }
+    }
+  }
+  db.exec("BEGIN TRANSACTION");
+  let srCount = 0;
+  for (const synsetId of usedSynsetIds) {
+    const synset = synsetMap.get(synsetId);
+    if (!synset) continue;
+    for (const rel of synset.synsetRelations) {
+      if (usedSynsetIds.has(rel.target)) {
+        insertSynsetRelation.run(synsetId, rel.target, rel.relType);
+        srCount++;
+        if (onProgress && srCount % 1e4 === 0) {
+          onProgress({
+            phase: "synset_relations",
+            current: srCount,
+            total: totalSynsetRelations
+          });
+        }
+      }
+    }
+  }
+  db.exec("COMMIT");
+  const senseToWordSynset = /* @__PURE__ */ new Map();
+  for (const [word, entries] of wordToEntries) {
+    const wId = wordIds.get(word);
+    if (!wId) continue;
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        senseToWordSynset.set(sense.id, {
+          wordId: wId,
+          synsetId: sense.synset
+        });
+      }
+    }
+  }
+  const insertSenseRelation = db.prepare(
+    "INSERT OR IGNORE INTO sense_relations (source_word_id, source_synset_id, target_word_id, target_synset_id, rel_type) VALUES (?, ?, ?, ?, ?)"
+  );
+  let totalSenseRelations = 0;
+  for (const entries of wordToEntries.values()) {
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        for (const rel of sense.senseRelations) {
+          if (senseToWordSynset.has(rel.target)) {
+            totalSenseRelations++;
+          }
+        }
+      }
+    }
+  }
+  db.exec("BEGIN TRANSACTION");
+  let senseRelCount = 0;
+  for (const [word, entries] of wordToEntries) {
+    const sourceWordId = wordIds.get(word);
+    if (!sourceWordId) continue;
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        const sourceSynsetId = sense.synset;
+        for (const rel of sense.senseRelations) {
+          const target = senseToWordSynset.get(rel.target);
+          if (target) {
+            insertSenseRelation.run(
+              sourceWordId,
+              sourceSynsetId,
+              target.wordId,
+              target.synsetId,
+              rel.relType
+            );
+            senseRelCount++;
+            if (onProgress && senseRelCount % 1e4 === 0) {
+              onProgress({
+                phase: "sense_relations",
+                current: senseRelCount,
+                total: totalSenseRelations
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  db.exec("COMMIT");
   db.close();
 }