@finbheara/domain 0.0.0-stage → 0.2.0

package/dist/noun-index.js

@@ -0,0 +1,233 @@
+import {
+  NAME_COLUMNS,
+  NAME_LEVEL_COLUMNS,
+  nameColumns,
+  personName
+} from "@finbheara/names/normalize";
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+var RESERVED = new Set(`rowid oid _rowid_ __r __v all and as by check create default delete distinct drop
+	from group in index insert into is key limit not null on or order primary references
+	select set table to union unique update values where`.split(/\s+/u));
+function ident(s, what) {
+  if (!IDENT.test(s) || RESERVED.has(s.toLowerCase()))
+    throw new Error(`noun-index: ${what} ${JSON.stringify(s)} is not a usable identifier`);
+  return s;
+}
+function resolve(encoder, options) {
+  const table = ident(options.table ?? "noun_index", "table");
+  const value = ident(options.value ?? "value", "value column");
+  const valueType = (options.valueType ?? "").trim();
+  if (!/^[A-Za-z ()0-9]*$/u.test(valueType))
+    throw new Error(`noun-index: value type ${JSON.stringify(valueType)} is not a type`);
+  const seen = new Set([value.toLowerCase()]);
+  for (const c of encoder.columns) {
+    ident(c, "column");
+    if (seen.has(c.toLowerCase()))
+      throw new Error(`noun-index: column ${c} is declared twice`);
+    seen.add(c.toLowerCase());
+  }
+  for (const c of [...encoder.levels, ...encoder.indexed])
+    if (!encoder.columns.includes(c))
+      throw new Error(`noun-index: ${c} is not a column`);
+  return { table, value, valueType, isKey: /primary\s+key/iu.test(valueType) };
+}
+function indexSchema(encoder, options = {}) {
+  const r = resolve(encoder, options);
+  const cols = [`${r.value}${r.valueType === "" ? "" : ` ${r.valueType}`}`];
+  for (const c of encoder.columns)
+    cols.push(`${c} TEXT`);
+  const indexes = [];
+  if (!r.isKey)
+    indexes.push(`CREATE INDEX IF NOT EXISTS ${r.table}_${r.value} ON ${r.table}(${r.value})`);
+  for (const c of encoder.indexed)
+    indexes.push(`CREATE INDEX IF NOT EXISTS ${r.table}_${c} ON ${r.table}(${c})`);
+  return { table: `CREATE TABLE IF NOT EXISTS ${r.table}(${cols.join(", ")})`, indexes };
+}
+var CHUNK = 500;
+function createIndex(handle, encoder, options = {}) {
+  const r = resolve(encoder, options);
+  const { table: T, value: VC } = r;
+  const cols = encoder.columns;
+  const prepared = new Map;
+  const stmt = (sql) => {
+    let s = prepared.get(sql);
+    if (s === undefined) {
+      s = handle.prepare(sql);
+      prepared.set(sql, s);
+    }
+    return s;
+  };
+  const column = (c) => {
+    if (!cols.includes(c))
+      throw new Error(`noun-index: ${c} is not a column of ${T}`);
+    return c;
+  };
+  const level = (l) => {
+    if (!encoder.levels.includes(l))
+      throw new Error(`noun-index: ${l} is not a level of ${T}`);
+    return l;
+  };
+  const insertSql = `INSERT INTO ${T}(${VC}, ${cols.join(", ")}) VALUES(${cols.map(() => "?").join(", ")}, ?)`;
+  const params = (x) => {
+    const e = encoder.encode(x);
+    return cols.map((c) => e[c] ?? null);
+  };
+  const insert = (x, value) => {
+    stmt(insertSql).run(value, ...params(x));
+  };
+  const keyAt = (x, l) => {
+    level(l);
+    return encoder.key === undefined ? encoder.encode(x)[l] ?? null : encoder.key(x, l);
+  };
+  const valuesWhere = (col, key) => stmt(`SELECT ${VC} AS v FROM ${T} WHERE ${col} = ? ORDER BY rowid`).all(key).map((o) => o.v);
+  const pick = (columns) => columns === undefined ? cols : columns.map(column);
+  const toRows = (raw, picked) => raw.map((o) => {
+    const row = {};
+    for (const c of picked)
+      row[c] = o[c] ?? null;
+    return { value: o.__v, row };
+  });
+  const selectList = (picked) => ["rowid AS __r", `${VC} AS __v`, ...picked].join(", ");
+  const index = {
+    table: T,
+    encoder,
+    add: insert,
+    addAll(entries) {
+      for (const [x, v] of entries)
+        insert(x, v);
+    },
+    get(x, l) {
+      const k = keyAt(x, l);
+      return k === null ? [] : valuesWhere(l, k);
+    },
+    has(x, l) {
+      const k = keyAt(x, l);
+      return k !== null && stmt(`SELECT 1 FROM ${T} WHERE ${l} = ? LIMIT 1`).all(k).length > 0;
+    },
+    find: (c, key) => valuesWhere(column(c), key),
+    rows(where, columns) {
+      const picked = pick(columns);
+      const seen = new Map;
+      for (const [c, keys] of Object.entries(where)) {
+        column(c);
+        const uniq = [...new Set(keys)];
+        for (let i = 0;i < uniq.length; i += CHUNK) {
+          const part = uniq.slice(i, i + CHUNK);
+          const sql = `SELECT ${selectList(picked)} FROM ${T} WHERE ${c} IN (${part.map(() => "?").join(",")})`;
+          for (const o of stmt(sql).all(...part))
+            seen.set(Number(o.__r), o);
+        }
+      }
+      return toRows([...seen].sort((a, b) => a[0] - b[0]).map(([, o]) => o), picked);
+    },
+    glob(c, pattern, columns) {
+      const picked = pick(columns);
+      const raw = stmt(`SELECT ${selectList(picked)} FROM ${T} WHERE ${column(c)} GLOB ? ORDER BY rowid`).all(pattern);
+      return toRows(raw, picked);
+    },
+    nouns(value) {
+      const raw = stmt(`SELECT ${cols.join(", ")} FROM ${T} WHERE ${VC} = ? ORDER BY rowid`).all(value);
+      return raw.map((o) => encoder.decode(o));
+    },
+    remove(value) {
+      const n = stmt(`SELECT count(*) AS n FROM ${T} WHERE ${VC} = ?`).all(value)[0].n;
+      if (n > 0)
+        stmt(`DELETE FROM ${T} WHERE ${VC} = ?`).run(value);
+      return Number(n);
+    },
+    size: () => Number(stmt(`SELECT count(*) AS n FROM ${T}`).all()[0].n),
+    map: (l) => viewAt(l)
+  };
+  function viewAt(l) {
+    const lc = level(l);
+    const heads = `SELECT rowid AS __r, ${VC} AS __v, ${cols.join(", ")} FROM ${T}
+			WHERE ${lc} IS NULL OR rowid IN (SELECT min(rowid) FROM ${T} WHERE ${lc} IS NOT NULL GROUP BY ${lc})
+			ORDER BY rowid`;
+    const head = (k) => stmt(`SELECT rowid AS __r, ${VC} AS __v FROM ${T} WHERE ${lc} = ? ORDER BY rowid LIMIT 1`).all(k)[0];
+    const all = () => stmt(heads).all();
+    const view = {
+      dop: l,
+      get size() {
+        const o = stmt(`SELECT (SELECT count(DISTINCT ${lc}) FROM ${T}) + (SELECT count(*) FROM ${T} WHERE ${lc} IS NULL) AS n`).all()[0];
+        return Number(o.n);
+      },
+      get(x) {
+        const k = keyAt(x, l);
+        return k === null ? undefined : head(k)?.__v;
+      },
+      has(x) {
+        const k = keyAt(x, l);
+        return k !== null && head(k) !== undefined;
+      },
+      set(x, value) {
+        const k = keyAt(x, l);
+        const h = k === null ? undefined : head(k);
+        if (h === undefined)
+          insert(x, value);
+        else
+          stmt(`UPDATE ${T} SET ${VC} = ? WHERE rowid = ?`).run(value, h.__r);
+        return this;
+      },
+      delete(x) {
+        const k = keyAt(x, l);
+        if (k === null || head(k) === undefined)
+          return false;
+        stmt(`DELETE FROM ${T} WHERE ${lc} = ?`).run(k);
+        return true;
+      },
+      clear() {
+        stmt(`DELETE FROM ${T}`).run();
+      },
+      *keys() {
+        for (const o of all())
+          yield encoder.decode(o);
+      },
+      *values() {
+        for (const o of all())
+          yield o.__v;
+      },
+      *entries() {
+        for (const o of all())
+          yield [encoder.decode(o), o.__v];
+      },
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    };
+    return view;
+  }
+  return index;
+}
+var sameColumns = (a, b) => NAME_COLUMNS.every((c) => a[c] === b[c]);
+function personEncoder(options = {}) {
+  const read = options.read ?? ((p, o) => personName(p, o));
+  const printCol = options.print ?? "print";
+  const readingCol = options.reading ?? "reading";
+  const readingOf = (x, cols) => {
+    const g = read(x.nn0, "given-first");
+    if (g === x || sameColumns(cols, nameColumns(g)))
+      return "given-first";
+    if (sameColumns(cols, nameColumns(read(x.nn0, "surname-first"))))
+      return "surname-first";
+    throw new Error(`personEncoder: ${JSON.stringify(x.nn0)} was not read by this encoder's reader in either order`);
+  };
+  return {
+    columns: [printCol, readingCol, ...NAME_COLUMNS],
+    levels: NAME_LEVEL_COLUMNS,
+    indexed: NAME_COLUMNS.filter((c) => c !== "given_key"),
+    encode(x) {
+      const cols = nameColumns(x);
+      return { [printCol]: x.nn0, [readingCol]: readingOf(x, cols), ...cols };
+    },
+    key: (x, level) => nameColumns(x)[level],
+    decode(row) {
+      const order = row[readingCol] === "surname-first" ? "surname-first" : "given-first";
+      return read(row[printCol] ?? "", order);
+    }
+  };
+}
+export {
+  createIndex,
+  indexSchema,
+  personEncoder
+};

