bleam 0.0.8 → 0.0.10

package/templates/native/scripts/start/native-state.ts

@@ -0,0 +1,242 @@
+import { createHash } from 'node:crypto'
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import path from 'node:path'
+
+export type NativeChangeKind = 'none' | 'incremental' | 'structural'
+
+type NativeFingerprint = {
+  structural: string
+  incremental: string
+}
+
+type NativeState = {
+  version: 1
+  fingerprint: NativeFingerprint
+}
+
+const STATE_FILE_NAME = '.bleam-native-state.json'
+
+const STRUCTURAL_EXACT_FILES = new Set([
+  'Podfile',
+  'Podfile.lock',
+  'Podfile.properties.json',
+  path.join('Pods', 'Manifest.lock'),
+])
+
+const APP_SOURCE_EXTENSIONS = new Set([
+  '.c',
+  '.cc',
+  '.cpp',
+  '.entitlements',
+  '.h',
+  '.hpp',
+  '.m',
+  '.mm',
+  '.plist',
+  '.swift',
+  '.xcconfig',
+])
+
+const IGNORED_SEGMENTS = new Set([
+  '.symlinks',
+  'Headers',
+  'Target Support Files',
+  'Vendor',
+  'build',
+  'xcuserdata',
+])
+
+function getStatePath(rootDir: string): string {
+  return path.join(rootDir, 'build', STATE_FILE_NAME)
+}
+
+function isIgnoredRelativePath(relativePath: string): boolean {
+  const segments = relativePath.split(path.sep)
+  return segments.some((segment) => IGNORED_SEGMENTS.has(segment))
+}
+
+function isStructuralRelativePath(relativePath: string): boolean {
+  if (STRUCTURAL_EXACT_FILES.has(relativePath)) {
+    return true
+  }
+
+  return (
+    relativePath.endsWith(
+      path.join('Pods', 'Pods.xcodeproj', 'project.pbxproj'),
+    ) ||
+    relativePath.endsWith(path.join('.xcodeproj', 'project.pbxproj')) ||
+    relativePath.endsWith(path.join('.xcworkspace', 'contents.xcworkspacedata'))
+  )
+}
+
+function isAppSourceRelativePath(relativePath: string): boolean {
+  if (relativePath.startsWith(`Pods${path.sep}`)) {
+    return false
+  }
+
+  if (isStructuralRelativePath(relativePath)) {
+    return false
+  }
+
+  if (
+    relativePath.includes(`${path.sep}.xcodeproj${path.sep}`) ||
+    relativePath.includes(`${path.sep}.xcworkspace${path.sep}`)
+  ) {
+    return false
+  }
+
+  return APP_SOURCE_EXTENSIONS.has(path.extname(relativePath))
+}
+
+export function classifyNativePath(
+  relativePath: string,
+): NativeChangeKind | null {
+  if (isIgnoredRelativePath(relativePath)) {
+    return null
+  }
+
+  if (isStructuralRelativePath(relativePath)) {
+    return 'structural'
+  }
+
+  if (isAppSourceRelativePath(relativePath)) {
+    return 'incremental'
+  }
+
+  return null
+}
+
+function collectTrackedFiles(
+  rootDir: string,
+): Record<NativeChangeKind, string[]> {
+  const buckets: Record<NativeChangeKind, string[]> = {
+    none: [],
+    incremental: [],
+    structural: [],
+  }
+
+  const iosDir = path.join(rootDir, 'ios')
+  if (!existsSync(iosDir)) {
+    return buckets
+  }
+
+  const walk = (currentDir: string) => {
+    for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+      const fullPath = path.join(currentDir, entry.name)
+      const relativePath = path.relative(iosDir, fullPath)
+
+      if (isIgnoredRelativePath(relativePath)) {
+        continue
+      }
+
+      if (entry.isDirectory()) {
+        walk(fullPath)
+        continue
+      }
+
+      if (!entry.isFile()) {
+        continue
+      }
+
+      const kind = classifyNativePath(relativePath)
+      if (kind) {
+        buckets[kind].push(relativePath)
+      }
+    }
+  }
+
+  walk(iosDir)
+  buckets.incremental.sort()
+  buckets.structural.sort()
+  return buckets
+}
+
+function hashFiles(rootDir: string, relativePaths: string[]): string {
+  const hash = createHash('sha256')
+  const iosDir = path.join(rootDir, 'ios')
+
+  for (const relativePath of relativePaths) {
+    hash.update(relativePath)
+    hash.update('\0')
+    hash.update(readFileSync(path.join(iosDir, relativePath)))
+    hash.update('\0')
+  }
+
+  return hash.digest('hex')
+}
+
+export function computeNativeFingerprint(rootDir: string): NativeFingerprint {
+  const trackedFiles = collectTrackedFiles(rootDir)
+
+  return {
+    structural: hashFiles(rootDir, trackedFiles.structural),
+    incremental: hashFiles(rootDir, trackedFiles.incremental),
+  }
+}
+
+export function readNativeState(rootDir: string): NativeState | null {
+  const statePath = getStatePath(rootDir)
+  if (!existsSync(statePath)) {
+    return null
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, 'utf8')) as NativeState
+    if (
+      parsed.version !== 1 ||
+      typeof parsed.fingerprint?.structural !== 'string' ||
+      typeof parsed.fingerprint?.incremental !== 'string'
+    ) {
+      return null
+    }
+
+    return parsed
+  } catch {
+    return null
+  }
+}
+
+export function writeNativeState(
+  rootDir: string,
+  fingerprint: NativeFingerprint,
+) {
+  const statePath = getStatePath(rootDir)
+  mkdirSync(path.dirname(statePath), { recursive: true })
+  writeFileSync(
+    statePath,
+    `${JSON.stringify({ version: 1, fingerprint }, null, 2)}\n`,
+    'utf8',
+  )
+}
+
+export function clearNativeState(rootDir: string) {
+  rmSync(getStatePath(rootDir), { force: true })
+}
+
+export function getNativeChangeKind(rootDir: string): NativeChangeKind {
+  const previous = readNativeState(rootDir)
+  if (!previous) {
+    return 'structural'
+  }
+
+  const current = computeNativeFingerprint(rootDir)
+  if (
+    current.structural === previous.fingerprint.structural &&
+    current.incremental === previous.fingerprint.incremental
+  ) {
+    return 'none'
+  }
+
+  if (current.structural !== previous.fingerprint.structural) {
+    return 'structural'
+  }
+
+  return 'incremental'
+}

