@ham2k/extension-sdk 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# @ham2k/extension-sdk
+
+Write extensions for the [Ham2K Logger](https://ham2k.com) — the typed hook
+contracts and the host API an extension is built against.
+
+```sh
+npm install @ham2k/extension-sdk
+npm install --save-dev @ham2k/extension-tools esbuild
+```
+
+```ts
+import { defineExtension } from '@ham2k/extension-sdk'
+import type { PanelHook } from '@ham2k/extension-sdk'
+
+import manifest from '../manifest.json'
+
+const HelloPanel: PanelHook = {
+  async getPanels() {
+    return [{ key: 'hello', title: 'Hello World', icon: 'hand-wave-outline' }]
+  },
+  async render() {
+    return { kind: 'markdown', content: '# Hello, World!' }
+  },
+}
+
+defineExtension({
+  ...manifest,
+  onActivation({ registerHook }) {
+    registerHook('panel', { key: 'ki2d-hello-world', hook: HelloPanel })
+  },
+})
+```
+
+A panel returns *content*, not widgets — which is what keeps extensions out of
+the app's UI toolkit.
+
+`@ham2k/extension-tools` builds and packages it into a `.h2kext` the app can
+install. See [the extension docs](https://github.com/ham2k/halo/tree/main/docs/extensions)
+for hooks, forms, templates and distribution.
+
+## About the peer dependencies
+
+This package lists the libraries the extension host carries — `@ham2k/lib-*`,
+`i18next`, `liquidjs` — as **optional** peers, and you almost certainly do not
+need to install any of them.
+
+Your extension declares in its `manifest.json` which of them it uses, and the
+build rewrites each one into a lookup on the host's single instance before
+esbuild ever reaches the filesystem. Taking the host up on that is worth
+roughly thirty times the bundle size. The published types have theirs rolled
+in, so your editor works with only this package installed.
+
+Install one only to `inline` it — to ship your own copy because you need a
+version the host does not carry.
+
+## License
+
+MPL-2.0

package/dist/activityAdifImport.js

@@ -0,0 +1,45 @@
+function present(...values) {
+  return values.find((v) => v !== void 0 && v !== "");
+}
+function splitRefs(value) {
+  return value.split(",").map((r) => r.trim()).filter((r) => r.length > 0);
+}
+function refsFor(fields, sigField, sigInfoField, listField, rules) {
+  const found = [];
+  const list = listField ? fields[listField] : void 0;
+  if (list) found.push(...splitRefs(list));
+  if (present(fields[`${sigField}_intl`], fields[sigField])?.toUpperCase() === rules.sig.toUpperCase()) {
+    const info = present(fields[`${sigInfoField}_intl`], fields[sigInfoField]);
+    if (info) found.push(...splitRefs(info));
+  }
+  return found;
+}
+function activityAdifImport(rules) {
+  const listField = rules.refField;
+  const myListField = rules.refField ? `my_${rules.refField}` : void 0;
+  function refsForOneRecord(fields) {
+    const refs = [];
+    for (const [type, sigField, sigInfoField, field, scope] of [
+      [rules.huntingType, "sig", "sig_info", listField, void 0],
+      [rules.activationType, "my_sig", "my_sig_info", myListField, "operation"]
+    ]) {
+      if (!type) continue;
+      const seen = /* @__PURE__ */ new Set();
+      for (const raw of refsFor(fields, sigField, sigInfoField, field, rules)) {
+        const ref = rules.normalize ? rules.normalize(raw) : raw;
+        if (!ref || seen.has(ref)) continue;
+        seen.add(ref);
+        refs.push(scope ? { type, ref, for: scope } : { type, ref });
+      }
+    }
+    return refs.length > 0 ? { refs } : null;
+  }
+  return {
+    async refsForRecords({ records }, _ctx) {
+      return records.map((record) => refsForOneRecord(record.fields ?? {}));
+    }
+  };
+}
+export {
+  activityAdifImport
+};

package/dist/activityExports.js

@@ -0,0 +1,157 @@
+import { exportFilename, startMillisOf } from "./exportNames.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 = ":";
+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 }));
+}
+function filenameFor(operation, qsos, ref, compact) {
+  return exportFilename({
+    stationCall: operation.stationCall,
+    ref,
+    startAtMillis: startMillisOf(operation, qsos),
+    extension: "adi",
+    compact
+  });
+}
+function activityExportHook(rules) {
+  const prefix = `${rules.key}-adif`;
+  return {
+    async suggestExportOptions({ operation, qsos, compactFilenames }, ctx) {
+      const refs = refsOfType(operation, rules.activationType);
+      const t = tFor(ctx);
+      return refs.map((ref) => ({
+        exportType: `${prefix}${SEPARATOR}${ref.ref}`,
+        format: "adif",
+        // The FORMAT leads: a park activated on a contest weekend offers
+        // several files for the same reference, and "POTA US-1234" alone said
+        // nothing about which of them this was.
+        label: t("adifForRef", { program: rules.label, ref: ref.ref }),
+        // The WHOLE log's first QSO dates the file, not this reference's
+        // slice: the slice isn't known until `generateExport`, and a name
+        // that changed between being shown and being written would break the
+        // panel's promise.
+        filename: filenameFor(operation, qsos ?? [], ref.ref, compactFilenames),
+        icon: rules.icon,
+        selectedByDefault: true,
+        // Segment slicing: only the contacts made while this activity ran.
+        refType: rules.activationType
+      }));
+    },
+    async generateExport(args, ctx) {
+      const exportType = String(args.exportType ?? "");
+      if (!exportType.startsWith(`${prefix}${SEPARATOR}`)) {
+        throw new Error(`${rules.key}: unknown export type '${exportType}'`);
+      }
+      const wanted = exportType.slice(prefix.length + 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}'`);
+      }
+      const refs = (args.operation.refs ?? []).filter(
+        (r) => r?.type !== rules.activationType || r?.ref === wanted
+      );
+      const operation = { ...args.operation, refs };
+      const content = await adifForExport({
+        operation,
+        qsos: args.qsos,
+        includePrivateData: args.includePrivateData,
+        mainHandler: rules.key,
+        includeFieldsFrom: rules.includeFieldsFrom
+      });
+      return {
+        filename: filenameFor(args.operation, args.qsos, wanted, args.compactFilenames),
+        mimeType: "text/plain",
+        content
+      };
+    }
+  };
+}
+function filenameForHunt(operation, qsos, activity, compact) {
+  return exportFilename({
+    stationCall: operation.stationCall,
+    activity,
+    startAtMillis: startMillisOf(operation, qsos),
+    extension: "adi",
+    compact
+  });
+}
+function huntingExportHook(rules) {
+  const exportType = `${rules.key}-hunter`;
+  function huntedQsos(qsos) {
+    return qsos.filter((qso) => refsOfType(qso, rules.huntingType).length > 0);
+  }
+  return {
+    async suggestExportOptions({ operation, qsos, compactFilenames }, ctx) {
+      if (refsOfType(operation, rules.activationType).length > 0) return [];
+      if (huntedQsos(qsos ?? []).length === 0) return [];
+      const t = tFor(ctx);
+      return [{
+        exportType,
+        format: "adif",
+        label: t("adifForHunter", { program: rules.label }),
+        filename: filenameForHunt(operation, qsos ?? [], rules.label, compactFilenames),
+        icon: rules.icon,
+        color: rules.color,
+        selectedByDefault: true
+        // No `refType`: hunted refs live on QSOs, not on operation segments,
+        // so this isn't the segment-scoped slice `activityExportHook` uses —
+        // it spans the whole log. (See `HuntingExportRules.color` for why the
+        // accent has to be threaded explicitly instead.)
+      }];
+    },
+    async generateExport(args, ctx) {
+      const requested = String(args.exportType ?? "");
+      if (requested !== exportType) {
+        throw new Error(`${rules.key}: unknown export type '${requested}'`);
+      }
+      if (refsOfType(args.operation, rules.activationType).length > 0) {
+        throw new Error(`${rules.key}: operation now activates ${rules.activationType}; hunter export withdrawn`);
+      }
+      const content = await adifForExport({
+        operation: args.operation,
+        qsos: huntedQsos(args.qsos ?? []),
+        includePrivateData: args.includePrivateData,
+        // The hunter file is submitted to ONE program too — see
+        // `activityExportHook.generateExport`. `rules.key` is the ACTIVITY's
+        // key ('pota'), which is what its `adifFields` hook registers under;
+        // the '-hunter' suffix belongs to the export registration alone.
+        mainHandler: rules.key,
+        includeFieldsFrom: rules.includeFieldsFrom
+      });
+      return {
+        // The FULL qsos list, matching the option's filename — see
+        // `filenameFor`'s identical comment above.
+        filename: filenameForHunt(args.operation, args.qsos ?? [], rules.label, args.compactFilenames),
+        mimeType: "text/plain",
+        content
+      };
+    }
+  };
+}
+async function adifForExport({ operation, qsos, includePrivateData, mainHandler, includeFieldsFrom }) {
+  const { hooks } = await import("@ham2k/extension-sdk");
+  const entries = await hooks.invokeOne("export", "adif", "generateExport", {
+    operation,
+    qsos,
+    exportType: "adif",
+    // Forwarded, or the delegate defaults to withholding and the user's
+    // "include private info" setting silently does nothing here.
+    includePrivateData,
+    mainHandler,
+    includeFieldsFrom
+  });
+  const content = entries.find((e) => e.ok)?.value?.content;
+  if (!content) {
+    const failed = entries.find((e) => !e.ok)?.error;
+    throw new Error(`${mainHandler}: the ADIF exporter produced no file${failed ? ` (${failed})` : ""}`);
+  }
+  return content;
+}
+export {
+  activityExportHook,
+  adifForExport,
+  huntingExportHook
+};

