@bleedingdev/modern-js-create 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

package/templates/packages/shared-contracts-index.ts

@@ -0,0 +1,466 @@
+export type UltramodernPublicSitemapChangeFrequency =
+  | 'always'
+  | 'hourly'
+  | 'daily'
+  | 'weekly'
+  | 'monthly'
+  | 'yearly'
+  | 'never';
+
+export interface UltramodernPublicSitemapEntry {
+  /**
+   * Params used to expand every localized route pattern, for example
+   * { slug: 'platform-story' } for /talks/:slug.
+   */
+  params: Record<string, string | number | boolean>;
+  /**
+   * Per-locale overrides when translated URLs use translated params.
+   */
+  localeParams?: Partial<Record<'en' | 'cs', Record<string, string | number | boolean>>>;
+  draft?: boolean;
+  indexable?: boolean;
+  lastModified?: string;
+  changeFrequency?: UltramodernPublicSitemapChangeFrequency;
+  priority?: number;
+}
+
+export type UltramodernPerformanceReadinessSignalId =
+  | 'bfcache'
+  | 'core-web-vitals-rum'
+  | 'duplicate-prefetch-warmup'
+  | 'cache-policy-sanity'
+  | 'save-data-behavior'
+  | 'cloudflare-ssr-cache-hints';
+
+export interface UltramodernPerformanceReadinessDiagnosticsConfig {
+  /**
+   * Default-on. Set to false only for an explicit local or CI fast path.
+   */
+  enabled?: boolean;
+  /**
+   * Diagnostics may fail objective generated/framework invariants, or never
+   * fail and only emit the deterministic report.
+   */
+  failOn?: 'framework-invariant' | 'never';
+  reportPath?: string;
+  signals?: Partial<
+    Record<
+      UltramodernPerformanceReadinessSignalId,
+      {
+        enabled?: boolean;
+      }
+    >
+  >;
+}
+
+export const ultramodernWorkspaceContract = {
+  ownership: 'topology/ownership.json',
+  performanceReadiness: {
+    defaultOn: true,
+    optOut: 'scripts/ultramodern-performance-readiness.config.mjs#enabled=false',
+    report:
+      '.codex/reports/performance-readiness/ultramodern-performance-readiness.json',
+    signals: [
+      'bfcache',
+      'core-web-vitals-rum',
+      'duplicate-prefetch-warmup',
+      'cache-policy-sanity',
+      'save-data-behavior',
+      'cloudflare-ssr-cache-hints',
+    ],
+  },
+  preset: 'presetUltramodern',
+  topology: 'topology/reference-topology.json',
+} as const;
+
+export const tractorEventNames = {
+  checkoutAddToCart: 'checkout:add-to-cart',
+  checkoutCartUpdated: 'checkout:cart-updated',
+  checkoutClearCart: 'checkout:clear-cart',
+  checkoutRemoveFromCart: 'checkout:remove-from-cart',
+  exploreSelectedShop: 'explore:selected-shop',
+  mfNavigate: 'mf:navigate',
+} as const;
+
+export type TractorEventName =
+  (typeof tractorEventNames)[keyof typeof tractorEventNames];
+
+export interface CheckoutAddToCartPayload {
+  sku: string;
+  quantity: number;
+  name?: string;
+  shopId?: string;
+  unitPriceCents?: number;
+}
+
+export interface CheckoutCartLinePayload {
+  sku: string;
+  quantity: number;
+  name?: string;
+  unitPriceCents?: number;
+}
+
+export interface CheckoutCartUpdatedPayload {
+  lines: readonly CheckoutCartLinePayload[];
+  totalQuantity: number;
+  subtotalCents?: number;
+}
+
+export interface CheckoutRemoveFromCartPayload {
+  sku: string;
+}
+
+export interface CheckoutClearCartPayload {
+  reason?: string;
+}
+
+export interface ExploreSelectedShopPayload {
+  shopId: string;
+  name?: string;
+}
+
+export interface MfNavigatePayload {
+  to: string;
+  replace?: boolean;
+  state?: Record<string, unknown>;
+}
+
+export interface TractorEventPayloadMap {
+  'checkout:add-to-cart': CheckoutAddToCartPayload;
+  'checkout:cart-updated': CheckoutCartUpdatedPayload;
+  'checkout:clear-cart': CheckoutClearCartPayload;
+  'checkout:remove-from-cart': CheckoutRemoveFromCartPayload;
+  'explore:selected-shop': ExploreSelectedShopPayload;
+  'mf:navigate': MfNavigatePayload;
+}
+
+export class TractorEventValidationError extends Error {
+  readonly eventName: TractorEventName;
+  readonly payload: unknown;
+
+  constructor(eventName: TractorEventName, payload: unknown) {
+    super(`Invalid payload for Tractor event "${eventName}"`);
+    this.name = 'TractorEventValidationError';
+    this.eventName = eventName;
+    this.payload = payload;
+  }
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === 'string' && value.trim().length > 0;
+
+const isPositiveInteger = (value: unknown): value is number =>
+  Number.isInteger(value) && value > 0;
+
+const isNonNegativeInteger = (value: unknown): value is number =>
+  Number.isInteger(value) && value >= 0;
+
+const hasOptionalString = (value: Record<string, unknown>, key: string) =>
+  value[key] === undefined || isNonEmptyString(value[key]);
+
+const hasOptionalBoolean = (value: Record<string, unknown>, key: string) =>
+  value[key] === undefined || typeof value[key] === 'boolean';
+
+const hasOptionalRecord = (value: Record<string, unknown>, key: string) =>
+  value[key] === undefined || isRecord(value[key]);
+
+const hasOptionalNonNegativeInteger = (
+  value: Record<string, unknown>,
+  key: string,
+) => value[key] === undefined || isNonNegativeInteger(value[key]);
+
+export const isCheckoutAddToCartPayload = (
+  payload: unknown,
+): payload is CheckoutAddToCartPayload =>
+  isRecord(payload) &&
+  isNonEmptyString(payload['sku']) &&
+  isPositiveInteger(payload['quantity']) &&
+  hasOptionalString(payload, 'name') &&
+  hasOptionalString(payload, 'shopId') &&
+  hasOptionalNonNegativeInteger(payload, 'unitPriceCents');
+
+export const isCheckoutCartLinePayload = (
+  payload: unknown,
+): payload is CheckoutCartLinePayload =>
+  isRecord(payload) &&
+  isNonEmptyString(payload['sku']) &&
+  isPositiveInteger(payload['quantity']) &&
+  hasOptionalString(payload, 'name') &&
+  hasOptionalNonNegativeInteger(payload, 'unitPriceCents');
+
+export const isCheckoutCartUpdatedPayload = (
+  payload: unknown,
+): payload is CheckoutCartUpdatedPayload =>
+  isRecord(payload) &&
+  Array.isArray(payload['lines']) &&
+  payload['lines'].every(isCheckoutCartLinePayload) &&
+  isNonNegativeInteger(payload['totalQuantity']) &&
+  hasOptionalNonNegativeInteger(payload, 'subtotalCents');
+
+export const isCheckoutRemoveFromCartPayload = (
+  payload: unknown,
+): payload is CheckoutRemoveFromCartPayload =>
+  isRecord(payload) && isNonEmptyString(payload['sku']);
+
+export const isCheckoutClearCartPayload = (
+  payload: unknown,
+): payload is CheckoutClearCartPayload =>
+  isRecord(payload) && hasOptionalString(payload, 'reason');
+
+export const isExploreSelectedShopPayload = (
+  payload: unknown,
+): payload is ExploreSelectedShopPayload =>
+  isRecord(payload) &&
+  isNonEmptyString(payload['shopId']) &&
+  hasOptionalString(payload, 'name');
+
+export const isMfNavigatePayload = (
+  payload: unknown,
+): payload is MfNavigatePayload =>
+  isRecord(payload) &&
+  isNonEmptyString(payload['to']) &&
+  hasOptionalBoolean(payload, 'replace') &&
+  hasOptionalRecord(payload, 'state');
+
+const tractorEventValidators = {
+  [tractorEventNames.checkoutAddToCart]: isCheckoutAddToCartPayload,
+  [tractorEventNames.checkoutCartUpdated]: isCheckoutCartUpdatedPayload,
+  [tractorEventNames.checkoutClearCart]: isCheckoutClearCartPayload,
+  [tractorEventNames.checkoutRemoveFromCart]: isCheckoutRemoveFromCartPayload,
+  [tractorEventNames.exploreSelectedShop]: isExploreSelectedShopPayload,
+  [tractorEventNames.mfNavigate]: isMfNavigatePayload,
+} satisfies {
+  [Name in TractorEventName]: (
+    payload: unknown,
+  ) => payload is TractorEventPayloadMap[Name];
+};
+
+export const isTractorEventPayload = <Name extends TractorEventName>(
+  eventName: Name,
+  payload: unknown,
+): payload is TractorEventPayloadMap[Name] =>
+  tractorEventValidators[eventName](payload);
+
+export const assertTractorEventPayload = <Name extends TractorEventName>(
+  eventName: Name,
+  payload: unknown,
+): TractorEventPayloadMap[Name] => {
+  if (!isTractorEventPayload(eventName, payload)) {
+    throw new TractorEventValidationError(eventName, payload);
+  }
+
+  return payload;
+};
+
+export const createTractorEvent = <Name extends TractorEventName>(
+  eventName: Name,
+  payload: TractorEventPayloadMap[Name],
+): CustomEvent<TractorEventPayloadMap[Name]> =>
+  new CustomEvent(eventName, {
+    bubbles: true,
+    composed: true,
+    detail: assertTractorEventPayload(eventName, payload),
+  });
+
+export const dispatchTractorEvent = <Name extends TractorEventName>(
+  target: EventTarget,
+  eventName: Name,
+  payload: TractorEventPayloadMap[Name],
+) => target.dispatchEvent(createTractorEvent(eventName, payload));
+
+export const onTractorEvent = <Name extends TractorEventName>(
+  target: EventTarget,
+  eventName: Name,
+  handler: (
+    payload: TractorEventPayloadMap[Name],
+    event: CustomEvent<TractorEventPayloadMap[Name]>,
+  ) => void,
+) => {
+  const listener = (event: Event) => {
+    if (!('detail' in event)) {
+      throw new TractorEventValidationError(eventName, undefined);
+    }
+
+    const customEvent = event as CustomEvent<unknown>;
+    handler(
+      assertTractorEventPayload(eventName, customEvent.detail),
+      customEvent as CustomEvent<TractorEventPayloadMap[Name]>,
+    );
+  };
+
+  target.addEventListener(eventName, listener);
+
+  return () => {
+    target.removeEventListener(eventName, listener);
+  };
+};
+
+const normalizeCheckoutLine = (
+  line: CheckoutCartLinePayload,
+): CheckoutCartLinePayload => {
+  if (!isCheckoutCartLinePayload(line)) {
+    throw new TractorEventValidationError('checkout:cart-updated', line);
+  }
+
+  return {
+    quantity: line.quantity,
+    sku: line.sku,
+    ...(line.name === undefined ? {} : { name: line.name }),
+    ...(line.unitPriceCents === undefined
+      ? {}
+      : { unitPriceCents: line.unitPriceCents }),
+  };
+};
+
+export const createCheckoutCartSnapshot = (
+  lines: readonly CheckoutCartLinePayload[],
+): CheckoutCartUpdatedPayload => {
+  const normalizedLines = lines.map(line => normalizeCheckoutLine(line));
+  const subtotalCents = normalizedLines.reduce(
+    (total, line) => total + (line.unitPriceCents ?? 0) * line.quantity,
+    0,
+  );
+
+  return {
+    lines: normalizedLines,
+    totalQuantity: normalizedLines.reduce(
+      (total, line) => total + line.quantity,
+      0,
+    ),
+    ...(subtotalCents === 0 ? {} : { subtotalCents }),
+  };
+};
+
+export const applyCheckoutCartEvent = (
+  cart: CheckoutCartUpdatedPayload,
+  eventName:
+    | 'checkout:add-to-cart'
+    | 'checkout:remove-from-cart'
+    | 'checkout:clear-cart',
+  payload:
+    | CheckoutAddToCartPayload
+    | CheckoutRemoveFromCartPayload
+    | CheckoutClearCartPayload,
+): CheckoutCartUpdatedPayload => {
+  if (eventName === 'checkout:clear-cart') {
+    assertTractorEventPayload(eventName, payload);
+    return createCheckoutCartSnapshot([]);
+  }
+
+  if (eventName === 'checkout:remove-from-cart') {
+    const removePayload = assertTractorEventPayload(eventName, payload);
+    return createCheckoutCartSnapshot(
+      cart.lines.filter(line => line.sku !== removePayload.sku),
+    );
+  }
+
+  const addPayload = assertTractorEventPayload(eventName, payload);
+  const lines = cart.lines.map(normalizeCheckoutLine);
+  const existingIndex = lines.findIndex(line => line.sku === addPayload.sku);
+  const nextLine = normalizeCheckoutLine({
+    quantity: addPayload.quantity,
+    sku: addPayload.sku,
+    ...(addPayload.name === undefined ? {} : { name: addPayload.name }),
+    ...(addPayload.unitPriceCents === undefined
+      ? {}
+      : { unitPriceCents: addPayload.unitPriceCents }),
+  });
+
+  if (existingIndex === -1) {
+    return createCheckoutCartSnapshot([...lines, nextLine]);
+  }
+
+  const existing = lines[existingIndex];
+  return createCheckoutCartSnapshot(
+    lines.map((line, index) =>
+      index === existingIndex
+        ? normalizeCheckoutLine({
+            ...line,
+            ...nextLine,
+            quantity: existing.quantity + addPayload.quantity,
+          })
+        : line,
+    ),
+  );
+};
+
+export const dispatchCheckoutAddToCart = (
+  target: EventTarget,
+  payload: CheckoutAddToCartPayload,
+) => dispatchTractorEvent(target, 'checkout:add-to-cart', payload);
+
+export const dispatchCheckoutCartUpdated = (
+  target: EventTarget,
+  payload: CheckoutCartUpdatedPayload,
+) => dispatchTractorEvent(target, 'checkout:cart-updated', payload);
+
+export const dispatchCheckoutRemoveFromCart = (
+  target: EventTarget,
+  payload: CheckoutRemoveFromCartPayload,
+) => dispatchTractorEvent(target, 'checkout:remove-from-cart', payload);
+
+export const dispatchCheckoutClearCart = (
+  target: EventTarget,
+  payload: CheckoutClearCartPayload = {},
+) => dispatchTractorEvent(target, 'checkout:clear-cart', payload);
+
+export const dispatchExploreSelectedShop = (
+  target: EventTarget,
+  payload: ExploreSelectedShopPayload,
+) => dispatchTractorEvent(target, 'explore:selected-shop', payload);
+
+export const dispatchMfNavigate = (
+  target: EventTarget,
+  payload: MfNavigatePayload,
+) => dispatchTractorEvent(target, 'mf:navigate', payload);
+
+export const onCheckoutAddToCart = (
+  target: EventTarget,
+  handler: (
+    payload: CheckoutAddToCartPayload,
+    event: CustomEvent<CheckoutAddToCartPayload>,
+  ) => void,
+) => onTractorEvent(target, 'checkout:add-to-cart', handler);
+
+export const onCheckoutCartUpdated = (
+  target: EventTarget,
+  handler: (
+    payload: CheckoutCartUpdatedPayload,
+    event: CustomEvent<CheckoutCartUpdatedPayload>,
+  ) => void,
+) => onTractorEvent(target, 'checkout:cart-updated', handler);
+
+export const onCheckoutRemoveFromCart = (
+  target: EventTarget,
+  handler: (
+    payload: CheckoutRemoveFromCartPayload,
+    event: CustomEvent<CheckoutRemoveFromCartPayload>,
+  ) => void,
+) => onTractorEvent(target, 'checkout:remove-from-cart', handler);
+
+export const onCheckoutClearCart = (
+  target: EventTarget,
+  handler: (
+    payload: CheckoutClearCartPayload,
+    event: CustomEvent<CheckoutClearCartPayload>,
+  ) => void,
+) => onTractorEvent(target, 'checkout:clear-cart', handler);
+
+export const onExploreSelectedShop = (
+  target: EventTarget,
+  handler: (
+    payload: ExploreSelectedShopPayload,
+    event: CustomEvent<ExploreSelectedShopPayload>,
+  ) => void,
+) => onTractorEvent(target, 'explore:selected-shop', handler);
+
+export const onMfNavigate = (
+  target: EventTarget,
+  handler: (
+    payload: MfNavigatePayload,
+    event: CustomEvent<MfNavigatePayload>,
+  ) => void,
+) => onTractorEvent(target, 'mf:navigate', handler);

package/templates/workspace-scripts/assert-mf-types.mjs.handlebars

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+const generatedContractPath = path.join(
+  root,
+  '.modernjs/ultramodern-generated-contract.json',
+);
+const generatedContract = fs.existsSync(generatedContractPath)
+  ? JSON.parse(fs.readFileSync(generatedContractPath, 'utf-8'))
+  : undefined;
+const defaultAppDirs = {{defaultAppDirsJson}};
+
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+  process.stdout.write(`Usage:
+  node scripts/assert-mf-types.mjs [app-dir...]
+
+Checks that every Module Federation remote with exposed modules emitted a non-empty dist/@mf-types.zip archive and uses the workspace TypeScript compiler.
+`);
+  process.exit(0);
+}
+
+const candidateDirs = args;
+const appDirs = candidateDirs.length
+  ? candidateDirs
+  : fs.existsSync(path.join(root, 'module-federation.config.ts'))
+    ? ['.']
+    : defaultAppDirs;
+
+for (const appDir of appDirs) {
+  const configPath = path.join(root, appDir, 'module-federation.config.ts');
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      `Missing Module Federation config: ${path.relative(root, configPath)}`,
+    );
+  }
+
+  const contractEntry = generatedContract?.apps?.find(
+    app => app.path === appDir.replace(/\\/g, '/'),
+  );
+  if (
+    contractEntry &&
+    contractEntry.moduleFederation?.dts?.compilerInstance !==
+      'tsgo'
+  ) {
+    throw new Error(
+      `Module Federation DTS must use the workspace TypeScript compiler: ${appDir}`,
+    );
+  }
+
+  if (contractEntry && contractEntry.moduleFederation?.exposes?.length === 0) {
+    continue;
+  }
+
+  const typesArchivePath = path.join(root, appDir, 'dist/@mf-types.zip');
+  if (!fs.existsSync(typesArchivePath)) {
+    throw new Error(
+      `Missing Module Federation DTS archive: ${path.relative(root, typesArchivePath)}`,
+    );
+  }
+
+  const stats = fs.statSync(typesArchivePath);
+  if (stats.size === 0) {
+    throw new Error(
+      `Empty Module Federation DTS archive: ${path.relative(root, typesArchivePath)}`,
+    );
+  }
+}

package/templates/workspace-scripts/check-ultramodern-i18n-boundaries.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { runWorkspaceSourceCheck } from '@modern-js/code-tools';
+
+const root = path.resolve(import.meta.dirname, '..');
+process.exitCode = runWorkspaceSourceCheck({
+  cwd: root,
+  sourceRoots: ['apps', 'verticals'],
+});