@pisell/pisellos 2.3.38 → 2.3.40

package/lib/modules/ResourcePlanner/index.d.ts

@@ -0,0 +1,24 @@
+import { BaseModule } from '../BaseModule';
+import type { Module, ModuleOptions, PisellCore } from '../../types';
+import type { ResourcePlannerAssignmentResult, ResourcePlannerAssignableSlotResult, ResourcePlannerContextInput, ResourcePlannerProjection, ResourcePlannerQuery, ResourcePlannerSelectionPatch, ResourcePlannerSnapshot, ResourcePlannerValidationResult } from './types';
+export * from './types';
+export * from './planner';
+export declare enum ResourcePlannerHooks {
+    onContextChanged = "resourcePlanner:onContextChanged",
+    onSelectionChanged = "resourcePlanner:onSelectionChanged",
+    onProjectionChanged = "resourcePlanner:onProjectionChanged"
+}
+export declare class ResourcePlannerModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private store;
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    setContext(input: ResourcePlannerContextInput): ResourcePlannerSnapshot;
+    mergeContext(input: ResourcePlannerContextInput): ResourcePlannerSnapshot;
+    setSelectionPatch(patch: ResourcePlannerSelectionPatch): ResourcePlannerSnapshot;
+    queryAvailability(query?: ResourcePlannerQuery): ResourcePlannerProjection;
+    autoAssign(query?: ResourcePlannerQuery): ResourcePlannerAssignmentResult;
+    resolveAssignableSlots(query?: ResourcePlannerQuery): ResourcePlannerAssignableSlotResult;
+    validateSelection(): ResourcePlannerValidationResult;
+    getSnapshot(): ResourcePlannerSnapshot;
+}

package/lib/modules/ResourcePlanner/index.js

