@pisell/pisellos 2.3.72 → 2.3.73

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;