riverbankcms 0.33.0 → 0.35.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/acceptance/matrix.mjs +3 -3
- package/dist/cli/index.mjs +528 -284
- package/dist/cli/init-docs/content/cli-reference.md +1 -2
- package/dist/cli/init-docs/content/content-management.md +18 -6
- package/dist/cli/init-docs/content/getting-started.md +4 -4
- package/dist/cli/init-docs/content/workflow-content-types.md +8 -0
- package/dist/cli/init-docs/content/workflow-preview-mode.md +1 -0
- package/dist/{entryCommands-wcOr-fKy.mjs → entryCommands-D-1ldejM.mjs} +178 -114
- package/dist/{eventUpsertInputSchema-Df67rs3n.mjs → eventUpsertInputSchema-D1CXYu1M.mjs} +3 -2
- package/dist/{load-config-CexajivS.mjs → load-config-DB_S_gdr.mjs} +2 -2
- package/dist/load-config-DSGN-x3K.mjs +4 -0
- package/dist/{plan-Bhv4iKa3.mjs → plan-CMMvs6Nr.mjs} +9 -12
- package/dist/scaffold/index.mjs +2 -2
- package/dist/{sdk-event-upsert-Y4Iyx0N4.mjs → sdk-event-upsert-DoazwQVt.mjs} +33 -3
- package/dist/{src-90EK8rKq.mjs → src-CysOxz1U.mjs} +880 -770
- package/dist/testing.mjs +4 -4
- package/package.json +1 -1
- package/dist/load-config-CKgy6Yct.mjs +0 -4
package/dist/cli/index.mjs
CHANGED
|
@@ -1,10 +1,10 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
|
-
import { $ as walkAndCollectImageAttrs, $t as flatInkParametersSchema, A as parseSiteChromeBackgroundColorToken, An as buildEntryScaffold, Ar as
|
|
3
|
-
import { $ as
|
|
4
|
-
import { $ as
|
|
5
|
-
import { r as CLI_VERSION, t as loadConfigFile } from "../load-config-
|
|
6
|
-
import { t as eventUpsertInputSchema } from "../eventUpsertInputSchema-
|
|
7
|
-
import { a as prepareScaffoldExecution, c as LOCAL_PACKAGE_VENDOR_DIR, d as loadGeneratedPackageRanges, i as preflightScaffoldTargets, n as createScaffoldCompletion, s as deriveScaffoldLocalManifest, t as deriveScaffoldPlan } from "../plan-
|
|
2
|
+
import { $ as walkAndCollectImageAttrs, $t as flatInkParametersSchema, A as parseSiteChromeBackgroundColorToken, An as buildEntryScaffold, Ar as createContentEntryRef, At as getMimeType, B as sectionStylesOverrideSchema, Bn as isResolvedInternalLinkEntityType, Bt as footerPreferencesSchema, C as blockOrderIdentifiersForCommand, Cn as bookingPaymentCollectionOptionSchema, Cr as makeBoundaryId, Ct as parseCanonicalMediaIdentifier, D as pagePathForCommand, Dn as RichTextDocSchema, Dr as createBlockRef, Dt as deriveVideoSlotPolicy, E as pageIdentifierForCommand, Er as ianaTimezoneSchema, F as defaultHeaderBrandPreferences, Fn as entryLinkSchema$1, Fr as createNavigationRef, G as headerInteractionQuietPalette, Gn as parseGradientPresetId, Gt as cardVariantRoleValues, H as skinBookingBarSchema, Hn as pageLinkSchema$1, Hr as __toESM, Ht as boxlessCardVariantValue, In as externalLinkSchema$1, Ir as createPageRef, It as classifyKnownMimeType, J as boxBackgroundOverlaySchema, Jn as asHeaderLayoutId, Jt as surfaceCardRoleValues, K as blockCustomCssRuleSchema, Kt as itemRoleValues, L as cardStylesOverrideSchema, Ln as internalLinkSchema, Lt as managementMediaLibraryUploadLimitForMimeType, M as defaultHeaderPreferences, Mn as findUnfilledSentinels, Mr as createEventSeriesRef, N as defaultHeaderNavPreferences, Nn as RESOLVED_INTERNAL_LINK_ENTITY_TYPES, Nr as createFooterRef, Nt as parseRelativeStoragePath, O as hasConfiguredBookingVertical, On as isRichTextDoc, Or as createBlocksRef, Ot as resolveVideoSelectionIntentForMediaField, P as defaultHeaderBrandPresentation, Pn as customLinkSchema$1, Pr as createFormRef, Pt as FILE_SIZE_LIMITS, Q as summarizePortableMediaReferences, Qt as flatInkHoverTreatmentSchema, R as containerStylesOverrideSchema, Rn as internalResolvedLinkSchema, Rr as createVenueRef, Rt as parseSafeDownloadFilename, S as blockIdentifierForCommand, Sr as asSiteStyleId, St as buildMediaIdentifierFromFilename, T as pageIdentifierForBlockCommand, Tn as eventCommandScheduleSchema, U as headerVariantValues, Un as ICON_PICKER_PRESETS, Ut as cardRoleSchema, V as themeSchema, Vn as linkSchema, Vr as __commonJSMin, Vt as getFontWidthRange, W as headerInteractionPaletteValues, Wn as gradientPresetIdValues, Wt as cardRoleValues, X as runtimeBoxBackgroundSchema, Xn as bookingPageLookIdValues, Xt as buttonStyleSelectionSchema, Y as boxBackgroundSchema, Yn as asHeaderStyleId, Yt as BUTTON_STYLE_IDS, Z as collectPortableMediaReferencesFromContent, Zt as editorialLinkParametersSchema, _ as mapEventCommandContent, _n as paletteTokenNameSchema, _t as resolveManagedMediaReference, an as buttonVariantIdSchema, ar as arrangementModes, at as parseAspectRatioValue, bn as changeBookingQuestionsInputSchema, br as asLayoutVariantKey, bt as mediaTypeDiscriminants, c as isEventVisibility, cn as parseOpaqueButtonColourToken, cr as headingDecorationColorTokenValues, ct as getDirectImageUrlForSiteScopedPath, d as venueManagementFields, dn as hexColorSchema, dr as visibleHeadingDecorationFamilyValues, dt as imageMediaSchema, en as quietArrowParametersSchema, er as pageDesignEditorBackgroundOverrideOwner, et as deleteEnvSpecificKeys, f as sortRecord, fn as normalizePaletteHex, fr as asAppearancePresetId, ft as mediaSchema, g as resolveEventSeriesWaitlistMapping, gn as paletteModeSchema, gr as asDesignBlockId, gt as buildRenderableMediaAssetIndex, hn as paletteColorsSchema, hr as asBoundaryOptionId, ht as videoMediaSchema, i as sdkEventUpsertOptionalFieldSchemas, in as buttonSystemSchema, ir as VARIANT_ROLES, it as isExplicitRectCrop, j as backgroundAppearanceColorTokenNames, jn as validateEntryInstance, jr as createEventCategoryRef, jt as asRecord, k as headerPreferencesSchema, kn as sanitizeHref, kr as createCommandRef, ln as PALETTE_TOKEN_NAMES, lr as isArrangementMode, lt as getImageUrl, mn as paletteColorsFromEntries, mr as asBlockOrderIndex, mt as runtimeMediaSchema, nn as buttonEffectApplicationSchema, nr as siteChromeBackgroundOverrideOwner, nt as rotateNormalizedPoint, o as classifySdkEventBookingOffer, on as buttonVisualStatesSchema, or as eventListTreatmentValues, ot as resolveMediaTransformForAspect, p as stableStringify, pn as paletteColorEntries, pr as asBlockContentVersionId, pt as persistableMediaSchema, q as customCssRuleSchema, qn as asFooterLookId, qt as openCardRoleValue, rn as buttonPressOffsetSchema, rt as normalizeWidthCandidates, sn as opaqueButtonColourTokenSchema, sr as eyebrowTreatmentValues, st as getDirectImageUrlForRelativePath, t as classifySdkEventTiming, tn as squareOutlineParametersSchema, tr as parseBookingPageLookId, tt as looksLikeUuid, u as eventCategoryManagementFields, un as blockColorTokenNames, ur as tileTreatmentValues, ut as isSiteScopedDirectImageStoragePath, vn as parseColorTokenParts, vr as asDesignPageId, vt as PUBLIC_FILE_FIELD_KINDS, w as entryIdentifierForCommand, wn as bookingPaymentTermsSchema, wt as parseMediaIdentifier, x as eventManagementTiming, xr as asPageFlowPresetId, xt as mediaIdentifierSchema, yn as parseThemeColorToken, yr as asDesignSystemTemplateId, z as headerPositioningValues, zn as internalRouteOnlyLinkSchema, zr as refSlug, zt as defaultFooterPreferences } from "../sdk-event-upsert-DoazwQVt.mjs";
|
|
3
|
+
import { $ as footerLayoutForLookId, $t as resolveBookingDisplayContext, B as parseManagementKey, Bt as deriveTotalTicketQuantity, Cn as publicEventPricingDisplay, Ct as mapDrawingSchema, Dn as resolveExactOrFreePriceDisplay, En as publicEventPricingType, F as orderedLiveRunSessions, Fr as blockInteractionContextSchema, G as parseMailingListRuntimeContext, Gt as hasBookingClosed, H as parseMailingListBlockId, Hn as formatDurationUnitLabel, Ht as bookingCutOffHoursBetween, I as resolveWholeSeriesBookingPhase, In as toNonNegativeCents, Jn as parseSiteTermsVersionId, Jt as formatDateTime, K as assessMailingListTargeting, Kt as formatDate, L as resolveWholeSeriesRunLifecycle, M as CANCELLED_SESSION_STATUS, Mt as getBookingInstalmentPlanIntervalCount, N as firstLiveRunSessionStartMs, Nr as err, Nt as getBookingInstalmentProtectedDepositAmountCents, On as resolvePricingOptionsPriceDisplay, P as nextLiveRunSessionStartMs, Pr as ok, Q as parseFooterCompositionV1, Qt as inferSiteDateLocale, R as createSecret, S as EVENT_PRESET_VALUES, Sn as publicEventPricingCurrency, Sr as parseUserId, St as trimmedStringOrNull, T as WHOLE_SERIES_EVENT_PRESET_VALUES, Tn as publicEventPricingStrategy, Tr as parseEventSeriesId, Tt as buildBookingUtcDateWindow, U as parseMailingListContentVersionId, Ut as formatBookingClosedTime, V as slugify, Vn as assertNever, W as parseMailingListSignedSourceToken, Wn as unsafeAsDemoCapability, Wt as formatBookingCutOffHours, X as DEFAULT_MAILING_LIST_SUCCESS_MESSAGE, Xt as formatTime$1, Y as DEFAULT_MAILING_LIST_PRIVACY_NOTE, Yt as formatDateTimeRange, Zt as formatTimeRange, _n as parsePageSurfaceSubject, _t as parseLocationValue, a as authoredValuesEqual, an as getBookingLocalDateKey, ar as unsafeAsMediaAssetId, at as formatOpeningHoursRows, b as resolveSiteVerticalBookingConfig, bn as formatEventPricing, br as parseApiKeyId, bt as toLocationCoordinates, d as formatCreditProductUnits, dn as parseUtcIsoDateTimeString, dt as decideLocationSave, en as toScheduledBookingDateTime, et as parseMailingListPlacementTargeting, fn as toUtcIsoDateTimeString, ft as stableJsonStringify, gt as normalizeLocationAddressText, h as NAVIGATION_LOCATIONS, hn as toBookingTimeZone, ht as locationValueSchema, i as isRecord$27, in as formatLocalScheduleTime, it as richTextHasText, jn as mapReadonlyNonEmptyArray, l as creditProductUnitNoun, ln as parseBookingLocalDate, mn as resolveBookingTimeZoneId, mt as EVENT_ADDRESS_AFTER_BOOKING_LABEL, nn as compareLocalScheduleDates, nt as planMailingListChoicePresentation, on as getLocalScheduleDate, pn as resolveBookingBusinessTimeZone, pt as locationMapLinks, qt as formatDateRange, rn as formatLocalScheduleDate, rt as isCanonicalRichTextDoc, sn as getLocalScheduleTime, sr as unsafeAsPositiveByteCount, st as parseWeeklyOpeningHours, tt as DEFAULT_MAILING_LIST_TARGETING, u as formatCreditProductPayment, un as parseLocalScheduleTime, vn as EVENT_PRESET_VOCABULARY, vt as projectPublicLocation, wn as publicEventPricingOptions, wt as selectCategoryView, xn as isPublicEventPricingOptionDisplayable, xr as parseSiteId, yn as formatBookingPriceDisplay, yt as publicLocationSchema, z as exposeSecret, zn as formatCurrencyAmount } from "../src-CysOxz1U.mjs";
|
|
4
|
+
import { $ as walkLocalContentMedia, $n as extractApiErrorMessage, $r as ApiEnvelopeError, $t as commandContexts, A as formatDiffSummary, An as isLocalConfigured, Ar as getBookingLaterInstalments, At as navigationIdentityMap, B as formatFieldChange, Bn as DEFAULT_MEDIA_FIELD_KINDS, Br as publicProductSchema, Bt as ACCOUNT_SITE_SEARCH_MAX_LENGTH, C as reportFromOutcomes, Cn as ErrorCodes, Cr as planFlexibleBalanceCreditFirst, Ct as listFiles, D as calculateDiff, Dr as resolveAvailableBookingCollectionOptions, Dt as isMediaValue, E as createEmptySyncResult, En as CliExit, Er as repriceBookingCollectionOptions, Et as writeJsonFileAtomic, F as buildJsonDiff, Fn as cardListKnobBlocks, Fr as eventCalendarListLayoutValues, Ft as createBearerAccountApi, G as applyLocalMediaPush, Gn as MAX_REPEATER_GRID_COLUMNS, Gr as calendarMonthWindowSchema, Gt as createPushConfigCommand, H as revalidateLocalMediaPushPlan, Hn as blockContentSourceSchema, Hr as purchasablePublicPassProductSchema, Ht as navigationCommandItemToManagementInput, I as hasPageOperations, In as lookKnobBlocks, Ir as publicMapLocationResultSchema, It as ACCOUNT_SITE_CURSOR_MAX_LENGTH, J as readStableBinaryFile, Jn as resolveRepeaterGridColumnFieldId, Jr as eventSurfacePresetValues, Jt as revalidatePushConfigPlan, K as prepareLocalMediaForPush, Kn as isAcceptedRepeaterGridSpan, Kr as calendarSourceCursorSchema, Kt as loadPushConfigTarget, L as pageMetadataForUpsert, Ln as NodeSchema, Lr as publicVenueMapLocationSchema, Lt as ACCOUNT_SITE_LIST_LIMIT_DEFAULT, M as findChangedFieldsWithValues, Mn as loadSdkEnvironment, Mr as eventCalendarDefaultViewValues, Mt as convertPulledNavigationToLocal, N as formatHumanDiff, Nn as cardListBlockParts, Nr as eventCalendarDisplayModeValues, Nt as convertPulledPagesToLocal, O as calculateFooterDiff, On as getEnvPrefix, Or as resolveBookingCollectionOptionFacts, Ot as duplicateNavigationIdentityMessage, P as calculatePullDiff, Pn as cardListFamilyBlocks, Pr as eventCalendarListLayoutCompatibleDisplayModeValues, Pt as AccountApiMalformedResponseError, Q as normalizeMediaValueToIdentifierOnly, Qn as ManagementApiError, Qr as publicEventLoaderQuerySchemaShape, Qt as CommandFailure, Rn as NodeTreeSchema, Rr as publicMembershipProductSchema, Rt as ACCOUNT_SITE_LIST_LIMIT_MAX, S as planCliCommandBatchForBindings, Sn as withRiverbankEnv, Sr as planCheckoutPaymentFlow, St as fileExists, T as executeResidualSettingsSyncPlan, Tn as transportSuggestion, Tr as isBookingCollectionEquivalentToUpfront, Tt as writeJsonFile, Un as blockRequiredFeatureSchema, Ur as CALENDAR_SSR_PAGE_SIZE, Ut as normalizeNavigationConfigItemForCommand, V as formatFieldPath, Vn as blockCategoryEnum, Vr as purchasablePublicMembershipProductSchema, Vt as ACCOUNT_SITE_TITLE_MAX_LENGTH, W as syncLocalMediaForPull, Wn as fieldSchema$1, Wr as calendarMonthDate, Wt as applyPushConfigPlan, X as sha256, Xn as resolveRepeaterGridSpanFieldId, Xr as monthNumber, Xt as deriveCmsApiUrlFromDashboardUrl, Y as writeBinaryFileAtomic, Yn as resolveRepeaterGridRowFieldId, Yr as eventSurfaceScopeValues, Yt as createBearerAPIClient, Z as normalizeMediaIdentifierInput, Zn as visibilityLevels, Zr as normalizeCalendarFilterId, Zt as mapEnvironmentExecutionOutcomesJson, _ as commandExecutionToReport, _n as executeEnvironmentPlan, _r as nextCombinationHint, _t as metadataTargetFromEnvironment, a as executeEntryCommandPlanAsReport, an as confirmAction, ar as linkPayloadSchema, at as readAllMeta, b as executeCompiledCliCommandPlanAsReport, bn as planEnvironmentWriteAuthorization, br as checkoutCopy, bt as writeMetadataRecordMap, c as titleFromEntryData, cn as formatDateShort, cr as pageDesignIntentSchemaVersion, ct as readFooterMeta, d as unsafeAsCliEntryIdentifier, dn as managementClientFor, dr as areEventBookingRequirementsIdentical, dt as readPagesMeta, ei as unwrapResponse, en as defineCommand, er as normalizeApiError, et as buildStorageUrl, f as unsafeAsCliFormSlug, fn as mapEntryForOutput, fr as eventBookingConsentContentKey, ft as readSettingsMeta, g as commandCompileFailureToReport, gn as runWithInvocation, gr as checkoutStatusArms, gt as metadataFilePath, h as mutationCounterForEffect, hn as resolveCommandPath, hr as resolveSelectionAttendanceMode, ht as ensureMetadataDir, i as entrySiteCommandTypes, in as bindRequestTimeout, ir as sdkSettingsUpdateSchema, it as readEntries, j as hasPendingChanges, jn as isRemoteConfigured, jr as MAX_EVENT_BOOKING_SELECTION_ITEMS, jt as convertPulledFooterToLocal, k as formatDiffDetail, kn as getEnvironmentDebugInfo, kr as getStripeMinimumChargeRequirement, kt as navigationIdentity, l as unsafeAsCliBlockIdentifier, ln as handleCommandError, lr as sdkConfiguredBookingVerticalConfigSchema, lt as readFormsMeta, m as commandReportToSyncResult, mn as parseJsonData, mr as decideSelectionAttendance, mt as writeMediaManifest, n as entryCommandCompileErrorToReport, nn as registerCommand, nr as ApiRequestError, nt as extractMediaIdentifiers, o as executeEntryCommandPlanAsSyncResult, on as createOutputForCommand, or as portablePageDesignSchema, ot as readEventCategoriesMeta, p as unsafeAsCliPageIdentifier, pn as parseJsonArray, pr as INCOMPATIBLE_ATTENDANCE_MESSAGE, pt as readVenuesMeta, q as admitBinaryWriteDestination, qn as parseRepeaterGridInteger, qr as eventScheduleScopeValues, qt as preparePushConfigTarget, r as entryCommandReportToSyncResult, rn as renderedByOwner, rr as sdkEventScheduleSchema, rt as findLegacyEntryFiles, s as syncResultForEntryCommandCompileError, sn as currentInvocationEnvelope, sr as pageDesignDecisionsV2Schema, st as readEventsMeta, t as compileEntryPushCommands, tn as defineCommandGroup, tr as isRecord$2, tt as downloadMedia, u as unsafeAsCliContentTypeKey, un as loadManagementTarget, ur as API_ENDPOINTS, ut as readNavigationMeta, v as commandReportHasFailures, vn as parseEnvironmentSelection, vr as planSelectionCombinationPrices, vt as readMetadataFile, w as mergeManySyncResults, wn as formatError, wr as flexibleBalanceDueDay, wt as readJsonFile, x as formatManagementError, xn as requireEnvironmentWriteAuthorization, xr as unsafeAsPositiveCheckoutQuantity, xt as ensureDir, y as executeCliCommandPlan, yn as planEnvironmentExecution, yr as eventRegistrationErrors, yt as writeMetadataFile, z as buildFieldChanges, zn as bindingSchema, zr as publicPassProductSchema, zt as ACCOUNT_SITE_LIST_LIMIT_MIN } from "../entryCommands-D-1ldejM.mjs";
|
|
5
|
+
import { r as CLI_VERSION, t as loadConfigFile } from "../load-config-DB_S_gdr.mjs";
|
|
6
|
+
import { t as eventUpsertInputSchema } from "../eventUpsertInputSchema-D1CXYu1M.mjs";
|
|
7
|
+
import { a as prepareScaffoldExecution, c as LOCAL_PACKAGE_VENDOR_DIR, d as loadGeneratedPackageRanges, i as preflightScaffoldTargets, n as createScaffoldCompletion, s as deriveScaffoldLocalManifest, t as deriveScaffoldPlan } from "../plan-CMMvs6Nr.mjs";
|
|
8
8
|
import { config } from "dotenv";
|
|
9
9
|
import { z } from "zod";
|
|
10
10
|
import { Command, CommanderError } from "commander";
|
|
@@ -1399,6 +1399,9 @@ function parseLocalEventRun(raw, filePath) {
|
|
|
1399
1399
|
if (!sdkEventUpsertOptionalFieldSchemas.waitlistMode.safeParse(fields$1.waitlistMode).success) {
|
|
1400
1400
|
throw new InvalidLocalEventScheduleIdentityError(filePath, "waitlistMode must be inherit, off or on");
|
|
1401
1401
|
}
|
|
1402
|
+
if (!sdkEventUpsertOptionalFieldSchemas.bookingCutOffHours.safeParse(fields$1.bookingCutOffHours).success) {
|
|
1403
|
+
throw new InvalidLocalEventScheduleIdentityError(filePath, "bookingCutOffHours must be a whole number of hours from 0 to 720, or null");
|
|
1404
|
+
}
|
|
1402
1405
|
if ("categoryRef" in fields$1) {
|
|
1403
1406
|
throw new InvalidLocalEventScheduleIdentityError(filePath, "Move categoryRef to the parent Event file");
|
|
1404
1407
|
}
|
|
@@ -2310,6 +2313,7 @@ function mapEventRunToComparable(run) {
|
|
|
2310
2313
|
occurrences: run.occurrences,
|
|
2311
2314
|
capacity: run.capacity,
|
|
2312
2315
|
waitlistMode: run.waitlistMode,
|
|
2316
|
+
bookingCutOffHours: run.bookingCutOffHours,
|
|
2313
2317
|
bookingOffer: run.bookingOffer,
|
|
2314
2318
|
venueRef: run.venueRef,
|
|
2315
2319
|
settings: run.settings,
|
|
@@ -3720,10 +3724,7 @@ function createScopedPullContent(meta, overrides) {
|
|
|
3720
3724
|
entries: {},
|
|
3721
3725
|
pages: [],
|
|
3722
3726
|
navigation: [],
|
|
3723
|
-
settings: {
|
|
3724
|
-
homepageId: null,
|
|
3725
|
-
seoDefaults: null
|
|
3726
|
-
},
|
|
3727
|
+
settings: { seoDefaults: null },
|
|
3727
3728
|
forms: [],
|
|
3728
3729
|
events: [],
|
|
3729
3730
|
eventRuns: [],
|
|
@@ -4276,6 +4277,7 @@ function normalizeRemoteRun(run) {
|
|
|
4276
4277
|
occurrences: [...run.occurrences],
|
|
4277
4278
|
capacity: run.capacity,
|
|
4278
4279
|
waitlistMode: nullishToNull(run.waitlistMode),
|
|
4280
|
+
bookingCutOffHours: nullishToNull(run.bookingCutOffHours),
|
|
4279
4281
|
bookingOffer: normalizeCanonicalBookingOffer(run.bookingOffer),
|
|
4280
4282
|
venueRef: run.venueRef,
|
|
4281
4283
|
settings: run.settings,
|
|
@@ -4297,6 +4299,7 @@ function normalizeLocalRun(local, remote) {
|
|
|
4297
4299
|
occurrences: [...local.occurrences],
|
|
4298
4300
|
capacity: overrideWhenDefined(local.capacity, base.capacity, (value) => typeof value === "number" ? value : null),
|
|
4299
4301
|
waitlistMode: local.waitlistMode === undefined ? base.waitlistMode : local.waitlistMode,
|
|
4302
|
+
bookingCutOffHours: local.bookingCutOffHours === undefined ? base.bookingCutOffHours : local.bookingCutOffHours,
|
|
4300
4303
|
bookingOffer: overrideWhenDefined(local.bookingOffer, base.bookingOffer, normalizeCanonicalBookingOffer),
|
|
4301
4304
|
venueRef: overrideWhenDefined(local.venueRef, base.venueRef, normalizeNullableString),
|
|
4302
4305
|
settings: overrideWhenDefined(local.settings, base.settings, (value) => isRecord$29(value) ? value : {}),
|
|
@@ -4335,6 +4338,7 @@ function normalizeNewLocalRun(run) {
|
|
|
4335
4338
|
occurrences: [...run.occurrences],
|
|
4336
4339
|
capacity: run.capacity ?? null,
|
|
4337
4340
|
waitlistMode: nullishToNull(run.waitlistMode),
|
|
4341
|
+
bookingCutOffHours: nullishToNull(run.bookingCutOffHours),
|
|
4338
4342
|
bookingOffer: normalizeCanonicalBookingOffer(run.bookingOffer),
|
|
4339
4343
|
venueRef: run.venueRef ?? null,
|
|
4340
4344
|
settings: run.settings ?? {},
|
|
@@ -4637,14 +4641,10 @@ async function loadGenericComparison(input) {
|
|
|
4637
4641
|
const rawRemote = await client.pull.all();
|
|
4638
4642
|
const local = shouldExcludeCanonicalEntries(canonicalEntrySyncDecision) ? stripCanonicalEventEntriesFromLocalContent(rawLocal).content : rawLocal;
|
|
4639
4643
|
const canonicalRemote = shouldExcludeCanonicalEntries(canonicalEntrySyncDecision) ? stripCanonicalEventEntriesFromPulledContent(rawRemote).content : rawRemote;
|
|
4640
|
-
const normalizedRemote = normalizeRemoteHomepageReference(canonicalRemote);
|
|
4641
|
-
if (!normalizedRemote.ok) {
|
|
4642
|
-
throw new Error(normalizedRemote.error.message);
|
|
4643
|
-
}
|
|
4644
4644
|
return {
|
|
4645
4645
|
cliConfig,
|
|
4646
4646
|
local,
|
|
4647
|
-
remote:
|
|
4647
|
+
remote: canonicalRemote
|
|
4648
4648
|
};
|
|
4649
4649
|
}
|
|
4650
4650
|
async function verifyGenericPushNoop(input) {
|
|
@@ -5439,7 +5439,7 @@ async function executeFormCommandPlan(input) {
|
|
|
5439
5439
|
slug: command.input.slug,
|
|
5440
5440
|
name: command.input.name,
|
|
5441
5441
|
schema: managementFormSchema(command.input.schema),
|
|
5442
|
-
settings: command.input.settings
|
|
5442
|
+
...command.input.settings === undefined ? {} : { settings: command.input.settings }
|
|
5443
5443
|
})).effect;
|
|
5444
5444
|
default: assertNever(commandType);
|
|
5445
5445
|
}
|
|
@@ -68022,6 +68022,7 @@ const publicWholeSeriesRunSchema = z.object({
|
|
|
68022
68022
|
eventSeriesId: z.string(),
|
|
68023
68023
|
eventOfferingId: z.string(),
|
|
68024
68024
|
enrollmentOpen: z.boolean(),
|
|
68025
|
+
bookingClosesAt: z.string().optional(),
|
|
68025
68026
|
visibility: z.enum(["public", "unlisted"]),
|
|
68026
68027
|
lifecycle: z.enum([
|
|
68027
68028
|
"upcoming",
|
|
@@ -68067,6 +68068,7 @@ const publicEventBaseSchema = z.object({
|
|
|
68067
68068
|
requiresRegistration: z.boolean(),
|
|
68068
68069
|
bookingAvailability: publicEventBookingAvailabilitySchema,
|
|
68069
68070
|
bookingClosedDetail: publicEventBookingClosedDetailSchema.optional(),
|
|
68071
|
+
bookingClosesAt: z.string().optional(),
|
|
68070
68072
|
deliveryMode: z.enum([
|
|
68071
68073
|
"in_person",
|
|
68072
68074
|
"online",
|
|
@@ -72571,11 +72573,12 @@ function renderCalendarFeedIcs(feed, timezoneGenerator) {
|
|
|
72571
72573
|
language: "EN"
|
|
72572
72574
|
},
|
|
72573
72575
|
timezone: feed.timezone === "UTC" ? null : {
|
|
72574
|
-
name:
|
|
72576
|
+
name: null,
|
|
72575
72577
|
generator: timezoneGenerator
|
|
72576
72578
|
},
|
|
72577
72579
|
url: feed.url ?? null
|
|
72578
72580
|
});
|
|
72581
|
+
if (feed.timezone !== "UTC") calendar.x("X-WR-TIMEZONE", feed.timezone);
|
|
72579
72582
|
const generatedAt = new Date();
|
|
72580
72583
|
feed.entries.forEach((entry) => calendar.createEvent(calendarEvent(entry, generatedAt)));
|
|
72581
72584
|
return calendar.toString();
|
|
@@ -79780,11 +79783,19 @@ function rowFor(rows, mode) {
|
|
|
79780
79783
|
* capacity comes from the shared event-domain helpers so uncapped, fallback,
|
|
79781
79784
|
* and hybrid attendance-mode cases agree with the registration runtime.
|
|
79782
79785
|
*/
|
|
79783
|
-
function isBookableEvent(event) {
|
|
79786
|
+
function isBookableEvent(event, now) {
|
|
79784
79787
|
if (!event.requiresRegistration) return false;
|
|
79785
79788
|
if (event.bookingAvailability.kind !== "open") return false;
|
|
79789
|
+
if (now && hasEventBookingClosedEarly(event, now)) return false;
|
|
79786
79790
|
return !isEventFull(event) || canJoinEventWaitlistOnAnyMode(event);
|
|
79787
79791
|
}
|
|
79792
|
+
/**
|
|
79793
|
+
* Whether a date has passed its cut-off by this clock. The projected availability
|
|
79794
|
+
* can be older than the page it's on, and a cut-off makes that gap matter more.
|
|
79795
|
+
*/
|
|
79796
|
+
function hasEventBookingClosedEarly(event, now) {
|
|
79797
|
+
return event.bookingClosesAt !== undefined && hasBookingClosed(event.bookingClosesAt, now);
|
|
79798
|
+
}
|
|
79788
79799
|
|
|
79789
79800
|
//#endregion
|
|
79790
79801
|
//#region ../blocks/src/system/blocks/events/shared/pageSelection.ts
|
|
@@ -79845,7 +79856,7 @@ function planOrdinarySeriesSelection(events) {
|
|
|
79845
79856
|
const ordinary = events.filter(isOrdinaryPublicEvent);
|
|
79846
79857
|
const firstSeriesId = ordinary[0]?.seriesId;
|
|
79847
79858
|
if (!firstSeriesId || ordinary.some((event$1) => event$1.seriesId !== firstSeriesId)) return null;
|
|
79848
|
-
const bookable = ordinary.filter(isBookableEvent);
|
|
79859
|
+
const bookable = ordinary.filter((event$1) => isBookableEvent(event$1));
|
|
79849
79860
|
const [first, second] = bookable;
|
|
79850
79861
|
if (first && second) {
|
|
79851
79862
|
const [a$1, b$1, ...rest] = [...ordinary].filter(isOpenForBooking).sort((left, right) => Date.parse(left.startsAt) - Date.parse(right.startsAt));
|
|
@@ -80103,6 +80114,248 @@ function isCancelledOrdinaryDate(event) {
|
|
|
80103
80114
|
//#region ../blocks/src/system/blocks/shared/bookingPageKind.ts
|
|
80104
80115
|
const bookingPageKindSchema = z.enum(["fullPage", "bookingPage"]);
|
|
80105
80116
|
|
|
80117
|
+
//#endregion
|
|
80118
|
+
//#region ../blocks/src/system/runtime/nodes/events/domain/dates.ts
|
|
80119
|
+
/** Event presentation adapters; core owns projection, clocks and ranges. */
|
|
80120
|
+
function eventDateLocale(siteTimeZone) {
|
|
80121
|
+
return inferSiteDateLocale(siteTimeZone);
|
|
80122
|
+
}
|
|
80123
|
+
function eventCalendarWeekStart(timeZone, override) {
|
|
80124
|
+
return override ?? (inferSiteDateLocale(resolveBookingBusinessTimeZone(timeZone)) === "en-US" ? "sunday" : "monday");
|
|
80125
|
+
}
|
|
80126
|
+
/** Admit older wire zones once; the booking business fallback remains London. */
|
|
80127
|
+
function eventDateOptions(place) {
|
|
80128
|
+
const siteTimeZone = resolveBookingBusinessTimeZone(place.siteTimeZone);
|
|
80129
|
+
const resolved = resolveBookingDisplayContext({
|
|
80130
|
+
sessionTimeZone: resolveBookingTimeZoneId(place.timeZone, siteTimeZone),
|
|
80131
|
+
siteTimeZone,
|
|
80132
|
+
locale: inferSiteDateLocale(siteTimeZone),
|
|
80133
|
+
isOnline: place.isOnline === true || place.deliveryMode === "online" || place.deliveryMode === "hybrid",
|
|
80134
|
+
surface: "public"
|
|
80135
|
+
});
|
|
80136
|
+
return {
|
|
80137
|
+
...resolved.context,
|
|
80138
|
+
zone: resolved.zone
|
|
80139
|
+
};
|
|
80140
|
+
}
|
|
80141
|
+
/** Overnight spans keep their end day; folds retain both distinct offsets. */
|
|
80142
|
+
function formatEventTimeRange(times, options) {
|
|
80143
|
+
const start = toUtcIsoDateTimeString(times.startsAt);
|
|
80144
|
+
const end = toUtcIsoDateTimeString(times.endsAt);
|
|
80145
|
+
const startDay = getLocalScheduleDate(new Date(start), options.timeZone);
|
|
80146
|
+
const endDay = getLocalScheduleDate(new Date(end), options.timeZone);
|
|
80147
|
+
return startDay.year === endDay.year && startDay.month === endDay.month && startDay.day === endDay.day ? formatTimeRange(start, end, options, { zone: options.zone }) : formatDateTimeRange({
|
|
80148
|
+
start,
|
|
80149
|
+
end
|
|
80150
|
+
}, options, {
|
|
80151
|
+
date: "short",
|
|
80152
|
+
zone: options.zone
|
|
80153
|
+
});
|
|
80154
|
+
}
|
|
80155
|
+
function resolveEventTimeZone(event, calendarTimeZone) {
|
|
80156
|
+
return resolveBookingTimeZoneId(event.timeZone, resolveBookingBusinessTimeZone(calendarTimeZone));
|
|
80157
|
+
}
|
|
80158
|
+
function formatDate$1(isoTimestamp, options) {
|
|
80159
|
+
return formatDate({
|
|
80160
|
+
kind: "instant",
|
|
80161
|
+
value: toUtcIsoDateTimeString(isoTimestamp)
|
|
80162
|
+
}, options, {
|
|
80163
|
+
date: "short",
|
|
80164
|
+
weekday: "long"
|
|
80165
|
+
});
|
|
80166
|
+
}
|
|
80167
|
+
function formatTime(isoTimestamp, options) {
|
|
80168
|
+
return formatTime$1(toUtcIsoDateTimeString(isoTimestamp), options, { zone: options.zone });
|
|
80169
|
+
}
|
|
80170
|
+
function formatEventDateParts(args) {
|
|
80171
|
+
return {
|
|
80172
|
+
date: formatDate$1(args.startsAt, args),
|
|
80173
|
+
timeRange: formatEventTimeRange(args, args)
|
|
80174
|
+
};
|
|
80175
|
+
}
|
|
80176
|
+
/** A course run's first to last session date, such as `8–22 Sept 2026`. */
|
|
80177
|
+
function formatEventRunDates(first, last, options) {
|
|
80178
|
+
return formatDateRange({
|
|
80179
|
+
kind: "instant",
|
|
80180
|
+
value: toUtcIsoDateTimeString(first.startsAt)
|
|
80181
|
+
}, {
|
|
80182
|
+
kind: "instant",
|
|
80183
|
+
value: toUtcIsoDateTimeString(last.startsAt)
|
|
80184
|
+
}, options, {
|
|
80185
|
+
date: "short",
|
|
80186
|
+
order: "session"
|
|
80187
|
+
});
|
|
80188
|
+
}
|
|
80189
|
+
/** Civil calendar headings never acquire an instant's timezone shift. */
|
|
80190
|
+
function formatCalendarTitle(viewDate, view, days, timeZone) {
|
|
80191
|
+
const context = eventDateOptions({
|
|
80192
|
+
siteTimeZone: timeZone,
|
|
80193
|
+
timeZone
|
|
80194
|
+
});
|
|
80195
|
+
const first = days[0];
|
|
80196
|
+
const last = days[6];
|
|
80197
|
+
return view === "week" && first && last ? formatDateRange({
|
|
80198
|
+
kind: "civil",
|
|
80199
|
+
value: first
|
|
80200
|
+
}, {
|
|
80201
|
+
kind: "civil",
|
|
80202
|
+
value: last
|
|
80203
|
+
}, context, { date: "short" }) : formatDate({
|
|
80204
|
+
kind: "civil",
|
|
80205
|
+
value: viewDate
|
|
80206
|
+
}, context, {
|
|
80207
|
+
date: "long",
|
|
80208
|
+
day: "omit"
|
|
80209
|
+
});
|
|
80210
|
+
}
|
|
80211
|
+
function buildCalendarViewport(input) {
|
|
80212
|
+
const viewport = buildCalendarViewport$1(input);
|
|
80213
|
+
return {
|
|
80214
|
+
...viewport,
|
|
80215
|
+
title: formatCalendarTitle(input.anchorDate, input.view, viewport.days, input.timeZone)
|
|
80216
|
+
};
|
|
80217
|
+
}
|
|
80218
|
+
/** Tick digits are civil clock values, not session instants. */
|
|
80219
|
+
function formatEventHourLabel(hour, timeZone) {
|
|
80220
|
+
return formatEventClockLabel(`${String(hour % 24).padStart(2, "0")}:00`, eventDateLocale(timeZone));
|
|
80221
|
+
}
|
|
80222
|
+
/** Weekly cadence and tick clocks are civil values; UTC only carries their components. */
|
|
80223
|
+
function formatEventClockLabel(value, locale) {
|
|
80224
|
+
const clock = parseLocalScheduleTime(value);
|
|
80225
|
+
return formatTime$1(toUtcIsoDateTimeString(new Date(Date.UTC(2e3, 0, 1, clock.hour, clock.minute)).toISOString()), {
|
|
80226
|
+
locale,
|
|
80227
|
+
timeZone: resolveBookingBusinessTimeZone("UTC")
|
|
80228
|
+
}, { zone: "omit" });
|
|
80229
|
+
}
|
|
80230
|
+
function formatEventCompactDateRail(isoTimestamp, options, letterCase = "capitals") {
|
|
80231
|
+
const instant = {
|
|
80232
|
+
kind: "instant",
|
|
80233
|
+
value: toUtcIsoDateTimeString(isoTimestamp)
|
|
80234
|
+
};
|
|
80235
|
+
const cased = (value) => letterCase === "capitals" ? value.toLocaleUpperCase(options.locale) : value;
|
|
80236
|
+
return {
|
|
80237
|
+
weekday: cased(formatDate(instant, options, {
|
|
80238
|
+
date: "omit",
|
|
80239
|
+
weekday: "short",
|
|
80240
|
+
year: "omit"
|
|
80241
|
+
})),
|
|
80242
|
+
fullWeekday: formatDate(instant, options, {
|
|
80243
|
+
date: "omit",
|
|
80244
|
+
weekday: "long",
|
|
80245
|
+
year: "omit"
|
|
80246
|
+
}),
|
|
80247
|
+
day: formatDate(instant, options, {
|
|
80248
|
+
date: "omit",
|
|
80249
|
+
day: "numeric",
|
|
80250
|
+
year: "omit"
|
|
80251
|
+
}),
|
|
80252
|
+
month: cased(formatDate(instant, options, {
|
|
80253
|
+
date: "short",
|
|
80254
|
+
day: "omit",
|
|
80255
|
+
year: "omit"
|
|
80256
|
+
}).slice(0, 3)),
|
|
80257
|
+
label: formatDate(instant, options, {
|
|
80258
|
+
date: "long",
|
|
80259
|
+
weekday: "long"
|
|
80260
|
+
})
|
|
80261
|
+
};
|
|
80262
|
+
}
|
|
80263
|
+
/**
|
|
80264
|
+
* Format the next occurrence for the image-free catalogue card treatment.
|
|
80265
|
+
*
|
|
80266
|
+
* The compact rail already owns this short, booking-local date vocabulary;
|
|
80267
|
+
* keep the fact panel on the same date and timezone rules as event rows.
|
|
80268
|
+
*/
|
|
80269
|
+
function formatEventNextDateFact(event) {
|
|
80270
|
+
const rail = formatEventCompactDateRail(event.startsAt, eventDateOptions(event));
|
|
80271
|
+
return {
|
|
80272
|
+
dateTime: event.startsAt,
|
|
80273
|
+
value: `${rail.weekday} ${rail.day} ${rail.month}`,
|
|
80274
|
+
label: rail.label
|
|
80275
|
+
};
|
|
80276
|
+
}
|
|
80277
|
+
/**
|
|
80278
|
+
* Group events by their local date (YYYY-MM-DD key in each event's own
|
|
80279
|
+
* timezone). Thin domain wrapper over `groupItemsByDate` from the calendar
|
|
80280
|
+
* package; preserves the historical `Map<string, PublicEvent[]>` shape.
|
|
80281
|
+
*/
|
|
80282
|
+
function groupEventsByDate(events, calendarTimeZone) {
|
|
80283
|
+
const grouped = groupItemsByDate(events, {
|
|
80284
|
+
getStartsAt: (event) => event.startsAt,
|
|
80285
|
+
getTimeZone: () => calendarTimeZone
|
|
80286
|
+
});
|
|
80287
|
+
return new Map([...grouped].map(([dateKey, bucket]) => [dateKey, [...bucket]]));
|
|
80288
|
+
}
|
|
80289
|
+
/** Stable local-day identity shared by ledger continuations and day groups. */
|
|
80290
|
+
function eventLocalDateKey(event) {
|
|
80291
|
+
return getBookingLocalDateKey(toScheduledBookingDateTime({
|
|
80292
|
+
startsAt: event.startsAt,
|
|
80293
|
+
timeZone: resolveBookingBusinessTimeZone(event.timeZone),
|
|
80294
|
+
locale: "en-GB"
|
|
80295
|
+
}));
|
|
80296
|
+
}
|
|
80297
|
+
/** Full weekday and the existing zone-aware time range for a weekly running list. */
|
|
80298
|
+
function formatEventWeekdayTime(event) {
|
|
80299
|
+
const options = eventDateOptions(event);
|
|
80300
|
+
const weekday = formatDate({
|
|
80301
|
+
kind: "instant",
|
|
80302
|
+
value: toUtcIsoDateTimeString(event.startsAt)
|
|
80303
|
+
}, options, {
|
|
80304
|
+
date: "omit",
|
|
80305
|
+
weekday: "long",
|
|
80306
|
+
year: "omit"
|
|
80307
|
+
});
|
|
80308
|
+
return `${weekday} · ${formatEventTimeRange(event, options)}`;
|
|
80309
|
+
}
|
|
80310
|
+
|
|
80311
|
+
//#endregion
|
|
80312
|
+
//#region ../blocks/src/system/runtime/nodes/event-registration/closedEarlyCopy.ts
|
|
80313
|
+
const isWeekly$1 = (event) => event.scheduleScope === "recurring";
|
|
80314
|
+
function eventTimeZone(event) {
|
|
80315
|
+
return eventDateOptions(event).timeZone;
|
|
80316
|
+
}
|
|
80317
|
+
/** On a date's own read both `path` and the destination name that date; its event's page is one level up. */
|
|
80318
|
+
function eventOwnPagePath(event) {
|
|
80319
|
+
const path$3 = getPublicEventCanonicalPath(event);
|
|
80320
|
+
const dateSegment = `/${event.occurrenceId}`;
|
|
80321
|
+
return path$3?.endsWith(dateSegment) ? path$3.slice(0, -dateSegment.length) || "/" : path$3;
|
|
80322
|
+
}
|
|
80323
|
+
/** "Bookings close 2 hours before the start.", while they're still open. */
|
|
80324
|
+
function openBookingLine(event) {
|
|
80325
|
+
if (!event.bookingClosesAt) return null;
|
|
80326
|
+
const before = formatBookingCutOffHours(bookingCutOffHoursBetween(event.startsAt, event.bookingClosesAt));
|
|
80327
|
+
return isWeekly$1(event) ? `Bookings for each date close ${before} before the start.` : `Bookings close ${before} before the start.`;
|
|
80328
|
+
}
|
|
80329
|
+
/** The course's open line, counted from its first session still running. */
|
|
80330
|
+
function openRunBookingLine(run) {
|
|
80331
|
+
const first = orderedLiveRunSessions(run.sessions)[0];
|
|
80332
|
+
if (!run.bookingClosesAt || !first) return null;
|
|
80333
|
+
return `Bookings close ${formatBookingCutOffHours(bookingCutOffHoursBetween(first.startsAt, run.bookingClosesAt))} before the first session.`;
|
|
80334
|
+
}
|
|
80335
|
+
/** One date between its cut-off and its start, or null. */
|
|
80336
|
+
function closedDateCopy(event, now) {
|
|
80337
|
+
const closesAt = event.bookingClosesAt;
|
|
80338
|
+
if (!closesAt || !hasBookingClosed(closesAt, now) || Date.parse(event.startsAt) <= now.getTime()) return null;
|
|
80339
|
+
const zone = eventTimeZone(event);
|
|
80340
|
+
const closed = formatBookingClosedTime(closesAt, event.startsAt, zone);
|
|
80341
|
+
const start = formatBookingClosedTime(event.startsAt, event.startsAt, zone);
|
|
80342
|
+
const before = formatBookingCutOffHours(bookingCutOffHoursBetween(event.startsAt, closesAt));
|
|
80343
|
+
const weekly = isWeekly$1(event);
|
|
80344
|
+
return {
|
|
80345
|
+
titleText: weekly ? "Bookings for this date have closed" : "Bookings for this event have closed",
|
|
80346
|
+
bodyText: `Bookings closed at ${closed}, ${before} before the ${start} start. The organiser may still be able to help if you’d like to come.`,
|
|
80347
|
+
otherDatesHref: weekly ? eventOwnPagePath(event) : null
|
|
80348
|
+
};
|
|
80349
|
+
}
|
|
80350
|
+
/** The body of a course past its cut-off, or null if the run doesn't say when. */
|
|
80351
|
+
function closedRunBody(run) {
|
|
80352
|
+
const first = orderedLiveRunSessions(run.sessions)[0];
|
|
80353
|
+
if (!run.bookingClosesAt || !first) return null;
|
|
80354
|
+
const closed = formatBookingClosedTime(run.bookingClosesAt, first.startsAt, first.timeZone);
|
|
80355
|
+
const before = formatBookingCutOffHours(bookingCutOffHoursBetween(first.startsAt, run.bookingClosesAt));
|
|
80356
|
+
return `Bookings closed at ${closed}, ${before} before the first session. The organiser may still be able to help if you’d like to join.`;
|
|
80357
|
+
}
|
|
80358
|
+
|
|
80106
80359
|
//#endregion
|
|
80107
80360
|
//#region ../blocks/src/system/runtime/nodes/event-registration/closedRunCopy.ts
|
|
80108
80361
|
const copy = {
|
|
@@ -80118,6 +80371,10 @@ const copy = {
|
|
|
80118
80371
|
titleText: "These dates have finished",
|
|
80119
80372
|
bodyText: "The details are kept here for reference."
|
|
80120
80373
|
},
|
|
80374
|
+
"bookings-closed": {
|
|
80375
|
+
titleText: "Bookings for these dates have closed",
|
|
80376
|
+
bodyText: "Bookings for these dates have closed. The organiser may still be able to help if you’d like to join."
|
|
80377
|
+
},
|
|
80121
80378
|
"enrolment-closed": {
|
|
80122
80379
|
titleText: "Booking closed",
|
|
80123
80380
|
bodyText: "Bookings are no longer being taken for these dates."
|
|
@@ -80127,8 +80384,28 @@ const copy = {
|
|
|
80127
80384
|
bodyText: "There are no dates to book at the moment. The organiser may add more, and anything already booked still stands."
|
|
80128
80385
|
}
|
|
80129
80386
|
};
|
|
80130
|
-
|
|
80131
|
-
|
|
80387
|
+
/** A run past its cut-off says when it closed, if it can. */
|
|
80388
|
+
function closedRunCopy(reason, run) {
|
|
80389
|
+
const body = reason === "bookings-closed" && run ? closedRunBody(run) : null;
|
|
80390
|
+
return body ? {
|
|
80391
|
+
...copy[reason],
|
|
80392
|
+
bodyText: body
|
|
80393
|
+
} : copy[reason];
|
|
80394
|
+
}
|
|
80395
|
+
/**
|
|
80396
|
+
* A list of dates closes once none is left to book and at least one stopped at
|
|
80397
|
+
* its cut-off. Until then the closed ones just leave the list. There's nothing
|
|
80398
|
+
* further to point at, so the copy offers no other dates.
|
|
80399
|
+
*/
|
|
80400
|
+
function closedDatesCopy(dates, now) {
|
|
80401
|
+
const stillOpen = dates.some((date) => Date.parse(date.startsAt) > now.getTime() && !(date.bookingClosesAt && hasBookingClosed(date.bookingClosesAt, now)));
|
|
80402
|
+
if (stillOpen) return null;
|
|
80403
|
+
const [firstClosed] = dates.flatMap((date) => closedDateCopy(date, now) ?? []);
|
|
80404
|
+
if (!firstClosed) return null;
|
|
80405
|
+
return {
|
|
80406
|
+
...dates.length > 1 ? copy["bookings-closed"] : firstClosed,
|
|
80407
|
+
otherDatesHref: null
|
|
80408
|
+
};
|
|
80132
80409
|
}
|
|
80133
80410
|
|
|
80134
80411
|
//#endregion
|
|
@@ -80538,9 +80815,17 @@ function occurrenceCardAvailability(event, count) {
|
|
|
80538
80815
|
status: availability.isFull ? "full" : availability.status === "filling" ? "low" : "available"
|
|
80539
80816
|
} : null;
|
|
80540
80817
|
}
|
|
80541
|
-
/** Preserve projected closure reasons; only an open native
|
|
80818
|
+
/** Preserve projected closure reasons; only an open native booking needs its clock rechecked. */
|
|
80542
80819
|
function renderClockClosedCta(event, now) {
|
|
80543
|
-
if (!now || event.
|
|
80820
|
+
if (!now || event.destination.kind !== "native") return null;
|
|
80821
|
+
if (event.bookingScope !== "whole_series") {
|
|
80822
|
+
return hasEventBookingClosedEarly(event, now) ? {
|
|
80823
|
+
label: "Registration closed",
|
|
80824
|
+
href: resolveEventHref(event),
|
|
80825
|
+
external: false,
|
|
80826
|
+
hidden: true
|
|
80827
|
+
} : null;
|
|
80828
|
+
}
|
|
80544
80829
|
const phase = resolveWholeSeriesBookingPhase(event.run, now);
|
|
80545
80830
|
if (phase.kind === "open") return null;
|
|
80546
80831
|
const label$1 = (() => {
|
|
@@ -80548,6 +80833,7 @@ function renderClockClosedCta(event, now) {
|
|
|
80548
80833
|
case "cancelled": return "Cancelled";
|
|
80549
80834
|
case "completed": return "Completed";
|
|
80550
80835
|
case "in-progress":
|
|
80836
|
+
case "bookings-closed":
|
|
80551
80837
|
case "enrolment-closed":
|
|
80552
80838
|
case "no-sessions": return "Registration closed";
|
|
80553
80839
|
default: return assertNever(phase.reason);
|
|
@@ -80557,204 +80843,10 @@ function renderClockClosedCta(event, now) {
|
|
|
80557
80843
|
label: label$1,
|
|
80558
80844
|
href: resolveEventHref(event),
|
|
80559
80845
|
external: false,
|
|
80560
|
-
hidden: phase.reason !== "enrolment-closed"
|
|
80846
|
+
hidden: phase.reason !== "enrolment-closed" && phase.reason !== "bookings-closed"
|
|
80561
80847
|
};
|
|
80562
80848
|
}
|
|
80563
80849
|
|
|
80564
|
-
//#endregion
|
|
80565
|
-
//#region ../blocks/src/system/runtime/nodes/events/domain/dates.ts
|
|
80566
|
-
/** Event presentation adapters; core owns projection, clocks and ranges. */
|
|
80567
|
-
function eventDateLocale(siteTimeZone) {
|
|
80568
|
-
return inferSiteDateLocale(siteTimeZone);
|
|
80569
|
-
}
|
|
80570
|
-
function eventCalendarWeekStart(timeZone, override) {
|
|
80571
|
-
return override ?? (inferSiteDateLocale(resolveBookingBusinessTimeZone(timeZone)) === "en-US" ? "sunday" : "monday");
|
|
80572
|
-
}
|
|
80573
|
-
/** Admit older wire zones once; the booking business fallback remains London. */
|
|
80574
|
-
function eventDateOptions(place) {
|
|
80575
|
-
const siteTimeZone = resolveBookingBusinessTimeZone(place.siteTimeZone);
|
|
80576
|
-
const resolved = resolveBookingDisplayContext({
|
|
80577
|
-
sessionTimeZone: resolveBookingTimeZoneId(place.timeZone, siteTimeZone),
|
|
80578
|
-
siteTimeZone,
|
|
80579
|
-
locale: inferSiteDateLocale(siteTimeZone),
|
|
80580
|
-
isOnline: place.isOnline === true || place.deliveryMode === "online" || place.deliveryMode === "hybrid",
|
|
80581
|
-
surface: "public"
|
|
80582
|
-
});
|
|
80583
|
-
return {
|
|
80584
|
-
...resolved.context,
|
|
80585
|
-
zone: resolved.zone
|
|
80586
|
-
};
|
|
80587
|
-
}
|
|
80588
|
-
/** Overnight spans keep their end day; folds retain both distinct offsets. */
|
|
80589
|
-
function formatEventTimeRange(times, options) {
|
|
80590
|
-
const start = toUtcIsoDateTimeString(times.startsAt);
|
|
80591
|
-
const end = toUtcIsoDateTimeString(times.endsAt);
|
|
80592
|
-
const startDay = getLocalScheduleDate(new Date(start), options.timeZone);
|
|
80593
|
-
const endDay = getLocalScheduleDate(new Date(end), options.timeZone);
|
|
80594
|
-
return startDay.year === endDay.year && startDay.month === endDay.month && startDay.day === endDay.day ? formatTimeRange(start, end, options, { zone: options.zone }) : formatDateTimeRange({
|
|
80595
|
-
start,
|
|
80596
|
-
end
|
|
80597
|
-
}, options, {
|
|
80598
|
-
date: "short",
|
|
80599
|
-
zone: options.zone
|
|
80600
|
-
});
|
|
80601
|
-
}
|
|
80602
|
-
function resolveEventTimeZone(event, calendarTimeZone) {
|
|
80603
|
-
return resolveBookingTimeZoneId(event.timeZone, resolveBookingBusinessTimeZone(calendarTimeZone));
|
|
80604
|
-
}
|
|
80605
|
-
function formatDate$1(isoTimestamp, options) {
|
|
80606
|
-
return formatDate({
|
|
80607
|
-
kind: "instant",
|
|
80608
|
-
value: toUtcIsoDateTimeString(isoTimestamp)
|
|
80609
|
-
}, options, {
|
|
80610
|
-
date: "short",
|
|
80611
|
-
weekday: "long"
|
|
80612
|
-
});
|
|
80613
|
-
}
|
|
80614
|
-
function formatTime(isoTimestamp, options) {
|
|
80615
|
-
return formatTime$1(toUtcIsoDateTimeString(isoTimestamp), options, { zone: options.zone });
|
|
80616
|
-
}
|
|
80617
|
-
function formatEventDateParts(args) {
|
|
80618
|
-
return {
|
|
80619
|
-
date: formatDate$1(args.startsAt, args),
|
|
80620
|
-
timeRange: formatEventTimeRange(args, args)
|
|
80621
|
-
};
|
|
80622
|
-
}
|
|
80623
|
-
/** A course run's first to last session date, such as `8–22 Sept 2026`. */
|
|
80624
|
-
function formatEventRunDates(first, last, options) {
|
|
80625
|
-
return formatDateRange({
|
|
80626
|
-
kind: "instant",
|
|
80627
|
-
value: toUtcIsoDateTimeString(first.startsAt)
|
|
80628
|
-
}, {
|
|
80629
|
-
kind: "instant",
|
|
80630
|
-
value: toUtcIsoDateTimeString(last.startsAt)
|
|
80631
|
-
}, options, {
|
|
80632
|
-
date: "short",
|
|
80633
|
-
order: "session"
|
|
80634
|
-
});
|
|
80635
|
-
}
|
|
80636
|
-
/** Civil calendar headings never acquire an instant's timezone shift. */
|
|
80637
|
-
function formatCalendarTitle(viewDate, view, days, timeZone) {
|
|
80638
|
-
const context = eventDateOptions({
|
|
80639
|
-
siteTimeZone: timeZone,
|
|
80640
|
-
timeZone
|
|
80641
|
-
});
|
|
80642
|
-
const first = days[0];
|
|
80643
|
-
const last = days[6];
|
|
80644
|
-
return view === "week" && first && last ? formatDateRange({
|
|
80645
|
-
kind: "civil",
|
|
80646
|
-
value: first
|
|
80647
|
-
}, {
|
|
80648
|
-
kind: "civil",
|
|
80649
|
-
value: last
|
|
80650
|
-
}, context, { date: "short" }) : formatDate({
|
|
80651
|
-
kind: "civil",
|
|
80652
|
-
value: viewDate
|
|
80653
|
-
}, context, {
|
|
80654
|
-
date: "long",
|
|
80655
|
-
day: "omit"
|
|
80656
|
-
});
|
|
80657
|
-
}
|
|
80658
|
-
function buildCalendarViewport(input) {
|
|
80659
|
-
const viewport = buildCalendarViewport$1(input);
|
|
80660
|
-
return {
|
|
80661
|
-
...viewport,
|
|
80662
|
-
title: formatCalendarTitle(input.anchorDate, input.view, viewport.days, input.timeZone)
|
|
80663
|
-
};
|
|
80664
|
-
}
|
|
80665
|
-
/** Tick digits are civil clock values, not session instants. */
|
|
80666
|
-
function formatEventHourLabel(hour, timeZone) {
|
|
80667
|
-
return formatEventClockLabel(`${String(hour % 24).padStart(2, "0")}:00`, eventDateLocale(timeZone));
|
|
80668
|
-
}
|
|
80669
|
-
/** Weekly cadence and tick clocks are civil values; UTC only carries their components. */
|
|
80670
|
-
function formatEventClockLabel(value, locale) {
|
|
80671
|
-
const clock = parseLocalScheduleTime(value);
|
|
80672
|
-
return formatTime$1(toUtcIsoDateTimeString(new Date(Date.UTC(2e3, 0, 1, clock.hour, clock.minute)).toISOString()), {
|
|
80673
|
-
locale,
|
|
80674
|
-
timeZone: resolveBookingBusinessTimeZone("UTC")
|
|
80675
|
-
}, { zone: "omit" });
|
|
80676
|
-
}
|
|
80677
|
-
function formatEventCompactDateRail(isoTimestamp, options, letterCase = "capitals") {
|
|
80678
|
-
const instant = {
|
|
80679
|
-
kind: "instant",
|
|
80680
|
-
value: toUtcIsoDateTimeString(isoTimestamp)
|
|
80681
|
-
};
|
|
80682
|
-
const cased = (value) => letterCase === "capitals" ? value.toLocaleUpperCase(options.locale) : value;
|
|
80683
|
-
return {
|
|
80684
|
-
weekday: cased(formatDate(instant, options, {
|
|
80685
|
-
date: "omit",
|
|
80686
|
-
weekday: "short",
|
|
80687
|
-
year: "omit"
|
|
80688
|
-
})),
|
|
80689
|
-
fullWeekday: formatDate(instant, options, {
|
|
80690
|
-
date: "omit",
|
|
80691
|
-
weekday: "long",
|
|
80692
|
-
year: "omit"
|
|
80693
|
-
}),
|
|
80694
|
-
day: formatDate(instant, options, {
|
|
80695
|
-
date: "omit",
|
|
80696
|
-
day: "numeric",
|
|
80697
|
-
year: "omit"
|
|
80698
|
-
}),
|
|
80699
|
-
month: cased(formatDate(instant, options, {
|
|
80700
|
-
date: "short",
|
|
80701
|
-
day: "omit",
|
|
80702
|
-
year: "omit"
|
|
80703
|
-
}).slice(0, 3)),
|
|
80704
|
-
label: formatDate(instant, options, {
|
|
80705
|
-
date: "long",
|
|
80706
|
-
weekday: "long"
|
|
80707
|
-
})
|
|
80708
|
-
};
|
|
80709
|
-
}
|
|
80710
|
-
/**
|
|
80711
|
-
* Format the next occurrence for the image-free catalogue card treatment.
|
|
80712
|
-
*
|
|
80713
|
-
* The compact rail already owns this short, booking-local date vocabulary;
|
|
80714
|
-
* keep the fact panel on the same date and timezone rules as event rows.
|
|
80715
|
-
*/
|
|
80716
|
-
function formatEventNextDateFact(event) {
|
|
80717
|
-
const rail = formatEventCompactDateRail(event.startsAt, eventDateOptions(event));
|
|
80718
|
-
return {
|
|
80719
|
-
dateTime: event.startsAt,
|
|
80720
|
-
value: `${rail.weekday} ${rail.day} ${rail.month}`,
|
|
80721
|
-
label: rail.label
|
|
80722
|
-
};
|
|
80723
|
-
}
|
|
80724
|
-
/**
|
|
80725
|
-
* Group events by their local date (YYYY-MM-DD key in each event's own
|
|
80726
|
-
* timezone). Thin domain wrapper over `groupItemsByDate` from the calendar
|
|
80727
|
-
* package; preserves the historical `Map<string, PublicEvent[]>` shape.
|
|
80728
|
-
*/
|
|
80729
|
-
function groupEventsByDate(events, calendarTimeZone) {
|
|
80730
|
-
const grouped = groupItemsByDate(events, {
|
|
80731
|
-
getStartsAt: (event) => event.startsAt,
|
|
80732
|
-
getTimeZone: () => calendarTimeZone
|
|
80733
|
-
});
|
|
80734
|
-
return new Map([...grouped].map(([dateKey, bucket]) => [dateKey, [...bucket]]));
|
|
80735
|
-
}
|
|
80736
|
-
/** Stable local-day identity shared by ledger continuations and day groups. */
|
|
80737
|
-
function eventLocalDateKey(event) {
|
|
80738
|
-
return getBookingLocalDateKey(toScheduledBookingDateTime({
|
|
80739
|
-
startsAt: event.startsAt,
|
|
80740
|
-
timeZone: resolveBookingBusinessTimeZone(event.timeZone),
|
|
80741
|
-
locale: "en-GB"
|
|
80742
|
-
}));
|
|
80743
|
-
}
|
|
80744
|
-
/** Full weekday and the existing zone-aware time range for a weekly running list. */
|
|
80745
|
-
function formatEventWeekdayTime(event) {
|
|
80746
|
-
const options = eventDateOptions(event);
|
|
80747
|
-
const weekday = formatDate({
|
|
80748
|
-
kind: "instant",
|
|
80749
|
-
value: toUtcIsoDateTimeString(event.startsAt)
|
|
80750
|
-
}, options, {
|
|
80751
|
-
date: "omit",
|
|
80752
|
-
weekday: "long",
|
|
80753
|
-
year: "omit"
|
|
80754
|
-
});
|
|
80755
|
-
return `${weekday} · ${formatEventTimeRange(event, options)}`;
|
|
80756
|
-
}
|
|
80757
|
-
|
|
80758
80850
|
//#endregion
|
|
80759
80851
|
//#region ../blocks/src/system/runtime/nodes/events/domain/duration.ts
|
|
80760
80852
|
function formatEventDuration(event, style = "legacy") {
|
|
@@ -80807,8 +80899,8 @@ const QUICK_EVENT_DATE_LIMIT = 4;
|
|
|
80807
80899
|
* Sorting before deduplication means a duplicate occurrence keeps its earliest
|
|
80808
80900
|
* deterministic representation.
|
|
80809
80901
|
*/
|
|
80810
|
-
function selectQuickDateEvents(events) {
|
|
80811
|
-
return orderedUniqueEventOccurrences(events.filter((event) => event.bookingScope !== "whole_series" && isBookableEvent(event))).slice(0, QUICK_EVENT_DATE_LIMIT);
|
|
80902
|
+
function selectQuickDateEvents(events, now) {
|
|
80903
|
+
return orderedUniqueEventOccurrences(events.filter((event) => event.bookingScope !== "whole_series" && isBookableEvent(event, now))).slice(0, QUICK_EVENT_DATE_LIMIT);
|
|
80812
80904
|
}
|
|
80813
80905
|
/** Shared ordering and identity selection, independent of booking capacity. */
|
|
80814
80906
|
function orderedUniqueEventOccurrences(events) {
|
|
@@ -81852,9 +81944,98 @@ function resolveDedicatedBookingHref(pathname, bookingTarget = { kind: "chooser"
|
|
|
81852
81944
|
function resolveBookingRootPath(pathname) {
|
|
81853
81945
|
return resolveDedicatedBookingPath(pathname).replace(/\/book$/, "") || "/";
|
|
81854
81946
|
}
|
|
81947
|
+
const EMBED_DATES_SET_COUNTS = [
|
|
81948
|
+
3,
|
|
81949
|
+
4,
|
|
81950
|
+
5,
|
|
81951
|
+
6,
|
|
81952
|
+
8,
|
|
81953
|
+
10,
|
|
81954
|
+
12,
|
|
81955
|
+
20
|
|
81956
|
+
];
|
|
81957
|
+
const DEFAULT_EMBED_DATES_SELECTION = {
|
|
81958
|
+
filter: { kind: "all" },
|
|
81959
|
+
venueId: null,
|
|
81960
|
+
length: { kind: "next_week_or_eight" }
|
|
81961
|
+
};
|
|
81962
|
+
/** Lives under the reserved /book path, so it can't shadow a page on a full website. */
|
|
81963
|
+
const EMBED_DATES_LOGICAL_PATH = "/book/dates";
|
|
81964
|
+
const EMBED_DATES_PARAMS = {
|
|
81965
|
+
category: "category",
|
|
81966
|
+
classes: "classes",
|
|
81967
|
+
venue: "venue",
|
|
81968
|
+
count: "count"
|
|
81969
|
+
};
|
|
81970
|
+
const MAX_EMBED_DATES_CLASSES = 50;
|
|
81971
|
+
const UUID_PATTERN$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
81972
|
+
function embedDatesParams({ filter, venueId, length }) {
|
|
81973
|
+
return {
|
|
81974
|
+
...filter.kind === "category" ? { [EMBED_DATES_PARAMS.category]: filter.categoryId } : {},
|
|
81975
|
+
...filter.kind === "classes" ? { [EMBED_DATES_PARAMS.classes]: filter.seriesIds.join(",") } : {},
|
|
81976
|
+
...venueId ? { [EMBED_DATES_PARAMS.venue]: venueId } : {},
|
|
81977
|
+
...length.kind === "set" ? { [EMBED_DATES_PARAMS.count]: String(length.count) } : {}
|
|
81978
|
+
};
|
|
81979
|
+
}
|
|
81980
|
+
function readEmbedDatesParam(raw) {
|
|
81981
|
+
if (raw === undefined) return { kind: "missing" };
|
|
81982
|
+
const value = typeof raw === "string" ? raw : raw.length === 1 ? raw[0] : undefined;
|
|
81983
|
+
const trimmed = value?.trim();
|
|
81984
|
+
return trimmed ? {
|
|
81985
|
+
kind: "value",
|
|
81986
|
+
value: trimmed
|
|
81987
|
+
} : { kind: "invalid" };
|
|
81988
|
+
}
|
|
81989
|
+
function readEmbedDatesId(param) {
|
|
81990
|
+
return param.kind === "value" && UUID_PATTERN$1.test(param.value) ? param.value : null;
|
|
81991
|
+
}
|
|
81992
|
+
function parseEmbedDatesFilter(category, classes) {
|
|
81993
|
+
if (category.kind === "value" && classes.kind === "value") return null;
|
|
81994
|
+
if (category.kind === "invalid" || classes.kind === "invalid") return null;
|
|
81995
|
+
if (category.kind === "value") {
|
|
81996
|
+
const categoryId = readEmbedDatesId(category);
|
|
81997
|
+
return categoryId ? {
|
|
81998
|
+
kind: "category",
|
|
81999
|
+
categoryId
|
|
82000
|
+
} : null;
|
|
82001
|
+
}
|
|
82002
|
+
if (classes.kind === "missing") return { kind: "all" };
|
|
82003
|
+
const seriesIds = [...new Set(classes.value.split(",").map((id$2) => id$2.trim()))];
|
|
82004
|
+
return seriesIds.length <= MAX_EMBED_DATES_CLASSES && seriesIds.every((id$2) => UUID_PATTERN$1.test(id$2)) ? {
|
|
82005
|
+
kind: "classes",
|
|
82006
|
+
seriesIds
|
|
82007
|
+
} : null;
|
|
82008
|
+
}
|
|
82009
|
+
function parseEmbedDatesLength(count) {
|
|
82010
|
+
const setCount = count.kind === "value" ? EMBED_DATES_SET_COUNTS.find((candidate$1) => String(candidate$1) === count.value) : undefined;
|
|
82011
|
+
return setCount === undefined ? { kind: "next_week_or_eight" } : {
|
|
82012
|
+
kind: "set",
|
|
82013
|
+
count: setCount
|
|
82014
|
+
};
|
|
82015
|
+
}
|
|
82016
|
+
/**
|
|
82017
|
+
* Reads the embed's filters. A filter that can't be read never widens to "all
|
|
82018
|
+
* classes": the owner chose something narrower, so the caller shows no dates. A
|
|
82019
|
+
* count we don't offer only changes the length, so it falls back to the default.
|
|
82020
|
+
*/
|
|
82021
|
+
function parseEmbedDatesSelection(params) {
|
|
82022
|
+
const venue = readEmbedDatesParam(params?.[EMBED_DATES_PARAMS.venue]);
|
|
82023
|
+
const venueId = readEmbedDatesId(venue);
|
|
82024
|
+
if (venue.kind !== "missing" && venueId === null) return null;
|
|
82025
|
+
const filter = parseEmbedDatesFilter(readEmbedDatesParam(params?.[EMBED_DATES_PARAMS.category]), readEmbedDatesParam(params?.[EMBED_DATES_PARAMS.classes]));
|
|
82026
|
+
return filter && {
|
|
82027
|
+
filter,
|
|
82028
|
+
venueId,
|
|
82029
|
+
length: parseEmbedDatesLength(readEmbedDatesParam(params?.[EMBED_DATES_PARAMS.count]))
|
|
82030
|
+
};
|
|
82031
|
+
}
|
|
81855
82032
|
/** Shared by the dashboard snippet and server consumers; chooser means the whole page. */
|
|
81856
82033
|
function resolveBookingEmbedPath(target) {
|
|
81857
82034
|
if (target.kind === "chooser") return "/embed";
|
|
82035
|
+
if (target.kind === "upcoming_dates") {
|
|
82036
|
+
const query = new URLSearchParams(embedDatesParams(target.selection)).toString();
|
|
82037
|
+
return query ? `/embed${EMBED_DATES_LOGICAL_PATH}?${query}` : `/embed${EMBED_DATES_LOGICAL_PATH}`;
|
|
82038
|
+
}
|
|
81858
82039
|
if (target.kind === "event_category") {
|
|
81859
82040
|
return `/embed/book?${new URLSearchParams({ [BOOK_TARGET_PARAMS.category]: target.categoryId })}`;
|
|
81860
82041
|
}
|
|
@@ -81864,11 +82045,12 @@ const EMBED_SEGMENT = "[a-z0-9][a-z0-9-]*";
|
|
|
81864
82045
|
const EMBEDDABLE_DETAIL_PATH = new RegExp(`^/(?:events/${EMBED_SEGMENT}(?:/${EMBED_SEGMENT})?|services/${EMBED_SEGMENT})$`, "i");
|
|
81865
82046
|
/**
|
|
81866
82047
|
* The one rule for which logical paths the embed surface serves: the booking
|
|
81867
|
-
* root, /book, an event (optionally one occurrence) and
|
|
81868
|
-
* and the click owner both use it; embed.js mirrors it in
|
|
82048
|
+
* root, /book, the upcoming-dates list, an event (optionally one occurrence) and
|
|
82049
|
+
* a service. The proxy and the click owner both use it; embed.js mirrors it in
|
|
82050
|
+
* its own regex.
|
|
81869
82051
|
*/
|
|
81870
82052
|
function isEmbeddableLogicalPath(logical) {
|
|
81871
|
-
return logical === "/" || logical === "/book" || EMBEDDABLE_DETAIL_PATH.test(logical);
|
|
82053
|
+
return logical === "/" || logical === "/book" || logical === EMBED_DATES_LOGICAL_PATH || EMBEDDABLE_DETAIL_PATH.test(logical);
|
|
81872
82054
|
}
|
|
81873
82055
|
/** The document click owner and booking links share the embed surface prefix. */
|
|
81874
82056
|
function resolveEmbedDocumentPath(pathname) {
|
|
@@ -85475,6 +85657,7 @@ function bookingCalendar(event, outcome) {
|
|
|
85475
85657
|
function toRegistrationEvent(event) {
|
|
85476
85658
|
return {
|
|
85477
85659
|
...event,
|
|
85660
|
+
...bookingCloseLine(openBookingLine(event)),
|
|
85478
85661
|
selectionId: event.id,
|
|
85479
85662
|
registrationSubject: {
|
|
85480
85663
|
kind: "occurrence",
|
|
@@ -85482,6 +85665,9 @@ function toRegistrationEvent(event) {
|
|
|
85482
85665
|
}
|
|
85483
85666
|
};
|
|
85484
85667
|
}
|
|
85668
|
+
function bookingCloseLine(line) {
|
|
85669
|
+
return line ? { bookingCloseLine: line } : {};
|
|
85670
|
+
}
|
|
85485
85671
|
function toRegistrationEvents(events) {
|
|
85486
85672
|
return events.filter((event) => event.bookingScope === "single_occurrence").map(toRegistrationEvent);
|
|
85487
85673
|
}
|
|
@@ -85500,6 +85686,7 @@ function toWholeSeriesRegistrationEvent(group) {
|
|
|
85500
85686
|
const lastSession = sessions[sessions.length - 1] ?? firstSession;
|
|
85501
85687
|
return {
|
|
85502
85688
|
...representative,
|
|
85689
|
+
...bookingCloseLine(openRunBookingLine(run)),
|
|
85503
85690
|
selectionId: run.eventSeriesId,
|
|
85504
85691
|
registrationSubject: {
|
|
85505
85692
|
kind: "wholeSeries",
|
|
@@ -87959,6 +88146,11 @@ function resolveWaitlistClaimRestoration(input) {
|
|
|
87959
88146
|
message: "This waiting list invitation is for a different event. Please open the link in your invitation email."
|
|
87960
88147
|
};
|
|
87961
88148
|
}
|
|
88149
|
+
/** A place held on a run or date that's closed is still theirs, so it stays on the list they see. */
|
|
88150
|
+
function withOfferedEvent(choices, invitation) {
|
|
88151
|
+
const offered$1 = invitation.kind === "ready" ? invitation.restoration.event : null;
|
|
88152
|
+
return offered$1 && !choices.some((event) => event.selectionId === offered$1.selectionId) ? [offered$1, ...choices] : choices;
|
|
88153
|
+
}
|
|
87962
88154
|
|
|
87963
88155
|
//#endregion
|
|
87964
88156
|
//#region ../blocks/src/system/runtime/nodes/event-registration/registrationBrowserDraft.ts
|
|
@@ -88532,7 +88724,21 @@ function resolveHeadlessEventRegistrationStatus(wizard) {
|
|
|
88532
88724
|
default: return assertNever$4(wizard.flow);
|
|
88533
88725
|
}
|
|
88534
88726
|
}
|
|
88727
|
+
const BOOKING_CLOSED_MESSAGE = "Booking is currently closed for this event. Please contact the organiser if you’d like to find out more.";
|
|
88535
88728
|
function registrationSurfaceUnavailable(wizard) {
|
|
88729
|
+
if (wizard.bookingClosure.kind === "underway") return null;
|
|
88730
|
+
if (wizard.bookingClosure.kind === "closedEarly") {
|
|
88731
|
+
return {
|
|
88732
|
+
kind: "unavailable",
|
|
88733
|
+
message: wizard.bookingClosure.copy.bodyText
|
|
88734
|
+
};
|
|
88735
|
+
}
|
|
88736
|
+
if (wizard.bookingClosure.kind === "started") {
|
|
88737
|
+
return {
|
|
88738
|
+
kind: "unavailable",
|
|
88739
|
+
message: BOOKING_CLOSED_MESSAGE
|
|
88740
|
+
};
|
|
88741
|
+
}
|
|
88536
88742
|
if (wizard.scopedEvents.length === 0 && !wizard.occurrenceContext) {
|
|
88537
88743
|
return {
|
|
88538
88744
|
kind: "empty",
|
|
@@ -88543,7 +88749,7 @@ function registrationSurfaceUnavailable(wizard) {
|
|
|
88543
88749
|
if (!hasRegistrableEvents && !wizard.occurrenceContext) {
|
|
88544
88750
|
return {
|
|
88545
88751
|
kind: "unavailable",
|
|
88546
|
-
message:
|
|
88752
|
+
message: BOOKING_CLOSED_MESSAGE
|
|
88547
88753
|
};
|
|
88548
88754
|
}
|
|
88549
88755
|
return null;
|
|
@@ -90839,7 +91045,7 @@ function resolveEventRegistrationChoices(events, context, now) {
|
|
|
90839
91045
|
return scoped;
|
|
90840
91046
|
}
|
|
90841
91047
|
const eligibleRunIds = new Set(runs.filter((group) => resolveWholeSeriesChooserEligibility(group, now).kind === "eligible").map((group) => group.eventSeriesId));
|
|
90842
|
-
return scoped.filter((event) => event.bookingScope === "whole_series" ? eligibleRunIds.has(event.seriesId) : Date.parse(event.startsAt) > now.getTime());
|
|
91048
|
+
return scoped.filter((event) => event.bookingScope === "whole_series" ? eligibleRunIds.has(event.seriesId) : Date.parse(event.startsAt) > now.getTime() && !hasEventBookingClosedEarly(event, now));
|
|
90843
91049
|
}
|
|
90844
91050
|
|
|
90845
91051
|
//#endregion
|
|
@@ -91052,7 +91258,7 @@ function closedRegistrationCopy(source, events) {
|
|
|
91052
91258
|
if (hasCancelledRegistrationDate(events, source.occurrenceContext?.id)) return cancelledDateCopy;
|
|
91053
91259
|
const selectedRun = resolveSelectedWholeSeriesRun(events);
|
|
91054
91260
|
const phase = selectedRun ? resolveWholeSeriesBookingPhase(selectedRun.run, new Date(source.now)) : null;
|
|
91055
|
-
return phase?.kind === "closed" ? closedRunCopy(phase.reason) : null;
|
|
91261
|
+
return phase?.kind === "closed" ? closedRunCopy(phase.reason, selectedRun?.run) : null;
|
|
91056
91262
|
}
|
|
91057
91263
|
function buildEventRegistrationShellStepLabels(source, scopedSourceEvents) {
|
|
91058
91264
|
const selectedRun = resolveSelectedWholeSeriesRun(scopedSourceEvents);
|
|
@@ -95727,8 +95933,8 @@ function EventQuickDates({ events, pathname, buttonVariant = "primary", dateStyl
|
|
|
95727
95933
|
* Null when the date has no registration path (closed, paused, not open yet,
|
|
95728
95934
|
* no registration, or full with no waitlist), so no caller repeats that gate.
|
|
95729
95935
|
*/
|
|
95730
|
-
function eventDateBookingLink(event, pathname, dateLabel$1) {
|
|
95731
|
-
if (!isBookableEvent(event)) return null;
|
|
95936
|
+
function eventDateBookingLink(event, pathname, dateLabel$1, now) {
|
|
95937
|
+
if (!isBookableEvent(event, now)) return null;
|
|
95732
95938
|
const cta = resolveEventCta(event);
|
|
95733
95939
|
const destination = resolveRuntimeEventDestination(event);
|
|
95734
95940
|
const href = destination.kind === "external" ? cta.href : resolveDedicatedBookingHref(pathname, {
|
|
@@ -112727,6 +112933,7 @@ function bookingClosedReason(reason) {
|
|
|
112727
112933
|
case "cancelled": return "These dates have been cancelled.";
|
|
112728
112934
|
case "in-progress": return "Bookings closed when the first session began.";
|
|
112729
112935
|
case "completed": return "These dates have finished.";
|
|
112936
|
+
case "bookings-closed":
|
|
112730
112937
|
case "enrolment-closed": return "Bookings for these dates have closed.";
|
|
112731
112938
|
case "no-sessions": return "No dates are currently scheduled.";
|
|
112732
112939
|
}
|
|
@@ -113432,12 +113639,12 @@ function cardsListDates(props$1) {
|
|
|
113432
113639
|
return props$1.lookSlots !== undefined && props$1.datesMode === "next-dates";
|
|
113433
113640
|
}
|
|
113434
113641
|
/** One offering has room for a Book link on each date; several keep plain rows. */
|
|
113435
|
-
function catalogueDateBooking(shape, pathname) {
|
|
113436
|
-
return shape === "single" ? (event, dateLabel$1) => eventDateBookingLink(event, pathname ?? "/", dateLabel$1) : undefined;
|
|
113642
|
+
function catalogueDateBooking(shape, pathname, now) {
|
|
113643
|
+
return shape === "single" ? (event, dateLabel$1) => eventDateBookingLink(event, pathname ?? "/", dateLabel$1, now) : undefined;
|
|
113437
113644
|
}
|
|
113438
113645
|
function renderOfferingsCatalogueGroups({ props: props$1, groups, shape }) {
|
|
113439
113646
|
const enabledSeriesIds = new Set(groups.flatMap((load) => load.kind === "items" ? load.items.map((item) => item.kind === "event" ? item.event.seriesId : item.run.eventSeriesId) : []));
|
|
113440
|
-
const quickDateEvents = cardsListDates(props$1) ? [] : selectQuickDateEvents((props$1.quickDateEvents ?? []).filter((event) => enabledSeriesIds.has(event.seriesId)));
|
|
113647
|
+
const quickDateEvents = cardsListDates(props$1) ? [] : selectQuickDateEvents((props$1.quickDateEvents ?? []).filter((event) => enabledSeriesIds.has(event.seriesId)), props$1.now);
|
|
113441
113648
|
const populated = groups.flatMap(catalogueGroupItems);
|
|
113442
113649
|
const frames = listGroupFrames(props$1);
|
|
113443
113650
|
return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
|
|
@@ -113502,7 +113709,7 @@ function renderCatalogueItems({ props: props$1, items: items$1, shape, groupTitl
|
|
|
113502
113709
|
}
|
|
113503
113710
|
/** Dates are a display sample; the series card never infers availability from them. */
|
|
113504
113711
|
function catalogueDates(events, now, shape, pathname) {
|
|
113505
|
-
return offeringDatesBySeries(events, now, catalogueDateBooking(shape, pathname));
|
|
113712
|
+
return offeringDatesBySeries(events, now, catalogueDateBooking(shape, pathname, now));
|
|
113506
113713
|
}
|
|
113507
113714
|
function catalogueCardContent(item, now, dates, typeLabel) {
|
|
113508
113715
|
const event = item.kind === "event" ? item.event : item.run.representative;
|
|
@@ -116336,7 +116543,11 @@ function EventBookingPanelBody({ panel }) {
|
|
|
116336
116543
|
});
|
|
116337
116544
|
case "dropIn": return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DropInPanel, { panel: panel.panel });
|
|
116338
116545
|
case "bookingClosed": return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BookingClosedPanel, { detail: panel.detail });
|
|
116339
|
-
case "closedRun": return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ClosedRunPanel, {
|
|
116546
|
+
case "closedRun": return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ClosedRunPanel, { copy: closedRunCopy(panel.reason, panel.run) });
|
|
116547
|
+
case "closedDate": return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ClosedRunPanel, {
|
|
116548
|
+
copy: panel.copy,
|
|
116549
|
+
otherDatesHref: panel.copy.otherDatesHref
|
|
116550
|
+
});
|
|
116340
116551
|
case "single": return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SingleDateBooking, { run: panel.run });
|
|
116341
116552
|
case "choice": return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RunChooser, { runs: panel.runs });
|
|
116342
116553
|
case "unavailable": return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
|
|
@@ -116408,17 +116619,27 @@ function BookingClosedPanel({ detail }) {
|
|
|
116408
116619
|
});
|
|
116409
116620
|
}
|
|
116410
116621
|
/** Dates that cannot be booked keep their details and say why. */
|
|
116411
|
-
function ClosedRunPanel({
|
|
116412
|
-
const copy$1 = closedRunCopy(reason);
|
|
116622
|
+
function ClosedRunPanel({ copy: copy$1, otherDatesHref }) {
|
|
116413
116623
|
return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
|
|
116414
116624
|
className: "event-booking-panel__closed-run",
|
|
116415
|
-
children: [
|
|
116416
|
-
|
|
116417
|
-
|
|
116418
|
-
|
|
116419
|
-
|
|
116420
|
-
|
|
116421
|
-
|
|
116625
|
+
children: [
|
|
116626
|
+
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", {
|
|
116627
|
+
className: "card-title rb-mb-3",
|
|
116628
|
+
children: copy$1.titleText
|
|
116629
|
+
}),
|
|
116630
|
+
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
|
|
116631
|
+
className: "status-muted rb-text-base rb-leading-relaxed",
|
|
116632
|
+
children: copy$1.bodyText
|
|
116633
|
+
}),
|
|
116634
|
+
otherDatesHref ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
|
|
116635
|
+
className: "rb-mt-4 rb-text-base",
|
|
116636
|
+
children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", {
|
|
116637
|
+
className: "rb-underline",
|
|
116638
|
+
href: otherDatesHref,
|
|
116639
|
+
children: "See the other dates"
|
|
116640
|
+
})
|
|
116641
|
+
}) : null
|
|
116642
|
+
]
|
|
116422
116643
|
});
|
|
116423
116644
|
}
|
|
116424
116645
|
/**
|
|
@@ -116558,40 +116779,53 @@ function planEventBookingPanel({ selection, subject }, now) {
|
|
|
116558
116779
|
...nonBookingPanel,
|
|
116559
116780
|
registration
|
|
116560
116781
|
};
|
|
116561
|
-
|
|
116562
|
-
|
|
116563
|
-
kind: "closedRun",
|
|
116564
|
-
reason: phase.reason,
|
|
116565
|
-
registration
|
|
116566
|
-
} : {
|
|
116567
|
-
kind: "registration",
|
|
116782
|
+
return {
|
|
116783
|
+
...closedDatePanel(selection, now) ?? closedRunPanel(selection, now) ?? { kind: "registration" },
|
|
116568
116784
|
registration
|
|
116569
116785
|
};
|
|
116570
116786
|
}
|
|
116571
116787
|
case "wholeSeriesParent": {
|
|
116788
|
+
const registration = parentRegistrationTarget(selection, subject);
|
|
116572
116789
|
if (nonBookingPanel) return {
|
|
116573
116790
|
...nonBookingPanel,
|
|
116574
|
-
registration
|
|
116791
|
+
registration
|
|
116575
116792
|
};
|
|
116576
116793
|
const panel = planWholeSeriesParentBooking(selection.eligibleRuns);
|
|
116577
116794
|
return panel.kind === "bookTogether" ? {
|
|
116578
116795
|
kind: "registration",
|
|
116579
|
-
registration
|
|
116580
|
-
events: panel.runs.map((run) => run.representative),
|
|
116581
|
-
subject,
|
|
116582
|
-
occurrenceContext: null
|
|
116583
|
-
}
|
|
116796
|
+
registration
|
|
116584
116797
|
} : {
|
|
116585
116798
|
...panel,
|
|
116586
|
-
registration
|
|
116799
|
+
registration
|
|
116587
116800
|
};
|
|
116588
116801
|
}
|
|
116589
116802
|
case "wholeSeriesParentUnavailable": return {
|
|
116590
116803
|
...nonBookingPanel ?? { kind: "unavailable" },
|
|
116591
|
-
registration:
|
|
116804
|
+
registration: parentRegistrationTarget(selection, subject)
|
|
116592
116805
|
};
|
|
116593
116806
|
}
|
|
116594
116807
|
}
|
|
116808
|
+
/**
|
|
116809
|
+
* A date past its cut-off, however old the page's data is. A list of dates only
|
|
116810
|
+
* closes when every date has: until then the closed ones just leave the list.
|
|
116811
|
+
*/
|
|
116812
|
+
function closedRunPanel(selection, now) {
|
|
116813
|
+
if (selection.kind !== "wholeSeriesRun") return null;
|
|
116814
|
+
const phase = resolveWholeSeriesBookingPhase(selection.run.run, now);
|
|
116815
|
+
return phase.kind === "closed" ? {
|
|
116816
|
+
kind: "closedRun",
|
|
116817
|
+
reason: phase.reason,
|
|
116818
|
+
run: selection.run.run
|
|
116819
|
+
} : null;
|
|
116820
|
+
}
|
|
116821
|
+
function closedDatePanel(selection, now) {
|
|
116822
|
+
if (selection.kind === "wholeSeriesRun") return null;
|
|
116823
|
+
const copy$1 = selection.kind === "occurrence" ? closedDateCopy(selection.event, now) : closedDatesCopy(selection.dates, now);
|
|
116824
|
+
return copy$1 ? {
|
|
116825
|
+
kind: "closedDate",
|
|
116826
|
+
copy: copy$1
|
|
116827
|
+
} : null;
|
|
116828
|
+
}
|
|
116595
116829
|
/** Drop-in and page-level closure take precedence over fresh booking and run selection. */
|
|
116596
116830
|
function planNonBookingPanel(selection) {
|
|
116597
116831
|
if (!selectionRepresentativeEvent(selection).requiresRegistration) {
|
|
@@ -116625,6 +116859,18 @@ function selectionRegistrationTarget(selection, subject) {
|
|
|
116625
116859
|
};
|
|
116626
116860
|
}
|
|
116627
116861
|
}
|
|
116862
|
+
/**
|
|
116863
|
+
* Every run the course page admits, not just those still taking bookings. An
|
|
116864
|
+
* invitation emailed for a run links here, and stays good after that run closes.
|
|
116865
|
+
* The wizard narrows these to the runs it offers for a new booking.
|
|
116866
|
+
*/
|
|
116867
|
+
function parentRegistrationTarget(selection, subject) {
|
|
116868
|
+
return {
|
|
116869
|
+
events: selection.admittedRuns.map((run) => run.representative),
|
|
116870
|
+
occurrenceContext: null,
|
|
116871
|
+
subject
|
|
116872
|
+
};
|
|
116873
|
+
}
|
|
116628
116874
|
/** Cancelled dates have no new-booking or recovery form, including old direct links. */
|
|
116629
116875
|
function isCancelledDateSelection(selection) {
|
|
116630
116876
|
return selection.kind === "occurrence" && hasCancelledRegistrationDate([selection.event]);
|
|
@@ -116632,7 +116878,7 @@ function isCancelledDateSelection(selection) {
|
|
|
116632
116878
|
|
|
116633
116879
|
//#endregion
|
|
116634
116880
|
//#region ../blocks/src/system/runtime/nodes/event-registration/RegistrationClosedState.tsx
|
|
116635
|
-
function RegistrationClosedState({ title, body }) {
|
|
116881
|
+
function RegistrationClosedState({ title, body, otherDatesHref }) {
|
|
116636
116882
|
return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
|
|
116637
116883
|
id: EVENT_REGISTRATION_ANCHOR_ID,
|
|
116638
116884
|
className: "rb-reg-surface er-container er-registration-closed",
|
|
@@ -116651,7 +116897,15 @@ function RegistrationClosedState({ title, body }) {
|
|
|
116651
116897
|
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
|
|
116652
116898
|
className: "er-text er-text--muted",
|
|
116653
116899
|
children: body
|
|
116654
|
-
})
|
|
116900
|
+
}),
|
|
116901
|
+
otherDatesHref ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
|
|
116902
|
+
className: "er-text",
|
|
116903
|
+
children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", {
|
|
116904
|
+
className: "rb-underline",
|
|
116905
|
+
href: otherDatesHref,
|
|
116906
|
+
children: "See the other dates"
|
|
116907
|
+
})
|
|
116908
|
+
}) : null
|
|
116655
116909
|
] })
|
|
116656
116910
|
})
|
|
116657
116911
|
});
|
|
@@ -121507,8 +121761,8 @@ async function applyPageCommand(input, command) {
|
|
|
121507
121761
|
identifier: pageIdentifierForCommand(command),
|
|
121508
121762
|
title: command.input.title,
|
|
121509
121763
|
path: pagePathForCommand(command),
|
|
121510
|
-
seoTitle: command.input.seoTitle,
|
|
121511
|
-
seoDescription: command.input.seoDescription
|
|
121764
|
+
seoTitle: command.input.seoTitle ?? null,
|
|
121765
|
+
seoDescription: command.input.seoDescription ?? null
|
|
121512
121766
|
})).effect;
|
|
121513
121767
|
case "publishPage": return (await input.client.pages.publish(pageIdentifierForCommand(command))).effect;
|
|
121514
121768
|
case "unpublishPage": return (await input.client.pages.unpublish(pageIdentifierForCommand(command))).effect;
|
|
@@ -122718,15 +122972,10 @@ function fingerprintCommonRemote(remote, selection = { scope: "all" }) {
|
|
|
122718
122972
|
async function readRemoteForCommonRevalidation(client, selection) {
|
|
122719
122973
|
try {
|
|
122720
122974
|
const pulled = stripCanonicalEventEntriesFromPulledContent(await client.pull.all());
|
|
122721
|
-
const homepage = normalizeRemoteHomepageReference(pulled.content);
|
|
122722
|
-
if (!homepage.ok) return {
|
|
122723
|
-
ok: false,
|
|
122724
|
-
error: new Error(homepage.error.message)
|
|
122725
|
-
};
|
|
122726
122975
|
return {
|
|
122727
122976
|
ok: true,
|
|
122728
|
-
remote:
|
|
122729
|
-
fingerprint: fingerprintCommonRemote(
|
|
122977
|
+
remote: pulled.content,
|
|
122978
|
+
fingerprint: fingerprintCommonRemote(pulled.content, selection)
|
|
122730
122979
|
};
|
|
122731
122980
|
} catch (error$1) {
|
|
122732
122981
|
return {
|
|
@@ -123017,15 +123266,13 @@ async function loadCommonLocalSource(input) {
|
|
|
123017
123266
|
}
|
|
123018
123267
|
async function loadCommonRemoteSource(input) {
|
|
123019
123268
|
const pulled = stripCanonicalEventEntriesFromPulledContent(await input.client.pull.all());
|
|
123020
|
-
|
|
123021
|
-
if (!homepage.ok) return preparationError("unsafe-remote-state", homepage.error.message);
|
|
123022
|
-
if (homepage.content.meta.truncation.truncated && !input.options.allowTruncated) {
|
|
123269
|
+
if (pulled.content.meta.truncation.truncated && !input.options.allowTruncated) {
|
|
123023
123270
|
return preparationError("unsafe-remote-state", "Push aborted due to truncated remote content.");
|
|
123024
123271
|
}
|
|
123025
123272
|
return {
|
|
123026
|
-
remote:
|
|
123027
|
-
remoteFingerprint: fingerprintCommonRemote(
|
|
123028
|
-
warnings:
|
|
123273
|
+
remote: pulled.content,
|
|
123274
|
+
remoteFingerprint: fingerprintCommonRemote(pulled.content, input),
|
|
123275
|
+
warnings: pulled.content.meta.truncation.truncated ? ["Remote content was truncated; push continued because --allow-truncated was supplied."] : []
|
|
123029
123276
|
};
|
|
123030
123277
|
}
|
|
123031
123278
|
async function findCommonStaleItems(localSource, remote, force) {
|
|
@@ -124976,7 +125223,6 @@ function emptyPulledContent(overrides) {
|
|
|
124976
125223
|
pages: [],
|
|
124977
125224
|
navigation: [],
|
|
124978
125225
|
settings: {
|
|
124979
|
-
homepageId: null,
|
|
124980
125226
|
seoDefaults: null,
|
|
124981
125227
|
logoIdentifier: null,
|
|
124982
125228
|
logoDarkBackgroundIdentifier: null,
|
|
@@ -126316,10 +126562,7 @@ async function readRemoteSnapshot(client) {
|
|
|
126316
126562
|
entries: {},
|
|
126317
126563
|
pages: [],
|
|
126318
126564
|
navigation: [],
|
|
126319
|
-
settings: {
|
|
126320
|
-
homepageId: null,
|
|
126321
|
-
seoDefaults: null
|
|
126322
|
-
},
|
|
126565
|
+
settings: { seoDefaults: null },
|
|
126323
126566
|
forms: [],
|
|
126324
126567
|
meta: {
|
|
126325
126568
|
pulledAt: "",
|
|
@@ -128988,7 +129231,7 @@ function createUpsertCommand$4() {
|
|
|
128988
129231
|
...jsonInputOptions("Entry data"),
|
|
128989
129232
|
slug: {
|
|
128990
129233
|
flags: "--slug <slug>",
|
|
128991
|
-
description: "
|
|
129234
|
+
description: "Slug for a new entry (defaults to identifier). An existing entry keeps its address.",
|
|
128992
129235
|
value: z.string().optional()
|
|
128993
129236
|
}
|
|
128994
129237
|
},
|
|
@@ -131668,7 +131911,7 @@ async function loadConfig(configPath, output) {
|
|
|
131668
131911
|
return { errorMessage: "No config path provided." };
|
|
131669
131912
|
}
|
|
131670
131913
|
try {
|
|
131671
|
-
const { loadConfigFile: loadConfigFile$1 } = await import("../load-config-
|
|
131914
|
+
const { loadConfigFile: loadConfigFile$1 } = await import("../load-config-DSGN-x3K.mjs");
|
|
131672
131915
|
const rawConfig = await loadConfigFile$1(configPath);
|
|
131673
131916
|
const parsed = z.safeParse(riverbankSiteConfigSchema, rawConfig);
|
|
131674
131917
|
if (!parsed.success) {
|
|
@@ -134830,6 +135073,7 @@ function cancelledRunInput(run) {
|
|
|
134830
135073
|
visibility: run.visibility,
|
|
134831
135074
|
capacity: run.capacity,
|
|
134832
135075
|
waitlistMode: run.waitlistMode,
|
|
135076
|
+
bookingCutOffHours: run.bookingCutOffHours,
|
|
134833
135077
|
bookingOffer: run.bookingOffer,
|
|
134834
135078
|
venueRef: run.venueRef,
|
|
134835
135079
|
settings: run.settings,
|
|
@@ -147363,15 +147607,15 @@ const siteTermsSettingsCommandSchema = z.discriminatedUnion("kind", [z.object({
|
|
|
147363
147607
|
const STRIPE_CONNECT_BUSINESS_CATEGORIES = [
|
|
147364
147608
|
{
|
|
147365
147609
|
mcc: "8299",
|
|
147366
|
-
label: "
|
|
147610
|
+
label: "Classes, courses and workshops"
|
|
147367
147611
|
},
|
|
147368
147612
|
{
|
|
147369
147613
|
mcc: "7997",
|
|
147370
|
-
label: "
|
|
147614
|
+
label: "Gyms, sports clubs and fitness memberships"
|
|
147371
147615
|
},
|
|
147372
147616
|
{
|
|
147373
147617
|
mcc: "7911",
|
|
147374
|
-
label: "Dance
|
|
147618
|
+
label: "Dance classes and studios"
|
|
147375
147619
|
}
|
|
147376
147620
|
];
|
|
147377
147621
|
|