@@ -0,0 +1,148 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/ResourcePlanner/index.ts
+var ResourcePlanner_exports = {};
+__export(ResourcePlanner_exports, {
+  ResourcePlannerHooks: () => ResourcePlannerHooks,
+  ResourcePlannerModule: () => ResourcePlannerModule
+});
+module.exports = __toCommonJS(ResourcePlanner_exports);
+var import_BaseModule = require("../BaseModule");
+var import_planner = require("./planner");
+__reExport(ResourcePlanner_exports, require("./types"), module.exports);
+__reExport(ResourcePlanner_exports, require("./planner"), module.exports);
+var ResourcePlannerHooks = /* @__PURE__ */ ((ResourcePlannerHooks2) => {
+  ResourcePlannerHooks2["onContextChanged"] = "resourcePlanner:onContextChanged";
+  ResourcePlannerHooks2["onSelectionChanged"] = "resourcePlanner:onSelectionChanged";
+  ResourcePlannerHooks2["onProjectionChanged"] = "resourcePlanner:onProjectionChanged";
+  return ResourcePlannerHooks2;
+})(ResourcePlannerHooks || {});
+var ResourcePlannerModule = class extends import_BaseModule.BaseModule {
+  constructor() {
+    super(...arguments);
+    this.defaultName = "resourcePlanner";
+    this.defaultVersion = "1.0.0";
+  }
+  async initialize(core, options) {
+    this.core = core;
+    const initialState = options.initialState;
+    this.store = {
+      context: (0, import_planner.normalizePlannerContext)((initialState == null ? void 0 : initialState.context) || import_planner.DEFAULT_RESOURCE_PLANNER_CONTEXT),
+      selection: (initialState == null ? void 0 : initialState.selection) || { ...import_planner.DEFAULT_RESOURCE_PLANNER_SELECTION },
+      projection: (initialState == null ? void 0 : initialState.projection) || null,
+      version: (initialState == null ? void 0 : initialState.version) || 0
+    };
+  }
+  setContext(input) {
+    this.store.context = (0, import_planner.normalizePlannerContext)(input);
+    this.store.version += 1;
+    this.store.projection = null;
+    const snapshot = this.getSnapshot();
+    void this.core.effects.emit(`${this.name}:contextChanged`, snapshot);
+    return snapshot;
+  }
+  mergeContext(input) {
+    return this.setContext({
+      ...this.store.context,
+      ...input,
+      products: input.products || this.store.context.products,
+      resources: input.resources || this.store.context.resources,
+      externalEvents: input.externalEvents || this.store.context.externalEvents
+    });
+  }
+  setSelectionPatch(patch) {
+    const assignments = patch.assignments ? patch.replaceAssignments === false ? [...this.store.selection.assignments, ...patch.assignments] : patch.assignments : this.store.selection.assignments;
+    this.store.selection = {
+      ...this.store.selection,
+      ...patch,
+      productIds: patch.productIds || this.store.selection.productIds,
+      resourceIds: patch.resourceIds || this.store.selection.resourceIds,
+      assignments
+    };
+    this.store.version += 1;
+    const snapshot = this.getSnapshot();
+    void this.core.effects.emit(`${this.name}:selectionChanged`, snapshot);
+    return snapshot;
+  }
+  queryAvailability(query = {}) {
+    const mergedQuery = {
+      mode: this.store.selection.mode,
+      productIds: this.store.selection.productIds,
+      date: this.store.selection.date,
+      startTime: this.store.selection.startTime,
+      endTime: this.store.selection.endTime,
+      resourceIds: this.store.selection.resourceIds,
+      ...query
+    };
+    const projection = (0, import_planner.queryPlannerAvailability)(this.store.context, mergedQuery);
+    this.store.projection = projection;
+    this.store.version += 1;
+    void this.core.effects.emit(`${this.name}:projectionChanged`, this.getSnapshot());
+    return projection;
+  }
+  autoAssign(query = {}) {
+    const result = (0, import_planner.autoAssignResources)(this.store.context, {
+      mode: this.store.selection.mode,
+      productIds: this.store.selection.productIds,
+      date: this.store.selection.date,
+      startTime: this.store.selection.startTime,
+      endTime: this.store.selection.endTime,
+      resourceIds: this.store.selection.resourceIds,
+      ...query
+    });
+    const resourceIds = Array.from(new Map(
+      result.assignments.map((assignment) => [String(assignment.resourceId), assignment.resourceId])
+    ).values());
+    this.setSelectionPatch({
+      assignments: result.assignments,
+      ...resourceIds.length ? { resourceIds } : {}
+    });
+    return result;
+  }
+  resolveAssignableSlots(query = {}) {
+    return (0, import_planner.resolveAssignableSlots)(this.store.context, {
+      mode: this.store.selection.mode,
+      productIds: this.store.selection.productIds,
+      date: this.store.selection.date,
+      startTime: this.store.selection.startTime,
+      endTime: this.store.selection.endTime,
+      resourceIds: this.store.selection.resourceIds,
+      ...query
+    });
+  }
+  validateSelection() {
+    return (0, import_planner.validateAssignments)(this.store.context, this.store.selection);
+  }
+  getSnapshot() {
+    return {
+      context: this.store.context,
+      selection: this.store.selection,
+      projection: this.store.projection,
+      version: this.store.version
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourcePlannerHooks,
+  ResourcePlannerModule,
+  ...require("./types"),
+  ...require("./planner")
+});

package/lib/modules/ResourcePlanner/planner.d.ts

@@ -0,0 +1,14 @@
+import type { ResourcePlannerAssignmentResult, ResourcePlannerAssignableSlotResult, ResourcePlannerAvailabilityCell, ResourcePlannerContextInput, ResourcePlannerDemandInterval, ResourcePlannerProduct, ResourcePlannerProjection, ResourcePlannerQuery, ResourcePlannerResource, ResourcePlannerSelection, ResourcePlannerValidationResult } from './types';
+export declare const DEFAULT_RESOURCE_PLANNER_CONTEXT: Required<ResourcePlannerContextInput>;
+export declare const DEFAULT_RESOURCE_PLANNER_SELECTION: ResourcePlannerSelection;
+export declare function normalizePlannerContext(input?: ResourcePlannerContextInput): Required<ResourcePlannerContextInput>;
+export declare function buildDemandIntervals(products: ResourcePlannerProduct[], query: ResourcePlannerQuery, context?: Required<ResourcePlannerContextInput>): ResourcePlannerDemandInterval[];
+export declare function evaluateResourceForInterval(params: {
+    resource: ResourcePlannerResource;
+    interval: ResourcePlannerDemandInterval;
+    context: Required<ResourcePlannerContextInput>;
+}): ResourcePlannerAvailabilityCell;
+export declare function queryPlannerAvailability(contextInput: ResourcePlannerContextInput, query?: ResourcePlannerQuery): ResourcePlannerProjection;
+export declare function resolveAssignableSlots(contextInput: ResourcePlannerContextInput, query?: ResourcePlannerQuery): ResourcePlannerAssignableSlotResult;
+export declare function autoAssignResources(contextInput: ResourcePlannerContextInput, query?: ResourcePlannerQuery): ResourcePlannerAssignmentResult;
+export declare function validateAssignments(contextInput: ResourcePlannerContextInput, selection: ResourcePlannerSelection): ResourcePlannerValidationResult;