@pisell/pisellos 0.0.567 → 0.0.569

package/lib/modules/ResourcePlanner/index.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ResourcePlannerHooks: true,
+  ResourcePlannerModule: true
+};
+exports.ResourcePlannerModule = exports.ResourcePlannerHooks = void 0;
+var _BaseModule = require("../BaseModule");
+var _planner = require("./planner");
+Object.keys(_planner).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _planner[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _planner[key];
+    }
+  });
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+let ResourcePlannerHooks = exports.ResourcePlannerHooks = /*#__PURE__*/function (ResourcePlannerHooks) {
+  ResourcePlannerHooks["onContextChanged"] = "resourcePlanner:onContextChanged";
+  ResourcePlannerHooks["onSelectionChanged"] = "resourcePlanner:onSelectionChanged";
+  ResourcePlannerHooks["onProjectionChanged"] = "resourcePlanner:onProjectionChanged";
+  return ResourcePlannerHooks;
+}({});
+class ResourcePlannerModule extends _BaseModule.BaseModule {
+  defaultName = 'resourcePlanner';
+  defaultVersion = '1.0.0';
+  store;
+  async initialize(core, options) {
+    this.core = core;
+    const initialState = options.initialState;
+    this.store = {
+      context: (0, _planner.normalizePlannerContext)(initialState?.context || _planner.DEFAULT_RESOURCE_PLANNER_CONTEXT),
+      selection: initialState?.selection || {
+        ..._planner.DEFAULT_RESOURCE_PLANNER_SELECTION
+      },
+      projection: initialState?.projection || null,
+      version: initialState?.version || 0
+    };
+  }
+  setContext(input) {
+    this.store.context = (0, _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, _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, _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, _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, _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
+    };
+  }
+}
+exports.ResourcePlannerModule = ResourcePlannerModule;

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;