@pisell/pisellos 0.10.8 → 0.10.10

package/dist/modules/ResourcePlanner/localClock.js

@@ -0,0 +1,183 @@
+var MINUTE_MS = 60 * 1000;
+var HOUR_MS = 60 * MINUTE_MS;
+function pad(value) {
+  var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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');
+  }
+  var 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);
+}
+export function parseLocalDate(value) {
+  var match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+  if (!match) {
+    throw new Error("Invalid local date: ".concat(value));
+  }
+  var parts = {
+    year: Number(match[1]),
+    month: Number(match[2]),
+    day: Number(match[3])
+  };
+  assertDateParts(parts);
+  return parts;
+}
+export function parseLocalDateTime(value) {
+  var 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: ".concat(value));
+  }
+  var 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;
+}
+export function extractFixedOffsetMinutes(value) {
+  if (!value) return null;
+  var trimmed = value.trim();
+  if (trimmed.toUpperCase() === 'Z') return 0;
+  var directMatch = /^([+-])(\d{2}):(\d{2})$/.exec(trimmed);
+  var suffixMatch = /([zZ]|[+-]\d{2}:\d{2})$/.exec(trimmed);
+  var target = directMatch ? trimmed : suffixMatch === null || suffixMatch === void 0 ? void 0 : suffixMatch[1];
+  if (!target) return null;
+  if (target.toUpperCase() === 'Z') return 0;
+  var match = /^([+-])(\d{2}):(\d{2})$/.exec(target);
+  if (!match) return null;
+  var minutes = Number(match[2]) * 60 + Number(match[3]);
+  return match[1] === '-' ? -minutes : minutes;
+}
+export function captureRuntimeOffsetMinutes() {
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+  return -value.getTimezoneOffset();
+}
+export function formatFixedOffset(offsetMinutes) {
+  if (offsetMinutes === null || offsetMinutes === undefined) return '';
+  if (!Number.isFinite(offsetMinutes)) {
+    throw new Error('Invalid fixed offset');
+  }
+  var normalized = Math.trunc(offsetMinutes);
+  if (normalized === 0) return 'Z';
+  var sign = normalized >= 0 ? '+' : '-';
+  var absolute = Math.abs(normalized);
+  return "".concat(sign).concat(pad(Math.floor(absolute / 60)), ":").concat(pad(absolute % 60));
+}
+export function localDateTimeToScalar(value) {
+  assertDateParts(value);
+  assertTimeParts(value);
+  return Date.UTC(value.year, value.month - 1, value.day, value.hour, value.minute, value.second, 0);
+}
+export function localDateToScalar(value) {
+  return Date.UTC(value.getFullYear(), value.getMonth(), value.getDate(), value.getHours(), value.getMinutes(), value.getSeconds(), 0);
+}
+export function localDateToScalarStart(value) {
+  var parts = localDateInputToParts(value);
+  return Date.UTC(parts.year, parts.month - 1, parts.day, 0, 0, 0, 0);
+}
+export function scalarToLocalDateParts(value) {
+  var date = scalarToDate(value);
+  return {
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate()
+  };
+}
+export function scalarToLocalDateTimeParts(value) {
+  var date = scalarToDate(value);
+  return {
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate(),
+    hour: date.getUTCHours(),
+    minute: date.getUTCMinutes(),
+    second: date.getUTCSeconds()
+  };
+}
+export function dateOrdinalFromLocalDate(value) {
+  var parts = localDateInputToParts(value);
+  return Math.floor(Date.UTC(parts.year, parts.month - 1, parts.day) / (24 * HOUR_MS));
+}
+export function weekdayFromLocalDate(value) {
+  var parts = localDateInputToParts(value);
+  return new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();
+}
+export function formatLocalDate(value) {
+  var parts = typeof value === 'number' ? scalarToLocalDateParts(value) : localDateInputToParts(value);
+  return "".concat(pad(parts.year, 4), "-").concat(pad(parts.month), "-").concat(pad(parts.day));
+}
+export function formatLocalTime(value) {
+  var includeSeconds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var parts = typeof value === 'number' ? scalarToLocalDateTimeParts(value) : typeof value === 'string' ? parseLocalDateTime(value) : value;
+  assertTimeParts(parts);
+  if (!includeSeconds) {
+    return "".concat(pad(parts.hour), ":").concat(pad(parts.minute));
+  }
+  return "".concat(pad(parts.hour), ":").concat(pad(parts.minute), ":").concat(pad(parts.second));
+}
+export function formatLocalDateTime(value, fixedOffsetMinutes) {
+  var parts = typeof value === 'number' ? scalarToLocalDateTimeParts(value) : typeof value === 'string' ? parseLocalDateTime(value) : value;
+  assertDateParts(parts);
+  assertTimeParts(parts);
+  return "".concat(formatLocalDate(parts), "T").concat(formatLocalTime(parts)).concat(formatFixedOffset(fixedOffsetMinutes));
+}
+export function addLocalMinutes(value, minutes) {
+  if (!Number.isFinite(minutes)) {
+    throw new Error('Invalid minute delta');
+  }
+  return value + Math.trunc(minutes) * MINUTE_MS;
+}
+export function addLocalHours(value, hours) {
+  if (!Number.isFinite(hours)) {
+    throw new Error('Invalid hour delta');
+  }
+  return value + Math.trunc(hours) * HOUR_MS;
+}
+export function addLocalCalendarDays(value, days) {
+  if (!Number.isFinite(days)) {
+    throw new Error('Invalid day delta');
+  }
+  var parts = scalarToLocalDateTimeParts(value);
+  return Date.UTC(parts.year, parts.month - 1, parts.day + Math.trunc(days), parts.hour, parts.minute, parts.second, 0);
+}
+export function nextDate(value) {
+  return formatLocalDate(addLocalCalendarDays(localDateToScalarStart(value), 1));
+}
+export function ceilLocalScalarToTenMinutes(value) {
+  var parts = scalarToLocalDateTimeParts(value);
+  var minuteRemainder = parts.minute % 10;
+  if (minuteRemainder === 0 && parts.second === 0) return value;
+  var deltaMinutes = parts.second === 0 ? 10 - minuteRemainder : minuteRemainder === 0 ? 10 : 10 - minuteRemainder;
+  var roundedBase = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, 0, 0);
+  return addLocalMinutes(roundedBase, deltaMinutes);
+}

package/dist/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;