bundo-appgen 0.0.9 → 0.0.11

package/src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/create-asset-catalogs.mts

@@ -1,7 +1,18 @@
+import * as node_fs from "node:fs"
+import * as node_path from "node:path"
+
 import type {
 	Config,
 } from "../../../../../index.mts"
 
+import {
+	ConfigHelpers,
+} from "../../../_helpers/index.mts"
+
+import {
+	getXcassetsPath,
+} from "./_get-xcassets-path.mts"
+
 import {
 	initAppiconsets,
 } from "./_init-appiconsets.mts"
@@ -15,40 +26,214 @@ export function createAssetCatalogs(
 	metadata: {
 		bundleIdentifier: string,
 		namespace?: string,
-		platform: "macos" | "ios",
-		projectName: string,
+		platform: "macos",
 	},
 ) {
+
+	const
+		xcassetsPath =
+			getXcassetsPath(metadata.platform),
+
+		assetCatalogsTrackerFilePath =
+			ConfigHelpers.CachePaths.assetCatalogsTrackerFile()
+
+	let catalogsTracker: CatalogsTrackerSchema = {
+		appiconsets: undefined,
+		imagesets: undefined,
+	}
+
+	function removeAllCatalogs() {
+		// remove the Assets.xcassets directory including its files if any.
+		if(node_fs.existsSync(xcassetsPath)) {
+			node_fs.rmSync(
+				xcassetsPath,
+				{
+					recursive: true,
+					force: true,
+				},
+			)
+		}
+
+		if(node_fs.existsSync(assetCatalogsTrackerFilePath)) {
+			node_fs.rmSync(assetCatalogsTrackerFilePath)
+		}
+	}
+
 	if(!assetCatalogs) {
+		removeAllCatalogs()
 		return
 	}
 
+	try {
+		if(node_fs.existsSync(assetCatalogsTrackerFilePath)) {
+			catalogsTracker = JSON.parse(
+				node_fs.readFileSync(assetCatalogsTrackerFilePath, "utf8"),
+			) as CatalogsTrackerSchema
+		}
+	} catch {
+		// the tracker file is not a valid JSON file
+		// remove the Assets.xcassets directory including its files if any.
+		removeAllCatalogs()
+	}
+
+	// +++++ Create Catalog Files +++++
+	const newCatalogsTracker = createCatalogs(
+		assetCatalogs,
+		{
+			bundleIdentifier: metadata.bundleIdentifier,
+			platform: metadata.platform,
+			namespace: metadata.namespace,
+		},
+	)
+	// ----- Create Catalog Files -----
+
+	catalogsTracker.appiconsets?.forEach(existingCatalog => {
+		if(newCatalogsTracker.appiconsets?.indexOf(existingCatalog) === -1) {
+			const existingPath = node_path.join(xcassetsPath, existingCatalog + ".appiconset")
+
+			if(node_fs.existsSync(existingPath)) {
+				node_fs.rmSync(
+					existingPath,
+					{
+						recursive: true,
+						force: true,
+					},
+				)
+			}
+		}
+	})
+
+	catalogsTracker.imagesets?.forEach(existingCatalog => {
+		if(newCatalogsTracker.imagesets?.indexOf(existingCatalog) === -1) {
+			/**
+			 * "Long/Ass/Namespace/Image" -> "Long"
+			 */
+			const existingCatalogBasename = existingCatalog.split("/")[0]
+
+			if(!existingCatalogBasename) {
+				return
+			}
+
+			const existingPath = node_path.join(
+				xcassetsPath,
+				existingCatalogBasename,
+			)
+
+			if(node_fs.existsSync(existingPath)) {
+				// remove namespace directory
+				node_fs.rmSync(
+					existingPath,
+					{
+						recursive: true,
+						force: true,
+					},
+				)
+			} else {
+				const imagesetDir = node_path.join(existingCatalogBasename, ".imageset")
+				if(node_fs.existsSync(imagesetDir)) {
+					node_fs.rmSync(
+						imagesetDir,
+						{
+							recursive: true,
+							force: true,
+						},
+					)
+				}
+			}
+		}
+	})
+
+	node_fs.writeFileSync(
+		assetCatalogsTrackerFilePath,
+		JSON.stringify(newCatalogsTracker, null, 2),
+		"utf8",
+	)
+}
+
+function createCatalogs(
+	assetCatalogs: NonNullable<Config.Apple.Data["assetCatalogs"]>,
+	metadata: {
+		bundleIdentifier: string,
+		namespace?: string,
+		platform: "macos",
+	},
+	nextTracker?: CatalogsTrackerSchema,
+): CatalogsTrackerSchema {
+
+	const tracker: CatalogsTrackerSchema = nextTracker ?? {
+		appiconsets: undefined,
+		imagesets: undefined,
+	}
+
+	if(!assetCatalogs) {
+		return tracker
+	}
+
+	let isRecursived = false
+
 	for(const _key of Object.keys(assetCatalogs)) {
 		const key = _key as keyof typeof assetCatalogs
 
 		if(key == "imagesets") {
-			initImagesets(
+			const trackedCatalogs = initImagesets(
 				assetCatalogs.imagesets,
 				metadata,
 			)
+
+			if(trackedCatalogs?.length) {
+				if(!tracker.imagesets?.length) {
+					tracker.imagesets = trackedCatalogs
+				} else {
+					tracker.imagesets = [
+						...tracker.imagesets,
+						...trackedCatalogs,
+					]
+				}
+			}
 		} else if(key == "appiconsets") {
-			initAppiconsets(
-				assetCatalogs.appiconsets,
-				metadata,
-			)
+			if(!isRecursived) {
+				// appiconset cannot be created under a namespace
+
+				const trackedCatalogs = initAppiconsets(
+					assetCatalogs.appiconsets,
+					metadata,
+				)
+
+				if(trackedCatalogs?.length) {
+					if(!tracker.appiconsets?.length) {
+						tracker.appiconsets = trackedCatalogs
+					} else {
+						tracker.appiconsets = [
+							...tracker.appiconsets,
+							...trackedCatalogs,
+						]
+					}
+				}
+			}
 		} else {
 			// key is namespace
 			const namespacedCatalogs = assetCatalogs[key] as unknown as Config.Apple.AssetCatalogs
 
 			if(namespacedCatalogs && Object.keys(namespacedCatalogs).length) {
-				createAssetCatalogs(
+				isRecursived = true
+
+				createCatalogs(
 					namespacedCatalogs,
 					{
 						...metadata,
-						namespace: key,
+						namespace: metadata.namespace ? `${metadata.namespace}/${key as string}` : key,
 					},
+					tracker,
 				)
 			}
 		}
 	}
+
+	return tracker
+
+}
+
+interface CatalogsTrackerSchema {
+	appiconsets: string[] | undefined,
+	imagesets: string[] | undefined,
 }

package/src/_bin/_main/_init-template/_init-apple/_create-string-catalogs/create-string-catalog.mts

@@ -15,7 +15,7 @@ export function createStringCatalogs(
 	stringCatalogs: Config.Apple.Data["stringCatalogs"],
 	locales: string[] | undefined = ["en"],
 	metadata: {
-		platform: "macos" | "ios",
+		platform: "macos",
 	},
 ) {
 
@@ -23,7 +23,7 @@ export function createStringCatalogs(
 		config =
 			GlobalVars.appConfig.get(),
 
-		nativeProjectDir =
+		targetProjectDir =
 			node_path.join(
 				node_path.dirname(
 					GlobalVars.configFilePath.get(),
@@ -35,100 +35,178 @@ export function createStringCatalogs(
 		catalogs =
 			stringCatalogs
 				? Object.entries(stringCatalogs)
-				: null
-
-	if(catalogs?.length) {
-		for(const [catalogName, data] of catalogs) {
-			const
-				json: {
-					sourceLanguage: string,
-					strings: {
-						[Key in string]: {
-							extractionState: "manual",
-							localizations: {
-								[Locale in string]: {
-									stringUnit: {
-										state: "translated",
-										value: string,
-									}
+				: null,
+
+		stringCatalogsTrackerFilePath =
+			ConfigHelpers.CachePaths.stringCatalogsTrackerFile()
+
+	let catalogsTracker: CatalogsTrackerSchema = {
+		catalogs: undefined,
+	}
+
+	if(!catalogs?.length) {
+		if(node_fs.existsSync(stringCatalogsTrackerFilePath)) {
+			node_fs.rmSync(stringCatalogsTrackerFilePath)
+		}
+
+		return
+	}
+
+	try {
+		catalogsTracker =
+			node_fs.existsSync(stringCatalogsTrackerFilePath)
+				? JSON.parse(
+					node_fs.readFileSync(stringCatalogsTrackerFilePath, "utf8"),
+				) as CatalogsTrackerSchema
+				: { catalogs: undefined } satisfies CatalogsTrackerSchema
+	} catch {
+		// do nothing
+	}
+
+	if(catalogsTracker.catalogs?.length) {
+		catalogsTracker.catalogs.slice().forEach((existingCatalog, index) => {
+			if(!stringCatalogs?.[existingCatalog]) {
+				const existingPath = getCatalogFilePath({
+					targetProjectDirectory: targetProjectDir,
+					catalogName: existingCatalog,
+				})
+				if(node_fs.existsSync(existingPath)) {
+					node_fs.rmSync(
+						existingPath,
+						{
+							force: true,
+						},
+					)
+				}
+
+				catalogsTracker.catalogs?.splice(index, 1)
+			}
+		})
+	}
+
+	for(const [catalogName, data] of catalogs) {
+		const
+			json: {
+				sourceLanguage: string,
+				strings: {
+					[Key in string]: {
+						extractionState: "manual",
+						localizations: {
+							[Locale in string]: {
+								stringUnit: {
+									state: "translated",
+									value: string,
 								}
 							}
 						}
-					},
-					version: string,
-				} =
-					{
-						sourceLanguage: locales[0]!,
-						strings: {},
-						version: "1.2",
-					},
-				/**
-				 * The string key
-				 */
-				keys =
-					Object.keys(data)
-
-			for(const key of keys) {
-				const localizedValue = data[key]
-
-				if(!localizedValue) {
-					throw new Error(`String catalog of ${catalogName} has invalid configuration.`)
-				}
+					}
+				},
+				version: string,
+			} =
+				{
+					sourceLanguage: locales[0]!,
+					strings: {},
+					version: "1.2",
+				},
+			/**
+			 * The string key
+			 */
+			keys =
+				Object.keys(data)
+
+		for(const key of keys) {
+			const localizedValue = data[key]
+
+			if(!localizedValue) {
+				throw new Error(`String catalog of ${catalogName} has invalid configuration.`)
+			}
 
-				const localesOfValue = Object.keys(localizedValue)
+			const localesOfValue = Object.keys(localizedValue)
 
-				{
-					// check language from locale
-					for(const localeOfValue of localesOfValue) {
-						if(locales.indexOf(localeOfValue) == -1) {
-							throw new Error(`"${localeOfValue}" was not found from your \`locales\` config. Add "${localeOfValue}" to the \`locales\` array.`)
-						}
+			{
+				// check language from locale
+				for(const localeOfValue of localesOfValue) {
+					if(locales.indexOf(localeOfValue) == -1) {
+						throw new Error(`"${localeOfValue}" was not found from your \`locales\` config. Add "${localeOfValue}" to the \`locales\` array.`)
 					}
 				}
+			}
 
-				localesOfValue.forEach(locale => {
-					const value = localizedValue[locale]
+			localesOfValue.forEach(locale => {
+				const value = localizedValue[locale]
 
-					if(!value) {
-						throw new Error(`\`stringCatalogs.${key}.${locale}\` is empty.`)
-					}
+				if(!value) {
+					throw new Error(`\`stringCatalogs.${key}.${locale}\` is empty.`)
+				}
 
-					if(!json.strings[key]) {
-						json.strings[key] = {
-							extractionState: "manual",
-							localizations: {
-								[locale]: {
-									stringUnit: {
-										state: "translated",
-										value,
-									},
+				if(!json.strings[key]) {
+					json.strings[key] = {
+						extractionState: "manual",
+						localizations: {
+							[locale]: {
+								stringUnit: {
+									state: "translated",
+									value,
 								},
 							},
-						}
-					} else {
-						json.strings[key].localizations[locale] = {
-							stringUnit: {
-								state: "translated",
-								value,
-							},
-						}
+						},
 					}
-				})
-			}
+				} else {
+					json.strings[key].localizations[locale] = {
+						stringUnit: {
+							state: "translated",
+							value,
+						},
+					}
+				}
+			})
+		}
 
-			node_fs.writeFileSync(
-				node_path.join(
-					nativeProjectDir,
-					`${catalogName}.xcstrings`,
-				),
-				JSON.stringify(
-					json,
-					null,
-					2,
-				),
-				"utf8",
-			)
+		node_fs.writeFileSync(
+			getCatalogFilePath({
+				targetProjectDirectory: targetProjectDir,
+				catalogName,
+			}),
+			JSON.stringify(
+				json,
+				null,
+				2,
+			),
+			"utf8",
+		)
+
+		if(!catalogsTracker.catalogs?.length) {
+			catalogsTracker.catalogs = []
+		}
+
+		if(catalogsTracker.catalogs.indexOf(catalogName) == -1) {
+			catalogsTracker.catalogs.push(catalogName)
 		}
 	}
 
+	node_fs.writeFileSync(
+		stringCatalogsTrackerFilePath,
+		JSON.stringify(catalogsTracker, null, 2),
+		"utf8",
+	)
+
+}
+
+interface CatalogsTrackerSchema {
+	/**
+	 * The catalog / file name
+	 */
+	catalogs: string[] | undefined,
+}
+
+function getCatalogFilePath(
+	data: {
+		targetProjectDirectory: string,
+		catalogName: string,
+	},
+) {
+	return node_path.join(
+		data.targetProjectDirectory,
+		`${data.catalogName}.xcstrings`,
+	)
 }

package/src/_bin/_main/_init-template/_init-apple/_mod-files/_app-delegate-swift.mts

@@ -10,7 +10,7 @@ import {
 } from "../../../_helpers/index.mts"
 
 export function appDelegateSwift(
-	platform: "macos" | "ios",
+	platform: "macos",
 ) {
 
 	const
@@ -18,7 +18,7 @@ export function appDelegateSwift(
 			GlobalVars.appConfig.get(),
 
 		projectName =
-			ConfigHelpers.getProjectName(appConfig, platform),
+			ConfigHelpers.getProjectName(appConfig, platform)!, // already validated
 
 		appName =
 			ConfigHelpers.getName(
@@ -30,10 +30,7 @@ export function appDelegateSwift(
 			node_path.join(
 				node_path.dirname(GlobalVars.configFilePath.get()),
 				platform,
-				ConfigHelpers.getProjectName(
-					GlobalVars.appConfig.get(),
-					platform,
-				)!,
+				projectName,
 				"AppDelegate.swift",
 			)
 

package/src/_bin/_main/_init-template/_init-apple/_mod-files/_podfile/_pod-dependencies.mts

@@ -0,0 +1,78 @@
+import * as node_fs from "node:fs"
+import * as node_path from "node:path"
+
+import {
+	GlobalVars,
+} from "../../../../../_global-vars/index.mts"
+
+export function podDependencies(
+	platform: "macos",
+) {
+
+	const
+		dependencies =
+			GlobalVars.appConfig.get()[platform as "macos"]?.Podfile?.dependencies,
+
+		nativeProjectDir =
+			node_path.join(
+				node_path.dirname(GlobalVars.configFilePath.get()),
+				platform,
+			)
+
+	const podDependenciesFilePath = node_path.join(nativeProjectDir, "pod_dependencies.rb")
+
+	let podDependenciesFile = "def pod_dependencies"
+
+	dependencies?.forEach(dependency => {
+		// start with a line break and 2 spaces
+		let tx = `\n  pod '${dependency.name}'`
+
+		if(dependency.type == "cocoapods") {
+			if(dependency.version) {
+				tx += `, '${dependency.version}'`
+			}
+		} else if(dependency.type == "git") {
+			if(!dependency.url || typeof dependency.url != "string") {
+				throw new Error("\"gitUrl\" is empty or not a valid string for a pod spec source.")
+			}
+
+			tx += `, :git => '${dependency.url}'`
+
+			if(dependency.revision) {
+				if(
+					dependency.revision.type !== "branch" &&
+					dependency.revision.type !== "commit" &&
+					dependency.revision.type !== "tag"
+				) {
+					throw new Error("Expected \"branch\", or \"commit\", or \"tag\" for the revision type.")
+				}
+
+				if(
+					typeof dependency.revision.ref != "string" ||
+					!dependency.revision.ref
+				) {
+					throw new Error("Revision ref is empty or not a valid string.")
+				}
+
+				tx += `, :${dependency.revision.type} => '${dependency.revision.ref}'`
+			}
+		} else if(dependency.type == "local") {
+			if(!dependency.path || typeof dependency.path != "string") {
+				throw new Error("\"path\" is empty or not a valid string for a local pod.")
+			}
+
+			tx += `, :path => '${dependency.path}'`
+		}
+
+		podDependenciesFile += tx
+	})
+
+	podDependenciesFile += "\nend\n"
+
+	node_fs.writeFileSync(
+		podDependenciesFilePath,
+		podDependenciesFile,
+		"utf8",
+	)
+
+}

package/src/_bin/_main/_init-template/_init-apple/_mod-files/_podfile/index.mts

@@ -0,0 +1 @@
+export * from "./podfile.mts"

package/src/_bin/_main/_init-template/_init-apple/_mod-files/{_podfile.mts → _podfile/podfile.mts}

@@ -3,22 +3,32 @@ import * as node_path from "node:path"
 
 import {
 	GlobalVars,
-} from "../../../../_global-vars/index.mts"
+} from "../../../../../_global-vars/index.mts"
 
 import {
 	ConfigHelpers,
-} from "../../../_helpers/index.mts"
+} from "../../../../_helpers/index.mts"
+
+import {
+	podDependencies,
+} from "./_pod-dependencies.mts"
 
 export function podfile(
-	platform: "macos" | "ios",
+	platform: "macos",
 ) {
 
 	const
 		projectName =
 			ConfigHelpers.getProjectName(GlobalVars.appConfig.get(), platform)!, // already validated
 
+		nativeProjectDir =
+			node_path.join(
+				node_path.dirname(GlobalVars.configFilePath.get()),
+				platform,
+			),
+
 		podfilePath =
-			node_path.join(node_path.dirname(GlobalVars.configFilePath.get()), platform, "Podfile")
+			node_path.join(nativeProjectDir, "Podfile")
 
 	let
 		podfileText =
@@ -28,4 +38,6 @@ export function podfile(
 
 	node_fs.writeFileSync(podfilePath, podfileText, "utf8")
 
+	podDependencies(platform)
+
 }