chore: move stuff

boneskull · May 14, 2024 · 5744fda · 5744fda
1 parent 5238c1c
commit 5744fda
Show file tree

Hide file tree

Showing 32 changed files with 708 additions and 736 deletions.
diff --git a/packages/midnight-smoker/src/component/reporter/reporter.ts b/packages/midnight-smoker/src/component/reporter/reporter.ts
@@ -1,7 +1,7 @@
 import {ReifiedComponent} from '#component';
 import {fromUnknownError} from '#error';
 import {ReporterError} from '#error/reporter-error';
-import {type EventData, type EventName} from '#event/events';
+import {type DataForEvent, type EventName} from '#event/events';
 import {type PluginMetadata} from '#plugin';
 import {
   type ReporterContext,
@@ -42,7 +42,7 @@ export class Reporter<Ctx = unknown> extends ReifiedComponent<
     return this.def.description;
   }
 
-  public async invokeListener<T extends EventName>(data: EventData<T>) {
+  public async invokeListener<T extends EventName>(data: DataForEvent<T>) {
     // await Promise.resolve();
     // XXX don't like these casts
     if (this.hasListener(data.type)) {

diff --git a/packages/midnight-smoker/src/component/schema/reporter-def.ts b/packages/midnight-smoker/src/component/schema/reporter-def.ts
@@ -4,7 +4,7 @@
  *
  * @packageDocumentation
  */
-import {type EventData, type EventName, type Events} from '#event';
+import {type DataForEvent, type EventData, type EventName} from '#event';
 import {BaseSmokerOptionsSchema, type SmokerOptions} from '#options/options';
 import {type StaticPluginMetadata} from '#plugin/static-metadata';
 import {
@@ -48,7 +48,7 @@ export type SomeReporterContext = ReporterContext<object>;
 export type ReporterListener<Evt extends EventName, Ctx = unknown> = (
   this: void,
   ctx: ReporterContext<Ctx>,
-  data: EventData<Evt>,
+  data: DataForEvent<Evt>,
 ) => void | Promise<void>;
 
 export type ReporterSetupFn<Ctx = unknown> = (
@@ -65,7 +65,7 @@ export type ReporterTeardownFn<Ctx = unknown> = (
  */
 
 export type ReporterListeners<Ctx = unknown> = {
-  [K in keyof Events as `on${K}`]: ReporterListener<K, Ctx>;
+  [K in keyof EventData as `on${K}`]: ReporterListener<K, Ctx>;
 };
 
 /**

diff --git a/packages/midnight-smoker/src/event/events.ts b/packages/midnight-smoker/src/event/events.ts
@@ -7,7 +7,7 @@ import {type SmokerEventData} from './smoker-events';
 /**
  * Describes the data emitted by each event.
  */
-export type Events = InstallEventData &
+export type EventData = InstallEventData &
   PackEventData &
   LintEventData &
   ScriptEventData &
@@ -16,13 +16,14 @@ export type Events = InstallEventData &
 /**
  * Names of all events emitted by `midnight-smoker`
  */
-export type EventName = keyof Events;
+export type EventName = keyof EventData;
 
 /**
- * Data associated with a specific event
+ * Data associated with a specific event with an additional `type` field
+ * containing the event name
  *
  * @template T - The event name
  */
-export type EventData<T extends EventName> = {
-  [K in T]: {type: K} & Events[K];
+export type DataForEvent<T extends EventName> = {
+  [K in T]: {type: K} & EventData[K];
 }[T];
diff --git a/packages/midnight-smoker/src/event/script-events.ts b/packages/midnight-smoker/src/event/script-events.ts
@@ -1,12 +1,12 @@
-import type {
-  ExecResult,
-  RunScriptManifest,
-  RunScriptResult,
-  ScriptError,
-  StaticPkgManagerSpec,
-} from '../component';
-import type {ScriptEvent} from './event-constants';
-import type {PkgManagerEventBase} from './pkg-manager-events';
+import {
+  type ExecResult,
+  type RunScriptManifest,
+  type RunScriptResult,
+  type ScriptError,
+  type StaticPkgManagerSpec,
+} from '#schema';
+import {type ScriptEvent} from './event-constants';
+import {type PkgManagerEventBase} from './pkg-manager-events';
 
 export interface ScriptEventData {
   [ScriptEvent.PkgManagerRunScriptsBegin]: PkgManagerRunScriptsBeginEventData;
@@ -99,6 +99,7 @@ export interface RunScriptOkEventData extends RunScriptEventDataBase {
 
 export interface RunScriptFailedEventData extends RunScriptEventDataBase {
   error: ScriptError;
+  rawResult?: ExecResult;
 }
 
 export interface RunScriptSkippedEventData extends RunScriptEventDataBase {

diff --git a/packages/midnight-smoker/src/machine/bus/bus-machine.ts b/packages/midnight-smoker/src/machine/bus/bus-machine.ts
diff --git a/packages/midnight-smoker/src/machine/bus/index.ts b/packages/midnight-smoker/src/machine/bus/index.ts
diff --git a/...hine/controller/control-machine-actors.ts → ...machine/control/control-machine-actors.ts b/...hine/controller/control-machine-actors.ts → ...machine/control/control-machine-actors.ts
diff --git a/packages/midnight-smoker/src/machine/control/control-machine-events.ts b/packages/midnight-smoker/src/machine/control/control-machine-events.ts
@@ -0,0 +1,107 @@
+import {type DataForEvent, type EventData, type SmokerEvent} from '#event';
+import {type LoaderMachineOutput} from '#machine/loader';
+import {type PkgManagerMachineOutput} from '#machine/pkg-manager';
+import {type ReporterMachineOutput} from '#machine/reporter';
+import {type AnyInstallEvent, type CtrlInstallEvents} from './install-events';
+import {type AnyLintEvent, type CtrlLintEvents} from './lint-events';
+import {type AnyPackEvent, type CtrlPackEvents} from './pack-events';
+import {type AnyScriptEvent, type CtrlScriptEvents} from './script-events';
+
+export type ComputedPkgEventFields = 'currentPkg' | 'totalPkgs';
+
+export type EventMap = {
+  'SCRIPT.RUN_SCRIPT_BEGIN': typeof SmokerEvent.RunScriptBegin;
+  'SCRIPT.RUN_SCRIPT_FAILED': typeof SmokerEvent.RunScriptFailed;
+  'SCRIPT.RUN_SCRIPT_OK': typeof SmokerEvent.RunScriptOk;
+  'SCRIPT.RUN_SCRIPT_SKIPPED': typeof SmokerEvent.RunScriptSkipped;
+  'SCRIPT.PKG_MANAGER_RUN_SCRIPTS_BEGIN': typeof SmokerEvent.PkgManagerRunScriptsBegin;
+  'SCRIPT.PKG_MANAGER_RUN_SCRIPTS_FAILED': typeof SmokerEvent.PkgManagerRunScriptsFailed;
+  'SCRIPT.PKG_MANAGER_RUN_SCRIPTS_OK': typeof SmokerEvent.PkgManagerRunScriptsOk;
+  'PACK.PKG_PACK_BEGIN': typeof SmokerEvent.PkgPackBegin;
+  'PACK.PKG_PACK_FAILED': typeof SmokerEvent.PkgPackFailed;
+  'PACK.PKG_PACK_OK': typeof SmokerEvent.PkgPackOk;
+  'PACK.PKG_MANAGER_PACK_BEGIN': typeof SmokerEvent.PkgManagerPackBegin;
+  'PACK.PKG_MANAGER_PACK_FAILED': typeof SmokerEvent.PkgManagerPackFailed;
+  'PACK.PKG_MANAGER_PACK_OK': typeof SmokerEvent.PkgManagerPackOk;
+  'INSTALL.PKG_MANAGER_INSTALL_BEGIN': typeof SmokerEvent.PkgManagerInstallBegin;
+  'INSTALL.PKG_MANAGER_INSTALL_FAILED': typeof SmokerEvent.PkgManagerInstallFailed;
+  'INSTALL.PKG_MANAGER_INSTALL_OK': typeof SmokerEvent.PkgManagerInstallOk;
+  'INSTALL.PKG_INSTALL_BEGIN': typeof SmokerEvent.PkgInstallBegin;
+  'INSTALL.PKG_INSTALL_FAILED': typeof SmokerEvent.PkgInstallFailed;
+  'INSTALL.PKG_INSTALL_OK': typeof SmokerEvent.PkgInstallOk;
+  'LINT.RULE_BEGIN': typeof SmokerEvent.RuleBegin;
+  'LINT.RULE_FAILED': typeof SmokerEvent.RuleFailed;
+  'LINT.RULE_OK': typeof SmokerEvent.RuleOk;
+  'LINT.RULE_ERROR': typeof SmokerEvent.RuleError;
+  'LINT.PKG_MANAGER_LINT_BEGIN': typeof SmokerEvent.PkgManagerLintBegin;
+  'LINT.PKG_MANAGER_LINT_FAILED': typeof SmokerEvent.PkgManagerLintFailed;
+  'LINT.PKG_MANAGER_LINT_OK': typeof SmokerEvent.PkgManagerLintOk;
+};
+
+export type BusEvent =
+  | CtrlInstallEvents
+  | CtrlLintEvents
+  | CtrlPackEvents
+  | CtrlScriptEvents;
+
+export type ToSmokerEvent<T extends BusEvent> = DataForEvent<
+  EventMap[T['type']]
+>;
+
+export type CtrlEvents =
+  | AnyInstallEvent
+  | AnyLintEvent
+  | AnyPackEvent
+  | AnyScriptEvent
+  | CtrlHaltEvent
+  | CtrlInstallEvents
+  | CtrlLingeredEvent
+  | CtrlLintEvents
+  | CtrlLoaderMachineDoneEvent
+  | CtrlPackEvents
+  | CtrlPkgManagerMachineDoneEvent
+  | CtrlReporterDoneEvent
+  | CtrlScriptEvents
+  | VerbatimEventData;
+
+export type CtrlMachineEmitted = DataForEvent<keyof EventData>;
+
+/**
+ * These events are emitted by the bus machines, and are identical to the "real"
+ * events emitted by midnight-smoker.
+ */
+export type VerbatimEventData = DataForEvent<VerbatimEventNames>;
+
+export type VerbatimEventNames =
+  | typeof SmokerEvent.LintOk
+  | typeof SmokerEvent.LintFailed
+  | typeof SmokerEvent.PackOk
+  | typeof SmokerEvent.PackFailed
+  | typeof SmokerEvent.InstallOk
+  | typeof SmokerEvent.InstallFailed
+  | typeof SmokerEvent.RunScriptsFailed
+  | typeof SmokerEvent.RunScriptsOk;
+
+export interface CtrlHaltEvent {
+  type: 'HALT';
+}
+
+export interface CtrlLingeredEvent {
+  directory: string;
+  type: 'LINGERED';
+}
+
+export interface CtrlLoaderMachineDoneEvent {
+  output: LoaderMachineOutput;
+  type: 'xstate.done.actor.LoaderMachine.*';
+}
+
+export interface CtrlPkgManagerMachineDoneEvent {
+  output: PkgManagerMachineOutput;
+  type: 'xstate.done.actor.PkgManagerMachine.*';
+}
+
+export interface CtrlReporterDoneEvent {
+  output: ReporterMachineOutput;
+  type: 'xstate.done.actor.ReporterMachine.*';
+}
diff --git a/...src/machine/controller/control-machine.ts → ...er/src/machine/control/control-machine.ts b/...src/machine/controller/control-machine.ts → ...er/src/machine/control/control-machine.ts
@@ -1,14 +1,14 @@
 import {DEFAULT_EXECUTOR_ID, SYSTEM_EXECUTOR_ID} from '#constants';
 import {fromUnknownError} from '#error';
-import {SmokerEvent, type EventData} from '#event';
+import {SmokerEvent, type DataForEvent} from '#event';
 import {
   LoadableComponents,
   LoaderMachine,
   type LoaderMachineOutputOk,
   type PkgManagerInitPayload,
   type ReporterInitPayload,
   type RuleInitPayload,
-} from '#machine/loader-machine';
+} from '#machine/loader';
 import {PkgManagerMachine} from '#machine/pkg-manager';
 import {
   ReporterMachine,
@@ -26,7 +26,7 @@ import {
   type WorkspaceInfo,
 } from '#schema';
 import {FileManager} from '#util/filemanager';
-import {isEmpty} from 'lodash';
+import {isEmpty, map, uniqBy} from 'lodash';
 import assert from 'node:assert';
 import {type PackageJson} from 'type-fest';
 import {
@@ -139,7 +139,7 @@ function delta(startTime: number): string {
 export const ControlMachine = setup({
   types: {
     context: {} as CtrlMachineContext,
-    emitted: {} as Event.ControlMachineEmitted,
+    emitted: {} as Event.CtrlMachineEmitted,
     events: {} as Event.CtrlEvents,
     input: {} as CtrlMachineInput,
     output: {} as CtrlMachineOutput,
@@ -211,7 +211,7 @@ export const ControlMachine = setup({
     assignWorkspaceInfo: assign({
       workspaceInfo: (_, workspaceInfo: WorkspaceInfo[]) => workspaceInfo,
       uniquePkgNames: (_, workspaceInfo: WorkspaceInfo[]) =>
-        MachineUtil.uniquePkgNames(workspaceInfo),
+        map(uniqBy(workspaceInfo, 'pkgName'), 'pkgName'),
     }),
 
     /**
@@ -413,7 +413,7 @@ export const ControlMachine = setup({
     report: enqueueActions(
       (
         {enqueue, context: {reporterMachineRefs}},
-        event: Event.ControlMachineEmitted,
+        event: Event.CtrlMachineEmitted,
       ) => {
         for (const reporterMachineRef of Object.values(reporterMachineRefs)) {
           enqueue.sendTo(reporterMachineRef, {type: 'EVENT', event});
@@ -1004,14 +1004,14 @@ export const ControlMachine = setup({
           type: 'report',
           params: ({
             context: {pluginRegistry, smokerOptions},
-          }): EventData<typeof SmokerEvent.SmokeBegin> => ({
+          }): DataForEvent<typeof SmokerEvent.SmokeBegin> => ({
             type: SmokerEvent.SmokeBegin,
             plugins: pluginRegistry.plugins.map((plugin) => plugin.toJSON()),
             opts: smokerOptions,
           }),
         },
       ],
-      type: 'parallel',
+      type: MachineUtil.PARALLEL,
       states: {
         packing: {
           initial: 'working',
@@ -1273,7 +1273,7 @@ export const ControlMachine = setup({
                 type: 'report',
                 params: ({
                   context: {lingered},
-                }): EventData<typeof SmokerEvent.Lingered> => {
+                }): DataForEvent<typeof SmokerEvent.Lingered> => {
                   assert.ok(lingered);
                   return {type: SmokerEvent.Lingered, directories: lingered};
                 },
@@ -1312,21 +1312,21 @@ export const ControlMachine = setup({
                 `complete (with error) in ${delta(startTime)}s`,
             ),
           ],
-          type: 'final',
+          type: MachineUtil.FINAL,
         },
         complete: {
           entry: [
             log(({context: {startTime}}) => `complete in ${delta(startTime)}s`),
           ],
-          type: 'final',
+          type: MachineUtil.FINAL,
         },
       },
       onDone: {
         target: 'stopped',
       },
     },
     stopped: {
-      type: 'final',
+      type: MachineUtil.FINAL,
     },
   },
   output: ({

diff --git a/...ht-smoker/src/machine/controller/index.ts → ...night-smoker/src/machine/control/index.ts b/...ht-smoker/src/machine/controller/index.ts → ...night-smoker/src/machine/control/index.ts