package/templates/native/scripts/start/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}

package/templates/native/scripts/start/swift-packages.ts

@@ -0,0 +1,414 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+
+type SwiftPackageRequirement =
+  | { kind: 'branch'; branch: string }
+  | { kind: 'exactVersion'; version: string }
+  | { kind: 'upToNextMajorVersion'; minimumVersion: string }
+
+type RemoteSwiftPackageRequirement = {
+  identity: string
+  repositoryURL: string
+  requirement: SwiftPackageRequirement
+}
+
+type ResolvedPackagePin = {
+  identity: string
+  location: string
+  state: { branch?: string; revision?: string; version?: string }
+}
+
+export type ResolvePackagesPlan = {
+  args: string[]
+  reason:
+    | 'no-remote-dependencies'
+    | 'missing-package-resolved'
+    | 'missing-resolved-pin'
+    | 'requirement-mismatch'
+    | 'resolved-remote-packages'
+}
+
+type XcodeProjectPackageReferences = {
+  remote: RemoteSwiftPackageRequirement[]
+  localCount: number
+}
+
+type XcodeObject = {
+  isa?: string
+  repositoryURL?: string
+  requirement?: Record<string, unknown>
+  path?: string
+}
+
+const PACKAGE_RESOLVED_CANDIDATES = [
+  path.join('xcshareddata', 'swiftpm', 'Package.resolved'),
+  path.join('xcuserdata', 'swiftpm', 'Package.resolved'),
+]
+
+const REMOTE_PACKAGE_PROGRESS_PATTERNS = [
+  /(?:fetching|updating|cloning)\s*(?:from\s+)?(?<target>https?:\/\/\S+|git@\S+|\S+\.git|[^\s,]+)$/i,
+  /checking out\s+(?<target>[^\s,]+)(?:\s|$)/i,
+  /working copy of package ['"](?<target>[^'"]+)['"]/i,
+  /package ['"](?<target>[^'"]+)['"]/i,
+]
+
+function parseVersion(version: string): number[] | null {
+  const match = version.trim().match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/)
+  if (!match) {
+    return null
+  }
+
+  return [Number(match[1] ?? 0), Number(match[2] ?? 0), Number(match[3] ?? 0)]
+}
+
+function compareVersions(left: string, right: string): number {
+  const leftParts = parseVersion(left)
+  const rightParts = parseVersion(right)
+  if (!leftParts || !rightParts) {
+    return left.localeCompare(right)
+  }
+
+  for (let index = 0; index < 3; index += 1) {
+    const delta = leftParts[index] - rightParts[index]
+    if (delta !== 0) {
+      return delta
+    }
+  }
+
+  return 0
+}
+
+function normalizeIdentity(value: string): string {
+  return (
+    value
+      .trim()
+      .replace(/\.git$/i, '')
+      .replace(/\/+$/, '')
+      .split('/')
+      .pop()
+      ?.toLowerCase() ?? value.trim().toLowerCase()
+  )
+}
+
+function parseRequirement(
+  rawRequirement: Record<string, unknown>,
+): SwiftPackageRequirement | null {
+  const kind =
+    typeof rawRequirement.kind === 'string' ? rawRequirement.kind : null
+  if (!kind) {
+    return null
+  }
+
+  if (kind === 'branch' && typeof rawRequirement.branch === 'string') {
+    return { kind, branch: rawRequirement.branch }
+  }
+
+  if (kind === 'exactVersion' && typeof rawRequirement.version === 'string') {
+    return { kind, version: rawRequirement.version }
+  }
+
+  if (
+    kind === 'upToNextMajorVersion' &&
+    typeof rawRequirement.minimumVersion === 'string'
+  ) {
+    return { kind, minimumVersion: rawRequirement.minimumVersion }
+  }
+
+  return null
+}
+
+function collectSectionEntries(sectionBody: string): string[] {
+  const entries = []
+  let cursor = 0
+
+  while (cursor < sectionBody.length) {
+    const start = sectionBody.indexOf('= {', cursor)
+    if (start === -1) {
+      break
+    }
+
+    let depth = 0
+    let end = start
+    for (; end < sectionBody.length; end += 1) {
+      const char = sectionBody[end]
+      if (char === '{') {
+        depth += 1
+      } else if (char === '}') {
+        depth -= 1
+        if (depth === 0) {
+          const semicolonIndex = sectionBody.indexOf(';', end)
+          if (semicolonIndex === -1) {
+            break
+          }
+          entries.push(sectionBody.slice(start + 3, end + 1))
+          cursor = semicolonIndex + 1
+          break
+        }
+      }
+    }
+
+    if (end >= sectionBody.length) {
+      break
+    }
+  }
+
+  return entries
+}
+
+function parseXcodeObjects(projectContents: string): XcodeObject[] {
+  const objectsMatch = projectContents.match(
+    /objects = \{([\s\S]*?)\n\s*\};\n\s*rootObject =/,
+  )
+  if (!objectsMatch) {
+    return []
+  }
+
+  const objectsBlock = objectsMatch[1]
+  const sections = objectsBlock.split(/\/\* Begin /).slice(1)
+  const objects: XcodeObject[] = []
+
+  for (const section of sections) {
+    const endIndex = section.indexOf('/* End ')
+    const body = endIndex === -1 ? section : section.slice(0, endIndex)
+    for (const rawEntry of collectSectionEntries(body)) {
+      const isa = rawEntry.match(/\bisa = ([^;]+);/)?.[1]?.trim()
+      const repositoryURL = rawEntry
+        .match(/\brepositoryURL = ([^;]+);/)?.[1]
+        ?.trim()
+      const localPath = rawEntry.match(/\bpath = ([^;]+);/)?.[1]?.trim()
+      const requirementBody = rawEntry.match(
+        /\brequirement = \{([\s\S]*?)\n\s*\};/,
+      )
+
+      const requirement: Record<string, unknown> = {}
+      if (requirementBody) {
+        const fieldPattern = /(\w+) = ([^;]+);/g
+        let fieldMatch = fieldPattern.exec(requirementBody[1])
+        while (fieldMatch) {
+          requirement[fieldMatch[1]] = stripPbxString(fieldMatch[2])
+          fieldMatch = fieldPattern.exec(requirementBody[1])
+        }
+      }
+
+      objects.push({
+        isa: isa ? stripPbxString(isa) : undefined,
+        repositoryURL: repositoryURL
+          ? stripPbxString(repositoryURL)
+          : undefined,
+        path: localPath ? stripPbxString(localPath) : undefined,
+        requirement,
+      })
+    }
+  }
+
+  return objects
+}
+
+function stripPbxString(value: string): string {
+  return value.trim().replace(/^"|"$/g, '')
+}
+
+export function readProjectPackageReferences(
+  rootDir: string,
+  projectName: string,
+): XcodeProjectPackageReferences {
+  const projectPath = path.join(
+    rootDir,
+    'ios',
+    `${projectName}.xcodeproj`,
+    'project.pbxproj',
+  )
+  if (!existsSync(projectPath)) {
+    return { remote: [], localCount: 0 }
+  }
+
+  const contents = readFileSync(projectPath, 'utf8')
+  const objects = parseXcodeObjects(contents)
+  const remote: RemoteSwiftPackageRequirement[] = []
+  let localCount = 0
+
+  for (const object of objects) {
+    if (object.isa === 'XCLocalSwiftPackageReference' && object.path) {
+      localCount += 1
+      continue
+    }
+
+    if (
+      object.isa !== 'XCRemoteSwiftPackageReference' ||
+      !object.repositoryURL ||
+      !object.requirement
+    ) {
+      continue
+    }
+
+    const requirement = parseRequirement(object.requirement)
+    if (!requirement) {
+      continue
+    }
+
+    remote.push({
+      identity: normalizeIdentity(object.repositoryURL),
+      repositoryURL: object.repositoryURL,
+      requirement,
+    })
+  }
+
+  remote.sort((left, right) => left.identity.localeCompare(right.identity))
+  return { remote, localCount }
+}
+
+function findPackageResolvedPath(
+  rootDir: string,
+  projectName: string,
+): string | null {
+  const candidateRoots = [
+    path.join(rootDir, 'ios', `${projectName}.xcworkspace`),
+    path.join(
+      rootDir,
+      'ios',
+      `${projectName}.xcodeproj`,
+      'project.xcworkspace',
+    ),
+  ]
+
+  for (const candidateRoot of candidateRoots) {
+    for (const relativePath of PACKAGE_RESOLVED_CANDIDATES) {
+      const fullPath = path.join(candidateRoot, relativePath)
+      if (existsSync(fullPath)) {
+        return fullPath
+      }
+    }
+  }
+
+  return null
+}
+
+function readResolvedPackagePins(
+  rootDir: string,
+  projectName: string,
+): ResolvedPackagePin[] | null {
+  const packageResolvedPath = findPackageResolvedPath(rootDir, projectName)
+  if (!packageResolvedPath) {
+    return null
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(packageResolvedPath, 'utf8')) as {
+      pins?: Array<{
+        identity?: string
+        location?: string
+        repositoryURL?: string
+        state?: ResolvedPackagePin['state']
+      }>
+      object?: {
+        pins?: Array<{
+          identity?: string
+          location?: string
+          repositoryURL?: string
+          state?: ResolvedPackagePin['state']
+        }>
+      }
+    }
+    const pins = parsed.pins ?? parsed.object?.pins ?? []
+    return pins
+      .filter((pin) => typeof pin.state === 'object' && pin.state !== null)
+      .map((pin) => ({
+        identity: normalizeIdentity(
+          pin.identity ?? pin.location ?? pin.repositoryURL ?? '',
+        ),
+        location: pin.location ?? pin.repositoryURL ?? '',
+        state: pin.state ?? {},
+      }))
+      .filter((pin) => pin.identity.length > 0)
+  } catch {
+    return null
+  }
+}
+
+function requirementSatisfied(
+  requirement: SwiftPackageRequirement,
+  pin: ResolvedPackagePin,
+): boolean {
+  if (requirement.kind === 'branch') {
+    return pin.state.branch === requirement.branch
+  }
+
+  if (requirement.kind === 'exactVersion') {
+    return pin.state.version === requirement.version
+  }
+
+  if (!pin.state.version) {
+    return false
+  }
+
+  const minimumParts = parseVersion(requirement.minimumVersion)
+  const versionParts = parseVersion(pin.state.version)
+  if (!minimumParts || !versionParts) {
+    return compareVersions(pin.state.version, requirement.minimumVersion) >= 0
+  }
+
+  return (
+    versionParts[0] === minimumParts[0] &&
+    compareVersions(pin.state.version, requirement.minimumVersion) >= 0
+  )
+}
+
+export function getSwiftPackageResolvePlan(
+  rootDir: string,
+  projectName: string,
+): ResolvePackagesPlan {
+  const references = readProjectPackageReferences(rootDir, projectName)
+  if (references.remote.length === 0) {
+    return {
+      args: [],
+      reason: 'no-remote-dependencies',
+    }
+  }
+
+  const pins = readResolvedPackagePins(rootDir, projectName)
+  if (!pins) {
+    return {
+      args: [],
+      reason: 'missing-package-resolved',
+    }
+  }
+
+  const pinsByIdentity = new Map(pins.map((pin) => [pin.identity, pin]))
+  for (const remote of references.remote) {
+    const pin = pinsByIdentity.get(remote.identity)
+    if (!pin) {
+      return {
+        args: [],
+        reason: 'missing-resolved-pin',
+      }
+    }
+
+    if (!requirementSatisfied(remote.requirement, pin)) {
+      return {
+        args: [],
+        reason: 'requirement-mismatch',
+      }
+    }
+  }
+
+  return {
+    args: ['-skipPackageUpdates'],
+    reason: 'resolved-remote-packages',
+  }
+}
+
+export function extractPackageProgressLabel(line: string): string | null {
+  for (const pattern of REMOTE_PACKAGE_PROGRESS_PATTERNS) {
+    const match = line.match(pattern)
+    const target = match?.groups?.target?.trim()
+    if (!target) {
+      continue
+    }
+
+    return normalizeIdentity(target)
+      .split(/[\s#?]/)[0]
+      .replace(/^["']|["']$/g, '')
+  }
+
+  return null
+}