@bicharts/shape-core 0.1.13 → 0.1.15

package/dist/chunk-VHWC3THS.mjs

@@ -1,572 +0,0 @@
-/*! @bicharts/shape-core — Apache-2.0. Bundled reference data: GeoNames (https://www.geonames.org/) CC BY 4.0; US Census/TIGER (public domain). Full text: NOTICE in this package. */
-
-// src/ordinalDetector.ts
-var PATTERNS = [
-  // Likert agreement — the case that motivated this whole feature
-  {
-    name: "likert7_agreement",
-    minMatches: 5,
-    canonical: ["strongly disagree", "disagree", "slightly disagree", "neutral", "slightly agree", "agree", "strongly agree"]
-  },
-  {
-    name: "likert5_agreement",
-    minMatches: 3,
-    canonical: ["strongly disagree", "disagree", "neutral", "agree", "strongly agree"]
-  },
-  {
-    name: "likert3_agreement",
-    minMatches: 2,
-    canonical: ["disagree", "neutral", "agree"]
-  },
-  // Satisfaction
-  {
-    name: "likert5_satisfaction",
-    minMatches: 3,
-    canonical: ["very dissatisfied", "dissatisfied", "neutral", "satisfied", "very satisfied"]
-  },
-  {
-    name: "likert3_satisfaction",
-    minMatches: 2,
-    canonical: ["dissatisfied", "neutral", "satisfied"]
-  },
-  // Quality
-  {
-    name: "likert5_quality",
-    minMatches: 3,
-    canonical: ["poor", "fair", "good", "very good", "excellent"]
-  },
-  {
-    name: "likert3_quality",
-    minMatches: 2,
-    canonical: ["poor", "fair", "good"]
-  },
-  // Frequency
-  {
-    name: "frequency5",
-    minMatches: 3,
-    canonical: ["never", "rarely", "sometimes", "often", "always"]
-  },
-  // Intensity — common in psychology / wellness surveys
-  {
-    name: "intensity5",
-    minMatches: 3,
-    canonical: ["not at all", "slightly", "moderately", "very", "extremely"]
-  },
-  // Importance
-  {
-    name: "importance5",
-    minMatches: 3,
-    canonical: ["not important", "slightly important", "moderately important", "very important", "extremely important"]
-  },
-  // Severity / priority / urgency — common in IT / clinical / ops data
-  {
-    name: "severity_low_critical",
-    minMatches: 3,
-    canonical: ["low", "medium", "high", "critical"]
-  },
-  // Support/ops priority where the top band is "Urgent" (not "Critical").
-  // Distinct catalog entry so the subset check passes for {Low,Medium,High,
-  // Urgent} (the city_311 case where the LLM otherwise invented a generic
-  // Critical/High/Normal/Low taxonomy because no orderedDomain shipped).
-  {
-    name: "severity_low_urgent",
-    minMatches: 3,
-    canonical: ["low", "medium", "high", "urgent"]
-  },
-  {
-    name: "severity_none_critical",
-    minMatches: 3,
-    canonical: ["none", "mild", "moderate", "severe", "critical"]
-  },
-  {
-    name: "priority_p4_p1",
-    minMatches: 3,
-    canonical: ["p4", "p3", "p2", "p1", "p0"]
-  },
-  // Jira-style issue priority (Blocker highest).
-  {
-    name: "severity_trivial_blocker",
-    minMatches: 3,
-    canonical: ["trivial", "minor", "major", "critical", "blocker"]
-  },
-  {
-    name: "severity_minor_severe",
-    minMatches: 3,
-    canonical: ["minor", "moderate", "major", "severe"]
-  },
-  // Generic magnitude / confidence bands (two spellings of the mid value:
-  // 'medium' vs 'moderate' — separate patterns so the subset check is exact).
-  {
-    name: "magnitude5_medium",
-    minMatches: 3,
-    canonical: ["very low", "low", "medium", "high", "very high"]
-  },
-  {
-    name: "magnitude5_moderate",
-    minMatches: 3,
-    canonical: ["very low", "low", "moderate", "high", "very high"]
-  },
-  // Speed
-  {
-    name: "speed5",
-    minMatches: 3,
-    canonical: ["very slow", "slow", "moderate", "fast", "very fast"]
-  },
-  // Temperature (qualitative)
-  {
-    name: "temperature6",
-    minMatches: 3,
-    canonical: ["freezing", "cold", "cool", "mild", "warm", "hot"]
-  },
-  // Skill / experience ladder
-  {
-    name: "experience6",
-    minMatches: 3,
-    canonical: ["novice", "beginner", "intermediate", "advanced", "expert", "master"]
-  },
-  // Membership / loyalty tiers (metal ladder)
-  {
-    name: "tier_metal",
-    minMatches: 3,
-    canonical: ["bronze", "silver", "gold", "platinum", "diamond"]
-  },
-  // T-shirt sizes — letter form. Single letters are short/ambiguous, so
-  // require 4 anchors to fire (keeps {M,F} gender / {A,B} groups from
-  // tripping it).
-  {
-    name: "tshirt_letter_sizes",
-    minMatches: 4,
-    canonical: ["xxs", "xs", "s", "m", "l", "xl", "xxl", "xxxl"]
-  },
-  // T-shirt sizes — word form.
-  {
-    name: "tshirt_word_sizes",
-    minMatches: 3,
-    canonical: ["extra small", "small", "medium", "large", "extra large"]
-  },
-  // NPS respondent bands
-  {
-    name: "nps_bands",
-    minMatches: 2,
-    canonical: ["detractor", "passive", "promoter"]
-  },
-  // Likelihood / probability bands
-  {
-    name: "likelihood5",
-    minMatches: 3,
-    canonical: ["very unlikely", "unlikely", "neutral", "likely", "very likely"]
-  },
-  // Educational levels (one common ladder)
-  {
-    name: "education",
-    minMatches: 3,
-    canonical: ["none", "primary", "secondary", "bachelors", "masters", "doctoral"]
-  },
-  // Grade letters — A best → F worst. Single letters are short; we require
-  // 3 of 5 to fire to keep false-positive risk low.
-  {
-    name: "grades_a_to_f",
-    minMatches: 3,
-    canonical: ["a", "b", "c", "d", "f"]
-  },
-  {
-    name: "grades_a_to_f_plusminus",
-    minMatches: 4,
-    canonical: ["a+", "a", "a-", "b+", "b", "b-", "c+", "c", "c-", "d+", "d", "d-", "f"]
-  }
-];
-var SYNONYMS = {
-  // frequency5: never / rarely / sometimes / often / always
-  "seldom": "rarely",
-  "infrequently": "rarely",
-  "hardly ever": "rarely",
-  "occasionally": "sometimes",
-  "periodically": "sometimes",
-  "now and then": "sometimes",
-  "frequently": "often",
-  "frequent": "often",
-  "regularly": "often",
-  "commonly": "often",
-  "usually": "often",
-  "constantly": "always",
-  "every time": "always",
-  "all the time": "always",
-  "consistently": "always",
-  "continually": "always",
-  // likert5_quality: poor / fair / good / very good / excellent
-  "bad": "poor",
-  "weak": "poor",
-  "subpar": "poor",
-  "mediocre": "fair",
-  "passable": "fair",
-  "so so": "fair",
-  "decent": "good",
-  "solid": "good",
-  "outstanding": "excellent",
-  "superb": "excellent",
-  "exceptional": "excellent",
-  "stellar": "excellent",
-  // likert5_satisfaction
-  "unsatisfied": "dissatisfied",
-  "unhappy": "dissatisfied",
-  "displeased": "dissatisfied",
-  "happy": "satisfied",
-  "content": "satisfied",
-  "pleased": "satisfied",
-  "delighted": "very satisfied",
-  "highly satisfied": "very satisfied",
-  "extremely satisfied": "very satisfied",
-  "highly dissatisfied": "very dissatisfied",
-  "extremely dissatisfied": "very dissatisfied",
-  // agreement
-  "neither": "neutral",
-  "undecided": "neutral",
-  "no opinion": "neutral",
-  "neither agree nor disagree": "neutral",
-  "completely agree": "strongly agree",
-  "totally agree": "strongly agree",
-  "completely disagree": "strongly disagree",
-  "totally disagree": "strongly disagree",
-  // likelihood5
-  "highly unlikely": "very unlikely",
-  "extremely unlikely": "very unlikely",
-  "highly likely": "very likely",
-  "extremely likely": "very likely",
-  "almost certain": "very likely",
-  // education ladder
-  "bachelor": "bachelors",
-  "bachelor's": "bachelors",
-  "undergraduate": "bachelors",
-  "bachelor degree": "bachelors",
-  // bare "master" is intentionally OMITTED — it is the experience6 canonical
-  // (skill level), so it must not be remapped to the education "masters".
-  "master's": "masters",
-  "graduate": "masters",
-  "master degree": "masters",
-  "doctorate": "doctoral",
-  "phd": "doctoral"
-};
-var CANONICAL_SET = (() => {
-  const s = /* @__PURE__ */ new Set();
-  for (const p of PATTERNS) for (const c of p.canonical) s.add(normalize(c));
-  return s;
-})();
-var SYNONYM_TO_CANON = (() => {
-  const m = /* @__PURE__ */ new Map();
-  for (const [syn, canon] of Object.entries(SYNONYMS)) {
-    const ns = normalize(syn);
-    if (CANONICAL_SET.has(ns) || m.has(ns)) continue;
-    m.set(ns, normalize(canon));
-  }
-  return m;
-})();
-function resolveCanon(norm) {
-  return SYNONYM_TO_CANON.get(norm) ?? norm;
-}
-var ORDINAL_NAME_TOKENS = /* @__PURE__ */ new Set([
-  // temporal
-  "hour",
-  "hr",
-  "day",
-  "dow",
-  "dom",
-  "weekday",
-  "week",
-  "wk",
-  "woy",
-  "month",
-  "mth",
-  "quarter",
-  "qtr",
-  "year",
-  "yr",
-  "semester",
-  "trimester",
-  "decade",
-  "period",
-  "fiscal",
-  "fy",
-  // rank / level / scale
-  "rank",
-  "level",
-  "lvl",
-  "tier",
-  "grade",
-  "band",
-  "decile",
-  "percentile",
-  "quartile",
-  "quintile",
-  "score",
-  "rating",
-  "stars",
-  "step",
-  "stage",
-  "phase",
-  "round",
-  "wave",
-  "episode",
-  "chapter",
-  "age",
-  "cohort",
-  "generation",
-  "seniority",
-  "position",
-  "sequence",
-  "seq",
-  "priority"
-]);
-function tokenizeName(name) {
-  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-./]+/g, " ").toLowerCase().split(/\s+/).filter((t) => t.length > 0);
-}
-function isOrdinalFriendlyName(name) {
-  if (!name) return false;
-  for (const tok of tokenizeName(name)) {
-    if (ORDINAL_NAME_TOKENS.has(tok)) return true;
-  }
-  return false;
-}
-function normalize(s) {
-  return s.toLowerCase().replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim();
-}
-function buildCalendarDict(entries) {
-  const m = /* @__PURE__ */ new Map();
-  for (const [forms, pos] of entries) {
-    for (const f of forms) m.set(normalize(f), pos);
-  }
-  return m;
-}
-var CALENDAR_FAMILIES = [
-  // Weekday, Mon→Sun (ISO order, matches the server's DataShapeAdvisor R9).
-  { name: "weekday_mon_sun", minMatches: 4, dict: buildCalendarDict([
-    [["monday", "mon"], 0],
-    [["tuesday", "tue", "tues"], 1],
-    [["wednesday", "wed", "weds"], 2],
-    [["thursday", "thu", "thur", "thurs", "thr"], 3],
-    [["friday", "fri"], 4],
-    [["saturday", "sat"], 5],
-    [["sunday", "sun"], 6]
-  ]) },
-  // Month, Jan→Dec.
-  { name: "month_jan_dec", minMatches: 4, dict: buildCalendarDict([
-    [["january", "jan"], 0],
-    [["february", "feb"], 1],
-    [["march", "mar"], 2],
-    [["april", "apr"], 3],
-    [["may"], 4],
-    [["june", "jun"], 5],
-    [["july", "jul"], 6],
-    [["august", "aug"], 7],
-    [["september", "sep", "sept"], 8],
-    [["october", "oct"], 9],
-    [["november", "nov"], 10],
-    [["december", "dec"], 11]
-  ]) },
-  // Quarter, Q1→Q4. Power BI emits 'Qtr 1'/'Qtr 2'/... (the Marimekko genesis).
-  { name: "quarter_q1_q4", minMatches: 3, dict: buildCalendarDict([
-    [["q1", "qtr 1", "qtr1", "quarter 1", "q 1"], 0],
-    [["q2", "qtr 2", "qtr2", "quarter 2", "q 2"], 1],
-    [["q3", "qtr 3", "qtr3", "quarter 3", "q 3"], 2],
-    [["q4", "qtr 4", "qtr4", "quarter 4", "q 4"], 3]
-  ]) }
-];
-var _localeCalCache = {};
-function localeCalendarDicts(locale) {
-  const key = locale || "";
-  if (!key) return { weekday: /* @__PURE__ */ new Map(), month: /* @__PURE__ */ new Map() };
-  const cached = _localeCalCache[key];
-  if (cached) return cached;
-  const weekday = /* @__PURE__ */ new Map();
-  const month = /* @__PURE__ */ new Map();
-  const add = (map, s, pos) => {
-    const n = normalize(s);
-    if (n) map.set(n, pos);
-    const nd = normalize(s.replace(/\./g, ""));
-    if (nd && nd !== n) map.set(nd, pos);
-  };
-  try {
-    const wLong = new Intl.DateTimeFormat(key, { weekday: "long" });
-    const wShort = new Intl.DateTimeFormat(key, { weekday: "short" });
-    for (let i = 0; i < 7; ++i) {
-      const d = new Date(Date.UTC(2024, 0, 1 + i));
-      add(weekday, wLong.format(d), i);
-      add(weekday, wShort.format(d), i);
-    }
-    const mLong = new Intl.DateTimeFormat(key, { month: "long" });
-    const mShort = new Intl.DateTimeFormat(key, { month: "short" });
-    for (let m = 0; m < 12; ++m) {
-      const d = new Date(Date.UTC(2020, m, 15));
-      add(month, mLong.format(d), m);
-      add(month, mShort.format(d), m);
-    }
-  } catch {
-  }
-  const result = { weekday, month };
-  _localeCalCache[key] = result;
-  return result;
-}
-function mergeDicts(base, extra) {
-  if (extra.size === 0) return base;
-  const m = new Map(base);
-  for (const [k, v] of extra) if (!m.has(k)) m.set(k, v);
-  return m;
-}
-function detectCalendarOrdinal(normIndex, locale) {
-  const loc = localeCalendarDicts(locale);
-  for (const fam of CALENDAR_FAMILIES) {
-    const dict = fam.name === "weekday_mon_sun" ? mergeDicts(fam.dict, loc.weekday) : fam.name === "month_jan_dec" ? mergeDicts(fam.dict, loc.month) : fam.dict;
-    let allInDict = true;
-    const byPos = /* @__PURE__ */ new Map();
-    for (const [norm, original] of normIndex) {
-      const pos = dict.get(norm);
-      if (pos === void 0) {
-        allInDict = false;
-        break;
-      }
-      if (!byPos.has(pos)) byPos.set(pos, original);
-    }
-    if (!allInDict) continue;
-    if (byPos.size < fam.minMatches) continue;
-    const orderedDomain = [...byPos.entries()].sort((a, b) => a[0] - b[0]).map((e) => e[1]);
-    return { pattern: fam.name, orderedDomain };
-  }
-  return null;
-}
-function buildNormalizedIndex(rawValues) {
-  const out = /* @__PURE__ */ new Map();
-  for (const v of rawValues) {
-    if (v === null || v === void 0) continue;
-    const s = String(v);
-    if (s.length === 0) continue;
-    const n = normalize(s);
-    if (!out.has(n)) out.set(n, s);
-  }
-  return out;
-}
-var MAX_SAFE_DISTINCT = 15;
-var MAX_CODE_LEN = 10;
-var ALWAYS_SAFE_TOKENS = (() => {
-  const literal = [
-    // sizes
-    "xxs",
-    "xs",
-    "s",
-    "sm",
-    "small",
-    "m",
-    "med",
-    "medium",
-    "l",
-    "lg",
-    "large",
-    "xl",
-    "xlarge",
-    "xxl",
-    "xxxl",
-    "2xl",
-    "3xl",
-    "4xl",
-    // boolean / flags / fillers
-    "y",
-    "n",
-    "yes",
-    "no",
-    "t",
-    "f",
-    "true",
-    "false",
-    "na",
-    "n/a",
-    "n a",
-    "none",
-    "null",
-    "unknown",
-    "other",
-    "all",
-    "both",
-    // magnitude / severity words (safe standalone even when Tier A doesn't fire)
-    "low",
-    "medium",
-    "med",
-    "high",
-    "very low",
-    "very high",
-    "minimal",
-    "critical",
-    "urgent"
-  ];
-  const set = new Set(literal.map(normalize));
-  for (const fam of CALENDAR_FAMILIES) {
-    for (const k of fam.dict.keys()) set.add(k);
-  }
-  return set;
-})();
-function isCodeStructured(raw) {
-  const s = raw.trim();
-  if (s.length === 0 || s.length > MAX_CODE_LEN) return false;
-  const letters = (s.match(/\p{L}/gu) || []).length;
-  if (letters > 1) return false;
-  return /\p{Nd}/u.test(s);
-}
-function safeDistinctValuesToShip(rawDistinct) {
-  if (!rawDistinct || rawDistinct.length === 0) return null;
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const v of rawDistinct) {
-    if (v === null || v === void 0) continue;
-    const s = String(v);
-    if (seen.has(s)) continue;
-    const norm = normalize(s);
-    const safe = norm === "" || ALWAYS_SAFE_TOKENS.has(norm) || isCodeStructured(s);
-    if (!safe) return null;
-    seen.add(s);
-    out.push(s);
-    if (out.length > MAX_SAFE_DISTINCT) return null;
-  }
-  return out.length > 0 ? out : null;
-}
-function detectOrdinalDomain(rawValues, locale) {
-  if (!rawValues || rawValues.length < 2) return null;
-  const normIndex = buildNormalizedIndex(rawValues);
-  if (normIndex.size < 2) return null;
-  const canonIndex = /* @__PURE__ */ new Map();
-  for (const [norm, original] of normIndex) {
-    const canon = resolveCanon(norm);
-    if (!canonIndex.has(canon)) canonIndex.set(canon, original);
-  }
-  let best = null;
-  for (const pattern of PATTERNS) {
-    const orderedDomain = [];
-    for (const canonForm of pattern.canonical) {
-      const raw = canonIndex.get(canonForm);
-      if (raw !== void 0) orderedDomain.push(raw);
-    }
-    if (orderedDomain.length < pattern.minMatches) continue;
-    const patternSet = new Set(pattern.canonical);
-    let allUserValuesInPattern = true;
-    for (const normUserValue of normIndex.keys()) {
-      if (!patternSet.has(resolveCanon(normUserValue))) {
-        allUserValuesInPattern = false;
-        break;
-      }
-    }
-    if (!allUserValuesInPattern) continue;
-    let isBetter;
-    if (best === null) isBetter = true;
-    else if (orderedDomain.length > best.matched) isBetter = true;
-    else if (orderedDomain.length === best.matched && pattern.canonical.length < best.pattern.canonical.length) isBetter = true;
-    else isBetter = false;
-    if (isBetter) {
-      best = { pattern, matched: orderedDomain.length, orderedDomain };
-    }
-  }
-  if (best) return { pattern: best.pattern.name, orderedDomain: best.orderedDomain };
-  return detectCalendarOrdinal(normIndex, locale);
-}
-
-export {
-  isOrdinalFriendlyName,
-  safeDistinctValuesToShip,
-  detectOrdinalDomain
-};
-//# sourceMappingURL=chunk-VHWC3THS.mjs.map