@ham2k/extension-sdk 1.12.2 → 1.12.4

package/dist/activityExports.js

@@ -1,11 +1,44 @@
 import { exportTypeDefinition } from "./exportSettings.js";
 import { exportFilename, startMillisOf } from "./exportNames.js";
-import { segmentsWith } from "./segments.js";
+import { operationForQso, segmentsWith } from "./segments.js";
+import { utcDate } from "./templateContext.js";
 import { createCachedTranslator } from "./i18n.js";
 import en from "./i18n/activityExports.en.json";
 import es from "./i18n/activityExports.es.json";
 const tFor = createCachedTranslator({ en: { translation: en }, es: { translation: es } });
 const SEPARATOR = ":";
+const DAY_MARK = "@";
+const DAY_LENGTH = "YYYY-MM-DD".length;
+function byUtcDay(qsos) {
+  const timed = /* @__PURE__ */ new Map();
+  const timeless = [];
+  for (const qso of qsos) {
+    const millis = Number(qso.startAtMillis ?? 0);
+    if (!(millis > 0)) {
+      timeless.push(qso);
+      continue;
+    }
+    const day = utcDate(millis);
+    const list = timed.get(day);
+    if (list) list.push(qso);
+    else timed.set(day, [qso]);
+  }
+  const days = [...timed.keys()].filter((day) => timed.get(day).some((qso) => !qso.deleted)).sort();
+  return new Map(days.map((day, i) => [day, i === 0 ? [...timeless, ...timed.get(day)] : timed.get(day)]));
+}
+function activeQsos(operation, qsos, segments, activationType, ref) {
+  if (!segments || segments.length === 0) return qsos;
+  const refsAt = (qso) => refsOfType(operationForQso(operation, qso, segments), activationType);
+  const segmentRefs = segments.map((segment) => refsOfType(segment.operation, activationType).map((r) => r.ref));
+  const known = new Set(segmentRefs.flat());
+  if (known.has(ref)) {
+    const own = qsos.filter((qso) => refsAt(qso).some((r) => r.ref === ref));
+    const movedHere = known.size > 1 && segmentRefs.slice(1).some((refs) => refs.includes(ref));
+    if (own.length > 0 || movedHere) return own;
+  }
+  const active = qsos.filter((qso) => refsAt(qso).length > 0);
+  return active.length > 0 ? active : qsos;
+}
 function refsOfType(container, type) {
   const refs = container.refs ?? [];
   return refs.filter((r) => r && r.type === type && typeof r.ref === "string" && r.ref.length > 0).map((r) => ({ ref: r.ref, name: typeof r.name === "string" ? r.name : void 0 }));
@@ -34,10 +67,10 @@ function activityExportHook(rules) {
         }
       ];
     },
