@dreamboard-games/sdk 0.2.0

package/src/infrastructure/workspace-codegen/ownership.ts

@@ -0,0 +1,131 @@
+export type OwnershipPattern = {
+  prefix: string;
+  suffix: string;
+};
+
+export type ScaffoldingOwnership = {
+  version: number;
+  allowedPaths: {
+    rootFiles: string[];
+    directoryPrefixes: string[];
+  };
+  dynamic: {
+    generatedFiles: string[];
+    seedFiles: string[];
+    seedFilePatterns: OwnershipPattern[];
+  };
+  cliStatic: {
+    exactFiles: string[];
+    directoryPrefixes: string[];
+  };
+  preservedUserFiles: string[];
+};
+
+export const WORKSPACE_CODEGEN_OWNERSHIP: ScaffoldingOwnership = {
+  version: 26,
+  allowedPaths: {
+    rootFiles: [
+      ".npmrc",
+      "package.json",
+      "pnpm-lock.yaml",
+      "package-lock.json",
+      "manifest.ts",
+      "manifest.tsconfig.json",
+      "rule.md",
+    ],
+    directoryPrefixes: ["app/", "ui/", "shared/", "test/"],
+  },
+  dynamic: {
+    generatedFiles: [
+      "shared/manifest-literals.ts",
+      "shared/manifest-types.ts",
+      "shared/manifest-runtime.ts",
+      "shared/manifest-contract.ts",
+      "shared/generated/ui-contract.ts",
+      "app/index.ts",
+      "app/tsconfig.framework.json",
+      "ui/tsconfig.framework.json",
+    ],
+    seedFiles: [
+      "app/README.md",
+      "ui/App.tsx",
+      "app/game-contract.ts",
+      "app/game.ts",
+      "app/setup-profiles.ts",
+      "app/reducer-support.ts",
+      "app/derived.ts",
+      "ui/interaction-routes.tsx",
+      "ui/setup-screen.tsx",
+      "ui/styles.ts",
+      "ui/ui-contract-typing-smoke.tsx",
+    ],
+    seedFilePatterns: [{ prefix: "app/phases/", suffix: ".ts" }],
+  },
+  cliStatic: {
+    exactFiles: [
+      ".npmrc",
+      "package.json",
+      "app/tsconfig.json",
+      "ui/index.tsx",
+      "ui/package.json",
+      "ui/style.css",
+      "ui/tsconfig.json",
+    ],
+    directoryPrefixes: [],
+  },
+  preservedUserFiles: [],
+} as const;
+
+export const AUTHORITATIVE_GENERATED_FILES =
+  WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles;
+export const SEED_FILES = WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles;
+export const SEED_FILE_PATTERNS =
+  WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFilePatterns;
+export const PRESERVED_USER_FILES = new Set(
+  WORKSPACE_CODEGEN_OWNERSHIP.preservedUserFiles,
+);
+
+function normalizeProjectPath(filePath: string): string {
+  return filePath.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\\/g, "/");
+}
+
+export function isAllowedGamePath(filePath: string): boolean {
+  const path = normalizeProjectPath(filePath);
+  if (WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.rootFiles.includes(path)) {
+    return true;
+  }
+  return WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.directoryPrefixes.some(
+    (prefix) => path.startsWith(prefix),
+  );
+}
+
+export function isAuthoritativeGeneratedPath(filePath: string): boolean {
+  const path = normalizeProjectPath(filePath);
+  return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles.includes(path);
+}
+
+export function isDynamicSeedPath(filePath: string): boolean {
+  const path = normalizeProjectPath(filePath);
+  if (WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles.includes(path)) {
+    return true;
+  }
+  return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFilePatterns.some(
+    (pattern) =>
+      path.startsWith(pattern.prefix) && path.endsWith(pattern.suffix),
+  );
+}
+
+export function isCliStaticPath(filePath: string): boolean {
+  const path = normalizeProjectPath(filePath);
+  if (WORKSPACE_CODEGEN_OWNERSHIP.cliStatic.exactFiles.includes(path)) {
+    return true;
+  }
+  return WORKSPACE_CODEGEN_OWNERSHIP.cliStatic.directoryPrefixes.some(
+    (prefix) => path.startsWith(prefix),
+  );
+}
+
+export function isLibraryPath(filePath: string): boolean {
+  const path = normalizeProjectPath(filePath);
+  return isAuthoritativeGeneratedPath(path);
+}

