@ham2k/extension-sdk 0.1.0 → 0.3.0

package/dist/referenceActivity.js

@@ -6,9 +6,39 @@ async function hostApi() {
 }
 const NEARBY_DELTA = 1.5;
 const MAX_SUGGESTIONS = 30;
+const learnedPrefixes = /* @__PURE__ */ new Map();
+async function learnedReferencePrefix(category, entityPrefix, fallback) {
+  const cacheKey = `${category}:${entityPrefix}`;
+  const cached = learnedPrefixes.get(cacheKey);
+  if (cached) return cached;
+  const host = await hostApi();
+  let rows = [];
+  try {
+    rows = await host.dbLookupSelectAll(category, "", entityPrefix);
+  } catch (e) {
+    host.log(`${category}: prefix lookup failed for ${entityPrefix}: ${e}`);
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const prefix = row.key.split("-")[0];
+    if (prefix) counts.set(prefix, (counts.get(prefix) ?? 0) + 1);
+  }
+  let best;
+  for (const [prefix, count] of counts) {
+    if (best === void 0 || count > (counts.get(best) ?? 0)) best = prefix;
+  }
+  if (best === void 0) return fallback;
+  learnedPrefixes.set(cacheKey, best);
+  return best;
+}
 function normalize(ref) {
   return (ref ?? "").toUpperCase().trim();
 }
+function looksLikeReference(text, referenceRegex) {
+  if (referenceRegex.test(text)) return true;
+  if (/\s/.test(text)) return false;
+  return /[0-9]/.test(text) || /[-/]/.test(text);
+}
 function refsOfType(container, type) {
   return (container.refs ?? []).filter((r) => r.type === type && r.ref);
 }
@@ -36,8 +66,22 @@ function referenceActivity(config) {
       return null;
     }
   }