-    async suggestExportOptions({ operation, qsos, compactFilenames }, ctx) {
+    async suggestExportOptions({ operation, qsos, segments, compactFilenames }, ctx) {
       const refs = refsOfType(operation, rules.activationType);
       const t = tFor(ctx);
-      return refs.map((ref) => ({
+      const whole = (ref) => ({
         exportType: `${rules.activationType}-adif`,
         templateData: { ref: ref.ref, refName: ref.name ?? "", activity: rules.label },
         exportKey: `${prefix}${SEPARATOR}${ref.ref}`,
@@ -57,15 +90,44 @@ function activityExportHook(rules) {
         // being activated.
         refType: rules.activationType,
         ref: ref.ref
-      }));
+      });
+      const daysOf = (ref) => byUtcDay(activeQsos(operation, qsos ?? [], segments, rules.activationType, ref));
+      const split = rules.splitByUtcDay ? refs.map((ref) => ({ ref, days: daysOf(ref.ref) })) : [];
+      if (split.some(({ days }) => days.size > 1)) {
+        return split.flatMap(
+          ({ ref, days }) => days.size === 0 ? [whole(ref)] : [...days].map(([day, dayQsos]) => ({
+            exportType: `${rules.activationType}-adif`,
+            // The day rides as the filename template's modifier: a template
+            // is dated by the whole log's first contact, and two files that
+            // differed only in their contents would overwrite each other.
+            templateData: { ref: ref.ref, refName: ref.name ?? "", activity: rules.label, modifier: day },
+            exportKey: `${prefix}${DAY_MARK}${day}${SEPARATOR}${ref.ref}`,
+            format: "adif",
+            label: t("adifForRefOnDay", { program: rules.label, ref: ref.ref, day }),
+            // Dated by the day's own first contact, which the file is.
+            filename: filenameFor(operation, dayQsos, ref.ref, compactFilenames),
+            // The day's own count: the operator checking that a day reached
+            // its threshold needs that day's number, not the whole log's.
+            qsoCount: dayQsos.filter((qso) => !qso.deleted).length,
+            icon: rules.icon,
+            selectedByDefault: true,
+            refType: rules.activationType,
+            ref: ref.ref
+          }))
+        );
+      }
+      return refs.map(whole);
     },
     async generateExport(args, ctx) {
       const exportType = String(args.exportType ?? "");
       const exportKey = String(args.exportKey ?? "");
-      if (exportType !== `${rules.activationType}-adif` || !exportKey.startsWith(`${prefix}${SEPARATOR}`)) {
+      const dayed = exportKey.startsWith(`${prefix}${DAY_MARK}`) && exportKey.charAt(prefix.length + DAY_MARK.length + DAY_LENGTH) === SEPARATOR;
+      const day = dayed ? exportKey.slice(prefix.length + DAY_MARK.length, prefix.length + DAY_MARK.length + DAY_LENGTH) : void 0;
+      const head = dayed ? prefix.length + DAY_MARK.length + DAY_LENGTH : prefix.length;
+      if (exportType !== `${rules.activationType}-adif` || !(dayed || exportKey.startsWith(`${prefix}${SEPARATOR}`))) {
         throw new Error(`${rules.key}: unknown export type/key '${exportType}' / '${exportKey}'`);
       }
-      const wanted = exportKey.slice(prefix.length + SEPARATOR.length);
+      const wanted = exportKey.slice(head + SEPARATOR.length);
       if (!refsOfType(args.operation, rules.activationType).some((r) => r.ref === wanted)) {
         throw new Error(`${rules.key}: operation has no ${rules.activationType} reference '${wanted}'`);
       }
@@ -75,9 +137,13 @@ function activityExportHook(rules) {
           (r) => r?.type !== rules.activationType || r?.ref === wanted
         )
       });
+      const qsos = day === void 0 ? args.qsos : byUtcDay(args.qsos ?? []).get(day) ?? [];
+      if (day !== void 0 && !qsos.some((qso) => !qso.deleted)) {
+        throw new Error(`${rules.key}: no contacts on ${day} for ${wanted}`);
+      }
       const content = await adifForExport({
         operation: claimOnly(args.operation),
-        qsos: args.qsos,
+        qsos,
         segments: segmentsWith(args.segments, claimOnly),
         includePrivateData: args.includePrivateData,
         includeLookupData: args.includeLookupData,
@@ -89,7 +155,7 @@ function activityExportHook(rules) {
         operatorFallback: rules.operatorFallback
       });
       return {
-        filename: filenameFor(args.operation, args.qsos, wanted, args.compactFilenames),
+        filename: filenameFor(args.operation, qsos, wanted, args.compactFilenames),
         mimeType: "text/plain",
         content
       };

package/dist/activityScoring.js

@@ -34,6 +34,7 @@ function activityScorer(rules) {
     return typeof rule === "function" ? rule(activatedRefs) : rule;
   }
   const freshRefRescuesActivation = rules.freshRefRescuesActivation ?? true;
+  const distinctCallsPerDay = rules.distinctCallsPerDay ?? false;
   const tracksActivation = rules.tracksActivation ?? true;
   const tracksOperators = rules.tracksOperators ?? true;
   const allowsMultiple = rules.allowsMultipleReferences ?? false;
@@ -125,16 +126,22 @@ function activityScorer(rules) {
       const now = { day, band, mode, refs: huntedRefs };
       const priors = sheet.workedByCall[call] ?? [];
       const verdict = judge(priors, now);
-      const isDupe = verdict === "duplicate";
+      let isDupe = verdict === "duplicate";
       const freshRefOnly = verdict === "ref" && !freshRefRescuesActivation;
-      const activationCredit = freshRefOnly ? 0 : activationValue;
+      let activationCredit = freshRefOnly ? 0 : activationValue;
+      if (distinctCallsPerDay && activationCredit > 0 && !isDupe) {
+        const days = sheet.activationCallDays ?? (sheet.activationCallDays = {});
+        activationCredit = days[call] === day ? 0 : 1;
+        days[call] = day;
+        if (activationCredit + huntingValue === 0 && !verdict) isDupe = true;
+      }
       const hasStake = activationValue + huntingValue > 0;
       const score = { value: isDupe ? 0 : activationCredit + huntingValue };
       if (!hasStake) {
       } else if (isDupe) {
         score.dupe = true;
         score.alerts = ["duplicate"];
-      } else if (verdict) {
+      } else if (verdict && verdict !== "duplicate") {
         score.notices = [NOTICE_KEYS[verdict]];
       } else if (priors.length > 0 && score.value > 0 && freshRefRescuesActivation) {
         score.dupe = false;

package/dist/i18n/activityExports.en.json

@@ -1,4 +1,5 @@
 {
   "adifForRef": "ADIF for {{program}} {{ref}}",
+  "adifForRefOnDay": "ADIF for {{program}} {{ref}} on {{day}}",
   "adifForHunter": "{{program}} Hunter Log"
 }

package/dist/i18n/activityExports.es.json

@@ -1,4 +1,5 @@
 {
   "adifForRef": "ADIF para {{program}} {{ref}}",
+  "adifForRefOnDay": "ADIF para {{program}} {{ref}} del {{day}}",
   "adifForHunter": "Registro de Cazador {{program}}"
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-// @ham2k/extension-sdk 1.12.2
+// @ham2k/extension-sdk 1.12.4
 /** Experimental v1 panel scene contract. All coordinates are in the scene's viewBox. */
 export interface PanelScene {
 	version: 1;
@@ -175,10 +175,18 @@ export interface PanelSceneSpectrum {
 	display?: "both" | "pan" | "waterfall";
 	/**
 	 * Which way the waterfall moves; the panadapter sits on the side it comes from. Frequency rises
-	 * left to right for `down` (the default) and `up`, bottom to top for `right` and `left`. Text
-	 * stays upright; offsets and `corner`s are measured as if flowing down.
+	 * as `rising` says: by default left to right for `down` (the default) and `up`, bottom to top for
+	 * `right` and top to bottom for `left` — `down` turned a quarter either way. Text stays upright;
+	 * offsets and `corner`s are measured as if flowing down.
 	 */
 	flow?: "down" | "up" | "right" | "left";
+	/**
+	 * Which way frequency rises, across the `flow`: `right` or `left` for `down` and `up`, `down` or
+	 * `up` for `right` and `left`. Omitted, `right` for `down` and `up`, `up` for `right`, `down` for
+	 * `left`. Offsets, `align` and `corner`s are still measured as if frequency rose to the right.
+	 * Extension API 12; before it, `left` rose bottom to top as `right` does.
+	 */
+	rising?: "right" | "left" | "down" | "up";
 	/** The panadapter's share of the height with `both`, 0.1–0.9. Default 0.4. */
 	split?: number;
 	/** dB added to the radio's own floor. */
@@ -222,7 +230,9 @@ export interface PanelSceneSpectrum {
 	/**
 	 * Hz shown across the control, from the middle of each sweep. A sweep wider than this is cropped
 	 * to it, so a radio whose scope comes in a few widths can be shown at any narrower one — set the
-	 * scope (`setRadioSpectrum`) to the narrowest that covers it. Extension API 7.
+	 * scope (`setRadioSpectrum`) to the narrowest that covers it. Where the radio's `spectrum` says
+	 * `autoSpan`, the app sets the scope itself, wide enough for the widest `span` on screen.
+	 * Extension API 7; `autoSpan` 12.
 	 */
 	span?: PanelSceneSpectrumNumber;
 	/** A click tunes to the nearest multiple of this many Hz. Omitted, wherever it lands. */
@@ -408,6 +418,12 @@ export interface PanelSceneControl extends PanelSceneSpectrum {
 		value: string;
 		to: number;
 	};
+	/**
+	 * A `button` only: a click sends, as the event's `value`, where along the button's longer side it
+	 * landed — 0 at its top or left end, 1 at its bottom or right — so a scale can be clicked at a
+	 * place. Keys and screen readers activate it with no value, as does an app before this. Extension API 12.
+	 */
+	tapAt?: boolean;
 	/**
 	 * 0 to 1, fixed or bound like a layer's. At 0 the control is gone: it takes no clicks,
 	 * keyboard focus or screen-reader node. Anything between is only drawn fainter.
@@ -1099,6 +1115,7 @@ export interface ExportResult {
 export interface ExportOptionsRequest {
 	operation: Record<string, JSONValue>;
 	qsos: Record<string, JSONValue>[];
+	segments?: OperationSegmentPayload[];
 	compactFilenames?: boolean;
 }
 export interface ExportOption {
@@ -2098,13 +2115,24 @@ export interface PanelRadioSpectrum {
 	mode: "center" | "fixed" | null;
 	/** Half the width shown while centered — what the radio's menu shows as ±. */
 	spanHz: number | null;
-	/** The edges while fixed. */
+	/**
+	 * The edges shown: while fixed, and while centred where the radio places its scope apart from the
+	 * dial (a FlexRadio's panadapter, which a retune inside it does not move). Null where the scope
+	 * sits on the dial, `spanHz` either side of it.
+	 */
 	lowHz: number | null;
 	highHz: number | null;
 	refLevelDb: number | null;
 	speed: PanelRadioSpectrumSpeed | null;
 	/** What `setRadioSpectrum` accepts. A span between two is snapped to the nearer. */
 	spansHz: number[];
+	/**
+	 * The app sets the span itself — a sweep it computes, whose width changes nothing on the radio
+	 * (a FlexRadio's) — to the narrowest covering the widest `span` of the spectrum controls shown,
+	 * each cropping its own width. A panel then names its width with `span` and leaves
+	 * `setRadioSpectrum`'s `spanHz` alone, or the panels take turns. Absent before extension API 12.
+	 */
+	autoSpan?: boolean;
 	refMinDb: number;
 	refMaxDb: number;
 	refStepDb: number;
@@ -2423,6 +2451,7 @@ export interface ActivityScoringRules {
 	tracksActivation?: boolean;
 	tracksOperators?: boolean;
 	freshRefRescuesActivation?: boolean;
+	distinctCallsPerDay?: boolean;
 	allowsMultipleReferences?: boolean;
 	uniquePer?: readonly UniqueAxis[];
 	activates?: "daily" | "once";
@@ -2446,6 +2475,7 @@ export type ActivityScoresheet = {
 	dayActivatedQsos: number;
 	dayHuntedQsos: number;
 	dayDuplicates: number;
+	activationCallDays?: Record<string, number>;
 };
 export declare function activityScorer(rules: ActivityScoringRules): ContestScorer<ActivityScoresheet>;
 export interface ActivityExportRules {
@@ -2456,10 +2486,11 @@ export interface ActivityExportRules {
 	icon?: string;
 	includeFieldsFrom?: string[];
 	operatorFallback?: OperatorFallback;
+	splitByUtcDay?: boolean;
 }
 export declare function activityExportHook(rules: ActivityExportRules): {
 	getExportTypes(): Promise<ExportTypeDefinition[]>;
-	suggestExportOptions({ operation, qsos, compactFilenames }: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
+	suggestExportOptions({ operation, qsos, segments, compactFilenames }: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
 	generateExport(args: ExportRequest, ctx: HookContext): Promise<ExportResult>;
 };
 export interface HuntingExportRules {

package/docs/hooks.md

@@ -413,7 +413,7 @@ interface ExportHook {
   suggestExportOptions?(args: ExportOptionsRequest, ctx): Promise<ExportOption[]>
   generateExport(args: ExportRequest, ctx): Promise<ExportResult>
 }
-// ExportOptionsRequest: {operation, qsos, compactFilenames?}
+// ExportOptionsRequest: {operation, qsos, segments?, compactFilenames?}
 // ExportOption: {exportType, exportKey?, format, label, filename?, icon?, color?, refType?, ref?, priority?, selectedByDefault?}
 // ExportRequest: {operation, qsos, segments?, events?, exportType?, exportKey?, compactFilenames?}  — full QSON, one coarse call
 // ExportResult:  {filename, mimeType, content}
@@ -1926,7 +1926,7 @@ the extension. `value` names what it shows and sets.
 
 | Kind | Binds to | Sends | Also takes |
 |---|---|---|---|
-| `button` | — | `activate` | `menu` |
+| `button` | — | `activate` | `menu`, `tapAt` (extension API 12: a click's `value` is where along the button's longer side it landed, 0 at its top or left end to 1 at its bottom or right; a key or screen reader activates it with none) |
 | `slider` | number | `commit` | `min`, `max`, `step`, `discrete`, `hover`, `valueLabels`, `continuous`, `scrollThrough` |
 | `knob` | number | `commit` | `min`, `max`, `step`, `sensitivity`, `invertDrag`, `scrollThrough`, `valueLabels`, `continuous`, `menu`, a second axis (`valueY`, `eventY`, `minY`, `maxY`, `stepY`, `sensitivityY`) |
 | `nativeButton` | — | `activate` | `variant` (`filled`, `tonal`, `outlined`, `text`), `icon`, `menu`; needs `event` or `menu` |
@@ -2104,6 +2104,13 @@ control and takes the fields of `PanelSceneSpectrum` in the SDK:
   (`both`, `pan`, `waterfall`), `split`, and `flow` — which way the waterfall
   moves (`down`, `up`, `right`, `left`), the panadapter on the side it comes
   from.
+- `rising` (extension API 12): which way frequency increases, across the
+  flow — `right` or `left` for `down` and `up`, `down` or `up` for `right` and
+  `left`; one along the flow is refused. Omitted, each flow is `down` turned a
+  quarter, never mirrored: `right` for `down` and `up`, `up` for `right`,
+  `down` for `left` (before API 12, `left` rose up the screen too). Text stays
+  upright, and offsets, `align` and pointer corners are measured as if
+  frequency rose to the right.
 - `floor`, `range`, `average` (0–99, default 40), `fps` (default 15),
   `waterfallSpeed`, `waterfallFloor`, `waterfallRange`: numbers, or the names
   of scene values the control reads on every sweep.
@@ -2121,7 +2128,10 @@ control and takes the fields of `PanelSceneSpectrum` in the SDK:
   number or a scene value. A wider sweep is cropped to it, so a radio whose
   scope comes in a few fixed widths can be shown at any narrower one; set the
   scope to the narrowest that covers it. Everything is drawn, labelled and
-  clicked on the window shown.
+  clicked on the window shown. Where the radio's `spectrum` says `autoSpan`
+  (extension API 12), the app sets the scope itself, to the narrowest span
+  covering the widest `span` among the spectrum controls on screen, so each
+  panel names its width here and leaves `setRadioSpectrum`'s `spanHz` alone.
 - `follow` (0–0.45): keeps the tuned frequency at least this share of the
   width from either edge, by moving the radio's scope just far enough to put
   it on that margin — the picture scrolls with the dial rather than jumping
@@ -2357,7 +2367,13 @@ for a radio without a scope, otherwise its settings as the radio reports them
 (`mode`, `spanHz`, `lowHz`/`highHz`, `refLevelDb`, `speed`), what it accepts
 (`spansHz`, `refMinDb`…`refStepDb`, `modes`, `speeds`) and `problem`, why it
 cannot run, in the operator's language. The settings are known only while a
-`spectrum` control has the scope running, and null otherwise.
+`spectrum` control has the scope running, and null otherwise. `autoSpan`
+(extension API 12) is true where the app sizes the scope for its displays — a
+sweep it computes, whose width changes nothing on the radio (a FlexRadio's DAX
+IQ): it runs at the narrowest span covering the widest spectrum control's
+`span` on screen, each control cropping its own width from it, and narrows
+again as wider ones go. A panel there names its width with `span`; setting
+`spanHz` too has the panels take turns.
 `host.setRadioSpectrum({id, selection?, mode?, spanHz?, refLevelDb?, speed?})`
 changes them; a span between two the radio offers is snapped to the nearer. It
 answers `stopped` when no control is running the scope: nothing is queued for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ham2k/extension-sdk",
-  "version": "1.12.2",
+  "version": "1.12.4",
   "description": "Write extensions for the Ham2K Logger: typed hook contracts and the host API",
   "keywords": [
     "ham2k",