package/dist/place.js

@@ -0,0 +1,36 @@
+import {
+  DEFAULT_PLACE_CAPACITY2,
+  createPlaceReader2,
+  DEFAULT_PLACE_READER2,
+  place2,
+  isPlaceToken2,
+  countryCodeOf2,
+  areAllPlaceTokens2,
+  placeFromId2,
+  oireachtasOfRegion2,
+  regionOfOireachtas2,
+  placeStats2,
+  resetPlaceCache2,
+  placeRelation2,
+  placesRelation2,
+  probablySamePlace2,
+  sameReading2
+} from "./chunks/place-qbp3xfb4.js";
+export {
+  DEFAULT_PLACE_CAPACITY2 as DEFAULT_PLACE_CAPACITY,
+  DEFAULT_PLACE_READER2 as DEFAULT_PLACE_READER,
+  areAllPlaceTokens2 as areAllPlaceTokens,
+  countryCodeOf2 as countryCodeOf,
+  createPlaceReader2 as createPlaceReader,
+  isPlaceToken2 as isPlaceToken,
+  oireachtasOfRegion2 as oireachtasOfRegion,
+  place2 as place,
+  placeFromId2 as placeFromId,
+  placeRelation2 as placeRelation,
+  placeStats2 as placeStats,
+  placesRelation2 as placesRelation,
+  probablySamePlace2 as probablySamePlace,
+  regionOfOireachtas2 as regionOfOireachtas,
+  resetPlaceCache2 as resetPlaceCache,
+  sameReading2 as sameReading
+};