+  function undecorated(ref, reference, name) {
+    return {
+      ...ref,
+      ref: reference,
+      name,
+      program,
+      label: void 0,
+      shortLabel: void 0,
+      grid: void 0,
+      lat: void 0,
+      lon: void 0,
+      location: void 0
+    };
+  }
   function decorate(ref, reference, row, unknown) {
-    if (!row?.name) return { ...ref, ref: reference, name: unknown, program };
+    if (!row?.name) return undecorated(ref, reference, unknown);
     const data = row.data ?? {};
     return {
       ...ref,
@@ -52,6 +96,16 @@ function referenceActivity(config) {
       shortLabel: `${config.label} ${reference}`
     };
   }
+  async function refListInput(refType, args, ctx) {
+    const extras = config.refInput ? await config.refInput(args, ctx) : {};
+    return {
+      kind: "refList",
+      refType,
+      placeholder: extras.placeholder ?? config.placeholder,
+      pattern: config.referenceRegex.source,
+      transforms: extras.transforms ?? config.transforms
+    };
+  }
   const refHandler = {
     async validateRef({ ref }, _ctx) {
       const normalized = normalize(ref.ref);
@@ -61,7 +115,7 @@ function referenceActivity(config) {
       const t = config.tFor(ctx);
       const reference = normalize(ref.ref);
       if (!config.referenceRegex.test(reference)) {
-        return { ...ref, ref: reference, name: t("invalidReference") };
+        return undecorated(ref, reference, t("invalidReference"));
       }
       return decorate(ref, reference, await lookupReference(reference), t("unknownReference"));
     },
@@ -97,7 +151,7 @@ function referenceActivity(config) {
     }
   };
   const activityHook = {
-    async operationControls(_args, ctx) {
+    async operationControls({ operation }, ctx) {
       return [
         {
           key: `${config.key}/activation`,
@@ -107,12 +161,7 @@ function referenceActivity(config) {
           order: 10,
           optionType: "optional",
           allowsMultiple,
-          input: {
-            kind: "refList",
-            refType: config.activationType,
-            placeholder: config.placeholder,
-            pattern: config.referenceRegex.source
-          }
+          input: await refListInput(config.activationType, { operation, side: "activation" }, ctx)
         }
       ];
     },
@@ -122,7 +171,7 @@ function referenceActivity(config) {
     // on whether the operation is activating — both write the same hunting
     // refs, and POTA's HaLo port already settled on the single control.
     ...config.huntingType ? {
-      async loggingControls(_args, ctx) {
+      async loggingControls({ operation, qso }, ctx) {
         return [
           {
             key: `${config.key}/hunter`,
@@ -132,17 +181,12 @@ function referenceActivity(config) {
             order: 10,
             optionType: "optional",
             allowsMultiple: true,
-            input: {
-              kind: "refList",
-              refType: config.huntingType,
-              placeholder: config.placeholder,
-              pattern: config.referenceRegex.source
-            }
+            input: await refListInput(config.huntingType, { operation, qso, side: "hunting" }, ctx)
           }
         ];
       }
     } : {},
-    async suggest({ location, searchTerm }, _ctx) {
+    async suggest({ location, searchTerm, scoped }, ctx) {
       const host = await hostApi();
       const rows = searchTerm ? await host.dbLookupSelectAll(category, searchTerm) : location ? await host.dbLookupSelectByLocation(category, location.lat, location.lon, NEARBY_DELTA) : [];
       const withDistance = rows.map((row) => ({
@@ -152,7 +196,7 @@ function referenceActivity(config) {
       if (!searchTerm) {
         withDistance.sort((a, b) => (a.distance ?? Infinity) - (b.distance ?? Infinity));
       }
-      return withDistance.slice(0, MAX_SUGGESTIONS).map(({ row, distance }) => {
+      const suggestions = withDistance.slice(0, MAX_SUGGESTIONS).map(({ row, distance }) => {
         const data = row.data ?? {};
         return {
           type: config.activationType,
@@ -170,6 +214,31 @@ function referenceActivity(config) {
           allowsMultiple
         };
       });
+      const typed = scoped ? normalize(searchTerm) : "";
+      if (typed && looksLikeReference(typed, config.referenceRegex) && !suggestions.some((s) => s.ref === typed)) {
+        const t = config.tFor(ctx);
+        const valid = config.referenceRegex.test(typed);
+        const row = valid ? await lookupReference(typed) : null;
+        const data = row?.data ?? {};
+        const name = row?.name || (valid ? t("unknownReference") : t("invalidReference"));
+        if (suggestions.length >= MAX_SUGGESTIONS) suggestions.pop();
+        suggestions.unshift({
+          type: config.activationType,
+          ref: typed,
+          name,
+          grid: data.grid,
+          lat: row?.lat,
+          lon: row?.lon,
+          location: data.location,
+          program,
+          label: `${config.label} ${typed}: ${name}`,
+          shortLabel: `${config.label} ${typed}`,
+          distance: void 0,
+          relevance: 1,
+          allowsMultiple
+        });
+      }
+      return suggestions;
     }
   };
   function activationFields(operation) {
@@ -222,5 +291,7 @@ function referenceActivity(config) {
   return { refHandler, activityHook, adifFieldsHook, adifImportHook };
 }
 export {
+  learnedReferencePrefix,
+  looksLikeReference,
   referenceActivity
 };

package/dist/scoring.js

@@ -16,6 +16,9 @@ function startAtMillisOf(qso) {
   const at = qso.startAtMillis;
   return typeof at === "number" ? at : 0;
 }
+function candidateAsOfNow(qso) {
+  return typeof qso.startAtMillis === "number" ? qso : { ...qso, startAtMillis: Date.now() };
+}
 function contestScorer(scorer, options = {}) {
   const scope = options.scope ?? "always";
   const scopedRefTypes = typeof scope === "object" && Array.isArray(scope.refTypes) ? scope.refTypes : void 0;
@@ -118,10 +121,10 @@ function contestScorer(scorer, options = {}) {
     async scoreQso(args, ctx) {
       const sheet = await liveScoresheet(args, ctx, args.excludeUuid);
       const { score } = scorer.scoreQso(
-        { scoresheet: sheet, qso: args.qso, operation: args.operation, ref: args.ref, isNewDay: false },
+        { scoresheet: sheet, qso: candidateAsOfNow(args.qso), operation: args.operation, ref: args.ref, isNewDay: false },
         ctx
       );
-      return { notices: score.notices ?? [], alerts: score.alerts ?? [] };
+      return { notices: score.notices ?? [], alerts: score.alerts ?? [], ...score.dupe !== void 0 && { dupe: score.dupe } };
     },
     /// The same live judgement as `scoreQso`, for many candidates at once —
     /// the Spots Panel annotating every spot on screen. The log is folded ONCE
@@ -141,14 +144,18 @@ function contestScorer(scorer, options = {}) {
         const { score } = scorer.scoreQso(
           {
             scoresheet: copyCheckpoint(base),
-            qso: candidate.qso,
+            qso: candidateAsOfNow(candidate.qso),
             operation: args.operation,
             ref: args.ref,
             isNewDay: false
           },
           ctx
         );
-        result[candidate.key] = { notices: score.notices ?? [], alerts: score.alerts ?? [] };
+        result[candidate.key] = {
+          notices: score.notices ?? [],
+          alerts: score.alerts ?? [],
+          ...score.dupe !== void 0 && { dupe: score.dupe }
+        };
       }
       return result;
     }

package/dist/segments.js

@@ -0,0 +1,17 @@
+function operationForQso(base, qso, segments) {
+  if (!segments || segments.length === 0) return base;
+  const at = typeof qso.startAtMillis === "number" ? qso.startAtMillis : 0;
+  let effective = base;
+  for (const segment of segments) {
+    if (segment.fromMillis > at) break;
+    effective = segment.operation;
+  }
+  return effective;
+}
+function segmentsWith(segments, transform) {
+  return segments?.map((segment) => ({ ...segment, operation: transform(segment.operation) }));
+}
+export {
+  operationForQso,
+  segmentsWith
+};

package/dist/templateContext.js

@@ -26,6 +26,10 @@ function opValues(operation, extra = {}) {
   return {
     ...atMillis > 0 ? dateValues(atMillis) : { date: "", dateCompact: "", time: "", at: "" },
     station,
+    // `call` says the same thing, for symmetry with `qso.call` — the name an
+    // operator writing a CW message reaches for first; without it,
+    // `{{ op.call }}` renders empty with nothing to say why.
+    call: station,
     // Deduped, like halo_core's `Operation.stationCalls`: "N0DEV, N0DEV" is a
     // typo, and a template fanning out over this would otherwise repeat
     // itself once per typo.