@pisell/pisellos 2.2.292 → 2.2.293

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,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addLocalCalendarDays = addLocalCalendarDays;
+exports.addLocalHours = addLocalHours;
+exports.addLocalMinutes = addLocalMinutes;
+exports.captureRuntimeOffsetMinutes = captureRuntimeOffsetMinutes;
+exports.ceilLocalScalarToTenMinutes = ceilLocalScalarToTenMinutes;
+exports.dateOrdinalFromLocalDate = dateOrdinalFromLocalDate;
+exports.extractFixedOffsetMinutes = extractFixedOffsetMinutes;
+exports.formatFixedOffset = formatFixedOffset;
+exports.formatLocalDate = formatLocalDate;
+exports.formatLocalDateTime = formatLocalDateTime;
+exports.formatLocalTime = formatLocalTime;
+exports.localDateTimeToScalar = localDateTimeToScalar;
+exports.localDateToScalar = localDateToScalar;
+exports.localDateToScalarStart = localDateToScalarStart;
+exports.nextDate = nextDate;
+exports.parseLocalDate = parseLocalDate;
+exports.parseLocalDateTime = parseLocalDateTime;
+exports.scalarToLocalDateParts = scalarToLocalDateParts;
+exports.scalarToLocalDateTimeParts = scalarToLocalDateTimeParts;
+exports.weekdayFromLocalDate = weekdayFromLocalDate;
+const MINUTE_MS = 60 * 1000;
+const 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?.[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 = new Date()) {
+  return -value.getTimezoneOffset();
+}
+function formatFixedOffset(offsetMinutes) {
+  if (offsetMinutes === null || offsetMinutes === undefined) 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);
+}

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