@pisell/pisellos 2.3.72 → 2.3.74

package/lib/modules/ResourcePlanner/index.js

@@ -2,10 +2,6 @@ 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))
@@ -19,130 +15,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // 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/localClock.d.ts

@@ -0,0 +1,33 @@
+export interface LocalDateParts {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface LocalDateTimeParts extends LocalDateParts {
+    hour: number;
+    minute: number;
+    second: number;
+}
+type LocalDateInput = string | LocalDateParts;
+type LocalDateTimeInput = string | number | LocalDateTimeParts;
+export declare function parseLocalDate(value: string): LocalDateParts;
+export declare function parseLocalDateTime(value: string): LocalDateTimeParts;
+export declare function extractFixedOffsetMinutes(value: string | null | undefined): number | null;
+export declare function captureRuntimeOffsetMinutes(value?: Date): number;
+export declare function formatFixedOffset(offsetMinutes: number | null | undefined): string;
+export declare function localDateTimeToScalar(value: LocalDateTimeParts): number;
+export declare function localDateToScalar(value: Date): number;
+export declare function localDateToScalarStart(value: LocalDateInput): number;
+export declare function scalarToLocalDateParts(value: number): LocalDateParts;
+export declare function scalarToLocalDateTimeParts(value: number): LocalDateTimeParts;
+export declare function dateOrdinalFromLocalDate(value: LocalDateInput): number;
+export declare function weekdayFromLocalDate(value: LocalDateInput): number;
+export declare function formatLocalDate(value: LocalDateInput | number): string;
+export declare function formatLocalTime(value: LocalDateTimeInput, includeSeconds?: boolean): string;
+export declare function formatLocalDateTime(value: LocalDateTimeInput, fixedOffsetMinutes?: number | null): string;
+export declare function addLocalMinutes(value: number, minutes: number): number;
+export declare function addLocalHours(value: number, hours: number): number;
+export declare function addLocalCalendarDays(value: number, days: number): number;
+export declare function nextDate(value: LocalDateInput): string;
+export declare function ceilLocalScalarToTenMinutes(value: number): number;
+export {};

package/lib/modules/ResourcePlanner/localClock.js

@@ -0,0 +1,270 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/ResourcePlanner/localClock.ts
+var localClock_exports = {};
+__export(localClock_exports, {
+  addLocalCalendarDays: () => addLocalCalendarDays,
+  addLocalHours: () => addLocalHours,
+  addLocalMinutes: () => addLocalMinutes,
+  captureRuntimeOffsetMinutes: () => captureRuntimeOffsetMinutes,
+  ceilLocalScalarToTenMinutes: () => ceilLocalScalarToTenMinutes,
+  dateOrdinalFromLocalDate: () => dateOrdinalFromLocalDate,
+  extractFixedOffsetMinutes: () => extractFixedOffsetMinutes,
+  formatFixedOffset: () => formatFixedOffset,
+  formatLocalDate: () => formatLocalDate,
+  formatLocalDateTime: () => formatLocalDateTime,
+  formatLocalTime: () => formatLocalTime,
+  localDateTimeToScalar: () => localDateTimeToScalar,
+  localDateToScalar: () => localDateToScalar,
+  localDateToScalarStart: () => localDateToScalarStart,
+  nextDate: () => nextDate,
+  parseLocalDate: () => parseLocalDate,
+  parseLocalDateTime: () => parseLocalDateTime,
+  scalarToLocalDateParts: () => scalarToLocalDateParts,
+  scalarToLocalDateTimeParts: () => scalarToLocalDateTimeParts,
+  weekdayFromLocalDate: () => weekdayFromLocalDate
+});
+module.exports = __toCommonJS(localClock_exports);
+var MINUTE_MS = 60 * 1e3;
+var HOUR_MS = 60 * MINUTE_MS;
+function pad(value, size = 2) {
+  return String(value).padStart(size, "0");
+}
+function isFiniteInteger(value) {
+  return Number.isInteger(value) && Number.isFinite(value);
+}
+function assertDateParts(parts) {
+  if (!isFiniteInteger(parts.year) || !isFiniteInteger(parts.month) || !isFiniteInteger(parts.day)) {
+    throw new Error("Invalid local date parts");
+  }
+  const probe = new Date(Date.UTC(parts.year, parts.month - 1, parts.day));
+  if (probe.getUTCFullYear() !== parts.year || probe.getUTCMonth() !== parts.month - 1 || probe.getUTCDate() !== parts.day) {
+    throw new Error("Invalid local date");
+  }
+}
+function assertTimeParts(parts) {
+  if (!isFiniteInteger(parts.hour) || !isFiniteInteger(parts.minute) || !isFiniteInteger(parts.second) || parts.hour < 0 || parts.hour > 23 || parts.minute < 0 || parts.minute > 59 || parts.second < 0 || parts.second > 59) {
+    throw new Error("Invalid local time");
+  }
+}
+function localDateInputToParts(value) {
+  if (typeof value !== "string") {
+    assertDateParts(value);
+    return value;
+  }
+  return parseLocalDate(value);
+}
+function scalarToDate(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error("Invalid local scalar");
+  }
+  return new Date(value);
+}
+function parseLocalDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+  if (!match) {
+    throw new Error(`Invalid local date: ${value}`);
+  }
+  const parts = {
+    year: Number(match[1]),
+    month: Number(match[2]),
+    day: Number(match[3])
+  };
+  assertDateParts(parts);
+  return parts;
+}
+function parseLocalDateTime(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.\d{1,9})?(?:[zZ]|[+-]\d{2}:\d{2})?$/.exec(value.trim());
+  if (!match) {
+    throw new Error(`Invalid local datetime: ${value}`);
+  }
+  const parts = {
+    year: Number(match[1]),
+    month: Number(match[2]),
+    day: Number(match[3]),
+    hour: Number(match[4]),
+    minute: Number(match[5]),
+    second: Number(match[6] || "0")
+  };
+  assertDateParts(parts);
+  assertTimeParts(parts);
+  return parts;
+}
+function extractFixedOffsetMinutes(value) {
+  if (!value)
+    return null;
+  const trimmed = value.trim();
+  if (trimmed.toUpperCase() === "Z")
+    return 0;
+  const directMatch = /^([+-])(\d{2}):(\d{2})$/.exec(trimmed);
+  const suffixMatch = /([zZ]|[+-]\d{2}:\d{2})$/.exec(trimmed);
+  const target = directMatch ? trimmed : suffixMatch == null ? void 0 : suffixMatch[1];
+  if (!target)
+    return null;
+  if (target.toUpperCase() === "Z")
+    return 0;
+  const match = /^([+-])(\d{2}):(\d{2})$/.exec(target);
+  if (!match)
+    return null;
+  const minutes = Number(match[2]) * 60 + Number(match[3]);
+  return match[1] === "-" ? -minutes : minutes;
+}
+function captureRuntimeOffsetMinutes(value = /* @__PURE__ */ new Date()) {
+  return -value.getTimezoneOffset();
+}
+function formatFixedOffset(offsetMinutes) {
+  if (offsetMinutes === null || offsetMinutes === void 0)
+    return "";
+  if (!Number.isFinite(offsetMinutes)) {
+    throw new Error("Invalid fixed offset");
+  }
+  const normalized = Math.trunc(offsetMinutes);
+  if (normalized === 0)
+    return "Z";
+  const sign = normalized >= 0 ? "+" : "-";
+  const absolute = Math.abs(normalized);
+  return `${sign}${pad(Math.floor(absolute / 60))}:${pad(absolute % 60)}`;
+}
+function localDateTimeToScalar(value) {
+  assertDateParts(value);
+  assertTimeParts(value);
+  return Date.UTC(value.year, value.month - 1, value.day, value.hour, value.minute, value.second, 0);
+}
+function localDateToScalar(value) {
+  return Date.UTC(
+    value.getFullYear(),
+    value.getMonth(),
+    value.getDate(),
+    value.getHours(),
+    value.getMinutes(),
+    value.getSeconds(),
+    0
+  );
+}
+function localDateToScalarStart(value) {
+  const parts = localDateInputToParts(value);
+  return Date.UTC(parts.year, parts.month - 1, parts.day, 0, 0, 0, 0);
+}
+function scalarToLocalDateParts(value) {
+  const date = scalarToDate(value);
+  return {
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate()
+  };
+}
+function scalarToLocalDateTimeParts(value) {
+  const date = scalarToDate(value);
+  return {
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate(),
+    hour: date.getUTCHours(),
+    minute: date.getUTCMinutes(),
+    second: date.getUTCSeconds()
+  };
+}
+function dateOrdinalFromLocalDate(value) {
+  const parts = localDateInputToParts(value);
+  return Math.floor(Date.UTC(parts.year, parts.month - 1, parts.day) / (24 * HOUR_MS));
+}
+function weekdayFromLocalDate(value) {
+  const parts = localDateInputToParts(value);
+  return new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();
+}
+function formatLocalDate(value) {
+  const parts = typeof value === "number" ? scalarToLocalDateParts(value) : localDateInputToParts(value);
+  return `${pad(parts.year, 4)}-${pad(parts.month)}-${pad(parts.day)}`;
+}
+function formatLocalTime(value, includeSeconds = true) {
+  const parts = typeof value === "number" ? scalarToLocalDateTimeParts(value) : typeof value === "string" ? parseLocalDateTime(value) : value;
+  assertTimeParts(parts);
+  if (!includeSeconds) {
+    return `${pad(parts.hour)}:${pad(parts.minute)}`;
+  }
+  return `${pad(parts.hour)}:${pad(parts.minute)}:${pad(parts.second)}`;
+}
+function formatLocalDateTime(value, fixedOffsetMinutes) {
+  const parts = typeof value === "number" ? scalarToLocalDateTimeParts(value) : typeof value === "string" ? parseLocalDateTime(value) : value;
+  assertDateParts(parts);
+  assertTimeParts(parts);
+  return `${formatLocalDate(parts)}T${formatLocalTime(parts)}${formatFixedOffset(fixedOffsetMinutes)}`;
+}
+function addLocalMinutes(value, minutes) {
+  if (!Number.isFinite(minutes)) {
+    throw new Error("Invalid minute delta");
+  }
+  return value + Math.trunc(minutes) * MINUTE_MS;
+}
+function addLocalHours(value, hours) {
+  if (!Number.isFinite(hours)) {
+    throw new Error("Invalid hour delta");
+  }
+  return value + Math.trunc(hours) * HOUR_MS;
+}
+function addLocalCalendarDays(value, days) {
+  if (!Number.isFinite(days)) {
+    throw new Error("Invalid day delta");
+  }
+  const parts = scalarToLocalDateTimeParts(value);
+  return Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day + Math.trunc(days),
+    parts.hour,
+    parts.minute,
+    parts.second,
+    0
+  );
+}
+function nextDate(value) {
+  return formatLocalDate(addLocalCalendarDays(localDateToScalarStart(value), 1));
+}
+function ceilLocalScalarToTenMinutes(value) {
+  const parts = scalarToLocalDateTimeParts(value);
+  const minuteRemainder = parts.minute % 10;
+  if (minuteRemainder === 0 && parts.second === 0)
+    return value;
+  const deltaMinutes = parts.second === 0 ? 10 - minuteRemainder : minuteRemainder === 0 ? 10 : 10 - minuteRemainder;
+  const roundedBase = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, 0, 0);
+  return addLocalMinutes(roundedBase, deltaMinutes);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addLocalCalendarDays,
+  addLocalHours,
+  addLocalMinutes,
+  captureRuntimeOffsetMinutes,
+  ceilLocalScalarToTenMinutes,
+  dateOrdinalFromLocalDate,
+  extractFixedOffsetMinutes,
+  formatFixedOffset,
+  formatLocalDate,
+  formatLocalDateTime,
+  formatLocalTime,
+  localDateTimeToScalar,
+  localDateToScalar,
+  localDateToScalarStart,
+  nextDate,
+  parseLocalDate,
+  parseLocalDateTime,
+  scalarToLocalDateParts,
+  scalarToLocalDateTimeParts,
+  weekdayFromLocalDate
+});

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

@@ -1,14 +1,5 @@
-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;
+import type { AvailabilityProjection, AvailabilityProjectionInput, AvailabilityQuery, AvailabilityQueryResult, AvailabilitySelectionValidationParams, AvailabilitySelectionValidationResult, GetProductTimeRangesRequest, ProductTimeRangeGroup } from './types';
+export declare function createAvailabilityProjection(input: AvailabilityProjectionInput): AvailabilityProjection;
+export declare function getProductTimeRanges(projection: AvailabilityProjection, request?: GetProductTimeRangesRequest): ProductTimeRangeGroup[];
+export declare function queryAvailabilityProjection(projection: AvailabilityProjection, request: AvailabilityQuery): AvailabilityQueryResult;
+export declare function validateAvailabilitySelection(projection: AvailabilityProjection, params: AvailabilitySelectionValidationParams): AvailabilitySelectionValidationResult;