package/dist/activityScoring.js

@@ -0,0 +1,227 @@
+import { createCachedTranslator } from "./i18n.js";
+import { modesMatchForDupe } from "./modes.js";
+import { fmtInteger } from "@ham2k/lib-format-tools";
+import en from "./i18n/activityScoring.en.json";
+import es from "./i18n/activityScoring.es.json";
+const tFor = createCachedTranslator({ en: { translation: en }, es: { translation: es } });
+const DAY_IN_MILLIS = 1e3 * 60 * 60 * 24;
+function resolveRuleText(value, ctx, fallback) {
+  return typeof value === "function" ? value(ctx) : value ?? fallback;
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+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) => r.ref);
+}
+function packContact(day, band, mode, refs) {
+  return `${day}|${band}|${mode}|${[...refs].sort().join(",")}`;
+}
+function unpackContact(packed) {
+  const [day, band, mode, refs] = packed.split("|");
+  return {
+    day: Number(day),
+    band,
+    mode,
+    refs: refs ? refs.split(",") : []
+  };
+}
+function activityScorer(rules) {
+  function thresholdFor(activatedRefs) {
+    const rule = rules.qsosToActivate ?? 10;
+    return typeof rule === "function" ? rule(activatedRefs) : rule;
+  }
+  const freshRefRescuesActivation = rules.freshRefRescuesActivation ?? true;
+  const tracksActivation = rules.tracksActivation ?? true;
+  const allowsMultiple = rules.allowsMultipleReferences ?? false;
+  const activatesDaily = (rules.activates ?? "daily") === "daily";
+  const unique = new Set(rules.uniquePer ?? []);
+  function activationRefsOf(operation) {
+    return refsOfType(operation, rules.activationType);
+  }
+  function huntedRefsOf(qso) {
+    if (!rules.huntingType) return [];
+    const refs = refsOfType(qso, rules.huntingType);
+    return allowsMultiple ? refs : refs.slice(0, 1);
+  }
+  function judge(priors, now) {
+    if (priors.length === 0) return void 0;
+    let candidates = priors.map(unpackContact);
+    let notice;
+    if (unique.has("day")) {
+      candidates = candidates.filter((c) => c.day === now.day);
+      if (candidates.length === 0) notice ?? (notice = "day");
+    }
+    if (unique.has("band")) {
+      candidates = candidates.filter((c) => c.band === now.band);
+      if (candidates.length === 0) notice ?? (notice = "band");
+    }
+    if (unique.has("mode")) {
+      candidates = candidates.filter((c) => modesMatchForDupe(c.mode, now.mode));
+      if (candidates.length === 0) notice ?? (notice = "mode");
+    }
+    if (unique.has("ref")) {
+      candidates = candidates.filter(
+        (c) => c.refs.length === 0 && now.refs.length === 0 || c.refs.some((r) => now.refs.includes(r))
+      );
+      if (candidates.length === 0 && now.refs.length > 0) notice ?? (notice = "ref");
+    }
+    if (notice) return notice;
+    return candidates.length > 0 ? "duplicate" : void 0;
+  }
+  const NOTICE_KEYS = {
+    day: "newDay",
+    band: "newBand",
+    mode: "newMode",
+    ref: "newRef"
+  };
+  return {
+    startScoresheet() {
+      return {
+        workedByCall: {},
+        activatedRefs: {},
+        huntedRefs: {},
+        activatedQsos: 0,
+        huntedQsos: 0,
+        duplicates: 0,
+        dayActivatedRefs: {},
+        dayHuntedRefs: {},
+        dayActivatedQsos: 0,
+        dayHuntedQsos: 0,
+        dayDuplicates: 0
+      };
+    },
+    // Mutates and returns the scoresheet it is handed, which the contract
+    // allows and core/scoring measured the case for: copying accumulated state
+    // per QSO makes a full pass quadratic. The harness copies any resume
+    // checkpoint at its boundary, so nothing cached is ever aliased.
+    scoreQso({ scoresheet, qso, operation, isNewDay }) {
+      const sheet = scoresheet;
+      if (isNewDay && activatesDaily) {
+        sheet.dayActivatedRefs = {};
+        sheet.dayHuntedRefs = {};
+        sheet.dayActivatedQsos = 0;
+        sheet.dayHuntedQsos = 0;
+        sheet.dayDuplicates = 0;
+      }
+      const their = qso.their ?? {};
+      const call = str(their.call);
+      if (!call) return { scoresheet: sheet, score: { value: 0 } };
+      const activationRefs = activationRefsOf(operation);
+      const huntedRefs = huntedRefsOf(qso);
+      const activationValue = activationRefs.length > 0 ? huntedRefs.length || 1 : 0;
+      const huntingValue = huntedRefs.length;
+      const day = Math.floor(Number(qso.startAtMillis ?? 0) / DAY_IN_MILLIS);
+      const band = str(qso.band) ?? "";
+      const mode = str(qso.mode) ?? "";
+      const now = { day, band, mode, refs: huntedRefs };
+      const priors = sheet.workedByCall[call] ?? [];
+      const verdict = judge(priors, now);
+      const isDupe = verdict === "duplicate";
+      const freshRefOnly = verdict === "ref" && !freshRefRescuesActivation;
+      const activationCredit = freshRefOnly ? 0 : activationValue;
+      const score = { value: isDupe ? 0 : activationCredit + huntingValue };
+      if (isDupe) {
+        score.dupe = true;
+        score.alerts = ["duplicate"];
+      } else if (verdict) {
+        score.notices = [NOTICE_KEYS[verdict]];
+      }
+      const packed = packContact(day, band, mode, huntedRefs);
+      if (priors.length > 0) priors.push(packed);
+      else sheet.workedByCall[call] = [packed];
+      if (isDupe) {
+        sheet.duplicates += 1;
+        sheet.dayDuplicates += 1;
+        return { scoresheet: sheet, score };
+      }
+      for (const ref of activationRefs) {
+        sheet.activatedRefs[ref] = (sheet.activatedRefs[ref] ?? 0) + activationCredit;
+        sheet.dayActivatedRefs[ref] = (sheet.dayActivatedRefs[ref] ?? 0) + activationCredit;
+      }
+      sheet.activatedQsos += activationCredit;
+      sheet.dayActivatedQsos += activationCredit;
+      for (const ref of huntedRefs) {
+        sheet.huntedRefs[ref] = (sheet.huntedRefs[ref] ?? 0) + 1;
+        sheet.dayHuntedRefs[ref] = (sheet.dayHuntedRefs[ref] ?? 0) + 1;
+      }
+      sheet.huntedQsos += huntingValue;
+      sheet.dayHuntedQsos += huntingValue;
+      return { scoresheet: sheet, score };
+    },
+    summarizeScore({ scoresheet, scope }, ctx) {
+      const t = tFor(ctx);
+      const perDay = scope === "day" && activatesDaily;
+      const tallies = {};
+      const activatedRefs = perDay ? scoresheet.dayActivatedRefs : scoresheet.activatedRefs;
+      const huntedRefs = perDay ? scoresheet.dayHuntedRefs : scoresheet.huntedRefs;
+      const huntedQsos = perDay ? scoresheet.dayHuntedQsos : scoresheet.huntedQsos;
+      if (tracksActivation && Object.keys(activatedRefs).length > 0) {
+        tallies.activation = summarizeActivation(
+          activatedRefs,
+          perDay ? scoresheet.dayActivatedQsos : scoresheet.activatedQsos,
+          perDay ? scoresheet.dayDuplicates : scoresheet.duplicates,
+          huntedQsos,
+          scope,
+          thresholdFor(Object.keys(activatedRefs)),
+          rules,
+          t,
+          ctx
+        );
+      } else if (Object.keys(huntedRefs).length > 0) {
+        tallies.hunting = summarizeHunting(huntedRefs, huntedQsos, scope, rules, t, ctx);
+      }
+      return tallies;
+    }
+  };
+}
+function summarizeActivation(activatedRefs, qsos, duplicates, huntedQsos, scope, qsosToActivate, rules, t, ctx) {
+  const refKeys = Object.keys(activatedRefs).sort();
+  const lowest = Math.min(...refKeys.map((key) => activatedRefs[key]));
+  const activated = lowest >= qsosToActivate;
+  let summary;
+  if (!activated) summary = `${fmtInteger(lowest)}/${fmtInteger(qsosToActivate)}`;
+  else if (refKeys.length < 6) summary = `${fmtInteger(lowest)} ${"\u2713".repeat(refKeys.length)}`;
+  else summary = `${fmtInteger(lowest)} \u2713 x ${fmtInteger(refKeys.length)}`;
+  const detail = refKeys.map(
+    (key) => activatedRefs[key] >= qsosToActivate ? `\u2705 **${key}: ${fmtInteger(activatedRefs[key])}**` : `\u274C ${key}: ${fmtInteger(activatedRefs[key])}/${fmtInteger(qsosToActivate)}`
+  );
+  const parts = [
+    qsos === 1 ? t("activationQsoOne") : t("activationQsoMany", { formatted: fmtInteger(qsos) })
+  ];
+  if (huntedQsos > 0) {
+    const p2p = resolveRuleText(rules.p2pLabel, ctx, t("ref2ref"));
+    parts.push(
+      huntedQsos === 1 ? t("p2pQsoOne", { label: p2p }) : t("p2pQsoMany", { label: p2p, formatted: fmtInteger(huntedQsos) })
+    );
+  }
+  return {
+    key: "activation",
+    for: scope,
+    icon: rules.icon,
+    total: qsos,
+    activated,
+    activatedRefs,
+    duplicates,
+    label: `${rules.label}: ${parts.join(", ")}`,
+    summary,
+    longSummary: detail.join("\n")
+  };
+}
+function summarizeHunting(huntedRefs, qsos, scope, rules, t, ctx) {
+  const count = Object.keys(huntedRefs).length;
+  const noun = count === 1 ? resolveRuleText(rules.refNoun, ctx, t("reference")) : resolveRuleText(rules.refNounPlural, ctx, t("referencesPlural"));
+  return {
+    key: "hunting",
+    for: scope,
+    icon: rules.icon,
+    total: count,
+    huntedRefs,
+    huntedQsos: qsos,
+    label: `${rules.label}: ${count === 1 ? t("huntedOne", { noun }) : t("huntedMany", { noun, formatted: fmtInteger(count) })}`
+  };
+}
+export {
+  activityScorer
+};