package/src/infrastructure/workspace-codegen/preset-card-sets.ts

@@ -0,0 +1,169 @@
+import type {
+  BoardCard,
+  GameTopologyManifest,
+  ManualCardSetDefinition,
+  ObjectSchema,
+  PresetCardSetDefinition,
+  PropertySchema,
+} from "../../types/index.js";
+
+const STANDARD_DECK_ID = "standard_52_deck";
+
+function createEnumPropertySchema(
+  enums: string[],
+  description: string,
+): PropertySchema {
+  return {
+    type: "enum",
+    description,
+    enums,
+  };
+}
+
+function createStringPropertySchema(description: string): PropertySchema {
+  return {
+    type: "string",
+    description,
+  };
+}
+
+export function createStandard52CardDeck(): ManualCardSetDefinition {
+  const suits = ["SPADES", "HEARTS", "CLUBS", "DIAMONDS"];
+  const ranks = [
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "10",
+    "J",
+    "Q",
+    "K",
+    "A",
+    "2",
+  ];
+
+  const cards: BoardCard[] = [];
+  for (const suit of suits) {
+    for (const rank of ranks) {
+      cards.push({
+        type: `${suit}_${rank}`,
+        name: `${rank} of ${suit}`,
+        imageUrl: `/cards/${suit.toLowerCase()}_${rank.toLowerCase()}.png`,
+        text: `A playing card: ${rank} of ${suit}. Value: ${getBigTwoCardValue(rank)}, Suit value: ${getSuitValue(suit)}`,
+        count: 1,
+        cardType: `${suit}_${rank}`,
+        properties: {
+          suit,
+          rank,
+        },
+      });
+    }
+  }
+
+  return {
+    id: STANDARD_DECK_ID,
+    name: "Standard 52-Card Deck",
+    type: "manual",
+    cards,
+    cardSchema: {
+      properties: {
+        suit: createEnumPropertySchema(
+          ["SPADES", "HEARTS", "CLUBS", "DIAMONDS"],
+          "The suit of the card",
+        ),
+        rank: createStringPropertySchema("The rank of the card"),
+      },
+    } satisfies ObjectSchema,
+  };
+}
+
+export function addStandardDecksIfNeeded(
+  manifest: GameTopologyManifest,
+): GameTopologyManifest {
+  return {
+    ...manifest,
+    cardSets: manifest.cardSets.map((cardSet) =>
+      cardSet.type === "preset" && cardSet.presetId === STANDARD_DECK_ID
+        ? {
+            ...createStandard52CardDeck(),
+            id: cardSet.id,
+            name: cardSet.name,
+          }
+        : cardSet,
+    ),
+  };
+}
+
+export function materializePresetCardSet(
+  presetCardSet: PresetCardSetDefinition,
+): ManualCardSetDefinition {
+  if (presetCardSet.presetId !== STANDARD_DECK_ID) {
+    throw new Error(`Unsupported preset deck: ${presetCardSet.presetId}`);
+  }
+
+  const standardDeck = createStandard52CardDeck();
+  return {
+    ...standardDeck,
+    id: presetCardSet.id,
+    name: presetCardSet.name,
+  };
+}
+
+export function materializeCardSet(
+  cardSet: GameTopologyManifest["cardSets"][number],
+): ManualCardSetDefinition {
+  return cardSet.type === "manual"
+    ? cardSet
+    : materializePresetCardSet(cardSet);
+}
+
+function getBigTwoCardValue(rank: string): number {
+  switch (rank) {
+    case "3":
+      return 3;
+    case "4":
+      return 4;
+    case "5":
+      return 5;
+    case "6":
+      return 6;
+    case "7":
+      return 7;
+    case "8":
+      return 8;
+    case "9":
+      return 9;
+    case "10":
+      return 10;
+    case "J":
+      return 11;
+    case "Q":
+      return 12;
+    case "K":
+      return 13;
+    case "A":
+      return 14;
+    case "2":
+      return 15;
+    default:
+      return 0;
+  }
+}
+
+function getSuitValue(suit: string): number {
+  switch (suit) {
+    case "DIAMONDS":
+      return 1;
+    case "CLUBS":
+      return 2;
+    case "HEARTS":
+      return 3;
+    case "SPADES":
+      return 4;
+    default:
+      return 0;
+  }
+}