package/dist/appClock.js

@@ -0,0 +1,42 @@
+function installAppClock(global = globalThis) {
+  const RealDate = global.Date;
+  const realNow = () => RealDate.now();
+  let anchorReal = 0;
+  let anchorVirtual = 0;
+  let speed = 1;
+  const appNow = () => {
+    if (anchorReal === 0) return realNow();
+    return Math.round(anchorVirtual + (realNow() - anchorReal) * speed);
+  };
+  const appNowStatic = () => appNow();
+  const AppDate = new Proxy(RealDate, {
+    construct(target, args, newTarget) {
+      return Reflect.construct(target, args.length === 0 ? [appNow()] : args, newTarget);
+    },
+    // `Date()` without `new` — spec behaviour is "the current time as a
+    // string", so it follows the app clock the same way construction does.
+    apply() {
+      return new RealDate(appNow()).toString();
+    },
+    get(target, prop, receiver) {
+      if (prop === "now") return appNowStatic;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  global.Date = AppDate;
+  if (global.Date !== AppDate) {
+    throw new Error("appClock: the sandbox Date could not be replaced; extensions would read real time");
+  }
+  return {
+    realNow,
+    appNow,
+    setClockTravel(anchorRealMillis, anchorVirtualMillis, nextSpeed) {
+      anchorReal = anchorRealMillis;
+      anchorVirtual = anchorVirtualMillis;
+      speed = nextSpeed;
+    }
+  };
+}
+export {
+  installAppClock
+};

package/dist/dxcc.js

@@ -0,0 +1,25 @@
+import { parseCallsign } from "@ham2k/lib-callsigns";
+import { annotateFromCountryFile, useBuiltinCountryFile } from "@ham2k/lib-country-files";
+import { DXCC_BY_CODE } from "@ham2k/lib-dxcc-data";
+useBuiltinCountryFile();
+function annotateCallAgainstCountryFile(call) {
+  return annotateFromCountryFile(parseCallsign(call));
+}
+function entityPrefixForCall(call) {
+  if (!call) return void 0;
+  return annotateCallAgainstCountryFile(call).entityPrefix;
+}
+function flagForDxccCode(dxccCode) {
+  return dxccCode == null ? void 0 : DXCC_BY_CODE[dxccCode]?.flag;
+}
+function regionAndCountryForDxccCode(dxccCode) {
+  if (dxccCode == null) return {};
+  const entity = DXCC_BY_CODE[dxccCode];
+  return { ituRegion: entity?.ituRegion, countryCode: entity?.countryCode };
+}
+export {
+  annotateCallAgainstCountryFile,
+  entityPrefixForCall,
+  flagForDxccCode,
+  regionAndCountryForDxccCode
+};

package/dist/exportNames.js

@@ -0,0 +1,57 @@
+import { dateValues, logValues } from "./templateContext.js";
+import { oneLine, renderTemplate } from "./templates.js";
+import { isTestOperation } from "./testOperation.js";
+const NAME_TEMPLATES = {
+  // Date first: chronological order, and it reads as a sentence. Whitespace
+  // does collapse here (see [oneLine]), so an absent part just closes up.
+  NormalRefName: "{{ op.date }} {{ log.station }} at {{ log.ref }} {{ log.modifier }}",
+  NormalActivityName: "{{ op.date }} {{ log.station }} for {{ log.activity }} {{ log.modifier }}",
+  NormalName: "{{ op.date }} {{ log.station }} {{ log.modifier }}",
+  // Callsign first: these sort together per station, which is the order that
+  // matters once a season's uploads share one folder. `dash` preserves case
+  // for identifiers (`N0CALL/P` → `N0CALL-P`, `US-1234` unchanged) while
+  // free text goes through `downcase | dash`.
+  // Each part is slugged into a variable and the SLUG is what's tested: a
+  // part that is punctuation only (`!!!`) is not blank but slugs to nothing,
+  // and testing the raw value would leave the separator behind — a double
+  // dash where the old code's filtered join left none.
+  CompactRefName: "{% assign s = log.station | dash %}{% assign m = log.modifier | downcase | dash %}{% if s != blank %}{{ s }}@{% endif %}{{ log.ref | dash }}-{{ op.dateCompact }}{% if m != blank %}-{{ m }}{% endif %}",
+  CompactActivityName: "{% assign s = log.station | dash %}{% assign a = log.activity | downcase | dash %}{% assign m = log.modifier | downcase | dash %}{% if s != blank %}{{ s }}-{% endif %}{% if a != blank %}{{ a }}-{% endif %}{{ op.dateCompact }}{% if m != blank %}-{{ m }}{% endif %}",
+  CompactName: "{% assign s = log.station | dash %}{% assign m = log.modifier | downcase | dash %}{% if s != blank %}{{ s }}-{% endif %}{{ op.dateCompact }}{% if m != blank %}-{{ m }}{% endif %}"
+};
+function sanitize(name) {
+  return name.replace(/[/\\:*?"<>|]+/g, "-").replace(/\s+/g, " ").trim();
+}
+function exportFilename(parts) {
+  const millis = parts.startAtMillis && parts.startAtMillis > 0 ? parts.startAtMillis : Date.now();
+  const extension = parts.extension.replace(/^\./, "");
+  const shape = `${parts.compact ? "Compact" : "Normal"}${parts.ref ? "Ref" : parts.activity ? "Activity" : ""}Name`;
+  const modifier = [
+    (parts.modifier ?? "").trim(),
+    isTestOperation(parts.stationCall) ? "Testing" : ""
+  ].filter((part) => part !== "").join(" ");
+  const stem = oneLine(
+    renderTemplate(NAME_TEMPLATES[shape], {
+      op: dateValues(millis),
+      log: logValues({
+        station: String(parts.stationCall ?? "").trim(),
+        ref: parts.ref,
+        activity: parts.activity,
+        modifier,
+        extension,
+        compact: parts.compact
+      })
+    }, shape)
+  );
+  return `${sanitize(stem) || "export"}.${extension}`;
+}
+function startMillisOf(operation, qsos = []) {
+  const earliest = qsos.map((qso) => Number(qso.startAtMillis ?? 0)).filter((millis) => millis > 0).sort((a, b) => a - b)[0];
+  if (earliest) return earliest;
+  const operationStart = Number(operation.startAtMillisMin ?? operation.startAtMillis ?? 0);
+  return operationStart > 0 ? operationStart : void 0;
+}
+export {
+  exportFilename,
+  startMillisOf
+};

package/dist/i18n/activityExports.en.json

@@ -0,0 +1,4 @@
+{
+  "adifForRef": "ADIF for {{program}} {{ref}}",
+  "adifForHunter": "{{program}} Hunter Log"
+}

package/dist/i18n/activityExports.es.json

@@ -0,0 +1,4 @@
+{
+  "adifForRef": "ADIF para {{program}} {{ref}}",
+  "adifForHunter": "Registro de Cazador {{program}}"
+}

package/dist/i18n/activityScoring.en.json

@@ -0,0 +1,11 @@
+{
+  "activationQsoOne": "1 activation QSO",
+  "activationQsoMany": "{{formatted}} activation QSOs",
+  "p2pQsoOne": "1 {{label}} QSO",
+  "p2pQsoMany": "{{formatted}} {{label}} QSOs",
+  "ref2ref": "ref2ref",
+  "reference": "reference",
+  "referencesPlural": "references",
+  "huntedOne": "1 {{noun}} hunted",
+  "huntedMany": "{{formatted}} {{noun}} hunted"
+}

package/dist/i18n/activityScoring.es.json

@@ -0,0 +1,11 @@
+{
+  "activationQsoOne": "1 QSO de activación",
+  "activationQsoMany": "{{formatted}} QSOs de activación",
+  "p2pQsoOne": "1 QSO {{label}}",
+  "p2pQsoMany": "{{formatted}} QSOs {{label}}",
+  "ref2ref": "ref2ref",
+  "reference": "referencia",
+  "referencesPlural": "referencias",
+  "huntedOne": "1 {{noun}} cazado",
+  "huntedMany": "{{formatted}} {{noun}} cazados"
+}