optikit 1.0.1

package/dist/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import boxen from "boxen";
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+import { generateModule } from "./commands/generateModule.js";
+import { cleanProject } from "./commands/cleanProject.js";
+import { cleanIosProject } from "./commands/cleanProjectIos.js";
+import { updateFlutterVersion } from "./commands/updateVersions.js";
+import { buildFlutterApk, buildFlutterBundle, buildFlutterIos, buildFlutterIpa, } from "./commands/buildReleases.js";
+import { boxenOptions } from "./styles.js";
+import { openIos, openAndroid } from "./commands/openProject.js";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const packageInfo = require("../package.json");
+const version = packageInfo.version;
+const greeting = chalk.white.bold("Hello ^_^");
+console.log(boxen(greeting, boxenOptions));
+const options = yargs(hideBin(process.argv))
+    .command("generate module <moduleName>", "Generate a module with structure", (yargs) => {
+    return yargs.positional("moduleName", {
+        describe: "The name of the module to generate",
+        type: "string",
+    });
+}, (argv) => {
+    const moduleName = argv.moduleName;
+    generateModule(moduleName);
+})
+    .command("clean-flutter", "Clean the Flutter project", (yargs) => {
+    return yargs.option("disable-fvm", {
+        type: "boolean",
+        default: false,
+        description: "Run without FVM (use --disable-fvm to enable)",
+    });
+}, (argv) => {
+    const noFvm = argv.disableFvm;
+    cleanProject(noFvm);
+})
+    .command("clean-ios", "Clean the iOS project", (yargs) => {
+    return yargs
+        .option("clean-cache", {
+        type: "boolean",
+        default: false,
+        description: "Run with CocoaPods cache cleaning (use --clean-cache to enable)",
+    })
+        .option("repo-update", {
+        type: "boolean",
+        default: false,
+        description: "Run pod install with repository update (use --repo-update to enable)",
+    });
+}, (argv) => {
+    const cleanCache = argv.cleanCache;
+    const repoUpdate = argv.repoUpdate;
+    cleanIosProject(cleanCache, repoUpdate);
+})
+    .command("flutter-build-apk", "Build the Flutter APK with release configuration, obfuscation, and split debug info", (yargs) => {
+    return yargs.option("disable-fvm", {
+        type: "boolean",
+        default: false,
+        description: "Run without FVM (use --disable-fvm to enable)",
+    });
+}, async (argv) => {
+    const noFvm = argv.disableFvm;
+    await buildFlutterApk(noFvm);
+})
+    .command("flutter-build-bundle", "Build the Flutter Bundle with release configuration, obfuscation, and split debug info", (yargs) => {
+    return yargs.option("disable-fvm", {
+        type: "boolean",
+        default: false,
+        description: "Run without FVM (use --disable-fvm to enable)",
+    });
+}, async (argv) => {
+    const noFvm = argv.disableFvm;
+    await buildFlutterBundle(noFvm);
+})
+    .command("flutter-build-ios", "Build the Flutter iOS app with release configuration and increment the build version", (yargs) => {
+    return yargs.option("disable-fvm", {
+        type: "boolean",
+        default: false,
+        description: "Run without FVM (use --disable-fvm to enable)",
+    });
+}, async (argv) => {
+    const noFvm = argv.disableFvm;
+    await buildFlutterIos(noFvm);
+})
+    .command("flutter-build-ipa", "Create a release IPA with an updated build version number", (yargs) => {
+    return yargs.option("disable-fvm", {
+        type: "boolean",
+        default: false,
+        description: "Run without FVM (use --disable-fvm to enable)",
+    });
+}, async (argv) => {
+    const noFvm = argv.disableFvm;
+    await buildFlutterIpa(noFvm);
+})
+    .command("flutter-update-version", "Update version and build numbers for both Android and iOS", (yargs) => {
+    return yargs
+        .option("app-version", {
+        type: "string",
+        description: "The version number to set for both Android and iOS",
+        demandOption: false,
+        default: "",
+    })
+        .option("android-build", {
+        type: "string",
+        description: "The Android build number to set in pubspec.yaml",
+        demandOption: false,
+        default: "",
+    })
+        .option("ios-build", {
+        type: "string",
+        description: "The iOS build number to set using agv-tool and Info.plist",
+        demandOption: false,
+        default: "",
+    });
+}, async (argv) => {
+    const version = argv["app-version"];
+    const androidBuildNumber = argv["android-build"];
+    const iosBuildNumber = argv["ios-build"];
+    await updateFlutterVersion(version, androidBuildNumber, iosBuildNumber);
+})
+    .command("open-ios", "Open the iOS project in Xcode", {}, async () => {
+    await openIos();
+})
+    .command("open-android", "Open the Android project in Android Studio", {}, async () => {
+    await openAndroid();
+})
+    .version(version)
+    .help(true).argv;

package/dist/commands/buildReleases.js

@@ -0,0 +1,83 @@
+import { execCommand } from "../utils/execHelpers.js";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+export { buildFlutterApk, buildFlutterBundle, buildFlutterIos, buildFlutterIpa, };
+async function buildFlutterApk(noFvm) {
+    LoggerHelpers.info(noFvm
+        ? "Building Flutter APK without FVM..."
+        : "Building Flutter APK with FVM...");
+    const command = noFvm
+        ? "flutter build apk --release --obfuscate --split-debug-info=build/app/outputs/symbols"
+        : "fvm flutter build apk --release --obfuscate --split-debug-info=build/app/outputs/symbols";
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Flutter APK build successful.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error during APK build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error during APK build: ${error}`);
+        }
+    }
+}
+async function buildFlutterBundle(noFvm) {
+    LoggerHelpers.info(noFvm
+        ? "Building Flutter Bundle without FVM..."
+        : "Building Flutter Bundle with FVM...");
+    const command = noFvm
+        ? "flutter build appbundle --release --obfuscate --split-debug-info=build/app/outputs/symbols"
+        : "fvm flutter build appbundle --release --obfuscate --split-debug-info=build/app/outputs/symbols";
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Flutter Bundle build successful.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error during Bundle build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error during Bundle build: ${error}`);
+        }
+    }
+}
+async function buildFlutterIos(noFvm) {
+    LoggerHelpers.info(noFvm
+        ? "Building Flutter iOS app without FVM..."
+        : "Building Flutter iOS app with FVM...");
+    const command = noFvm
+        ? "flutter build ios --release"
+        : "fvm flutter build ios --release";
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Flutter iOS app build successful.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error during iOS build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error during iOS build: ${error}`);
+        }
+    }
+}
+async function buildFlutterIpa(noFvm) {
+    LoggerHelpers.info(noFvm
+        ? "Creating release IPA without FVM..."
+        : "Creating release IPA with FVM...");
+    const command = noFvm
+        ? "flutter build ipa --release"
+        : "fvm flutter build ipa --release";
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Release IPA creation successful.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error during IPA creation: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error during IPA creation: ${error}`);
+        }
+    }
+}

package/dist/commands/cleanProject.js

@@ -0,0 +1,21 @@
+import { execCommand } from "../utils/execHelpers.js";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+export { cleanProject };
+async function cleanProject(noFvm) {
+    LoggerHelpers.info(noFvm ? "Running clean without FVM..." : "Running clean with FVM...");
+    const command = noFvm
+        ? "flutter clean && rm -rf pubspec.lock && flutter pub get"
+        : "fvm flutter clean && rm -rf pubspec.lock && fvm flutter pub get";
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Project cleaned successfully.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error during clean: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error during clean: ${error}`);
+        }
+    }
+}

package/dist/commands/cleanProjectIos.js

@@ -0,0 +1,99 @@
+import * as fs from "fs";
+import * as path from "path";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { execInIos, execCommand, iosDirectory, execInIosWithRetry } from "../utils/execHelpers.js";
+export { cleanIosProject };
+async function getFlutterSdkPath() {
+    const fvmDir = path.join(process.cwd(), ".fvm", "flutter_sdk");
+    if (fs.existsSync(fvmDir)) {
+        LoggerHelpers.info(`Using FVM Flutter SDK...`);
+        return fvmDir;
+    }
+    const command = "which flutter";
+    try {
+        const globalFlutterPath = await execCommand(command);
+        LoggerHelpers.info("Using Flutter SDK...");
+        return path.dirname(globalFlutterPath.trim());
+    }
+    catch (error) {
+        LoggerHelpers.error("Flutter SDK not found. Please ensure Flutter is installed.");
+        throw error;
+    }
+}
+async function getFlutterXcframeworkPath() {
+    const flutterSdkPath = await getFlutterSdkPath();
+    return path.join(flutterSdkPath, "bin/cache/artifacts/engine/ios/Flutter.xcframework");
+}
+async function ensureFlutterArtifactsExist() {
+    const flutterXcframeworkPath = await getFlutterXcframeworkPath();
+    if (!fs.existsSync(flutterXcframeworkPath)) {
+        LoggerHelpers.warning("Flutter.xcframework not found.");
+        try {
+            LoggerHelpers.info("Downloading Flutter.xcframework...");
+            await execCommand("fvm flutter precache --ios");
+            LoggerHelpers.success("Flutter.xcframework has been downloaded successfully.");
+        }
+        catch (error) {
+            LoggerHelpers.error(`Failed to run precache: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    else {
+        LoggerHelpers.success("Flutter.xcframework exists. No need to run 'fvm flutter precache --ios'.");
+    }
+}
+async function cleanIosProject(cleanCache, repoUpdate) {
+    try {
+        const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+        if (!fs.existsSync(xcodeProjPath)) {
+            LoggerHelpers.error("No Xcode project found in the ios directory.");
+            return;
+        }
+        LoggerHelpers.info("Running clean for iOS project...");
+        await ensureFlutterArtifactsExist();
+        LoggerHelpers.info("Removing Podfile.lock...");
+        await execInIos("rm -rf Podfile.lock");
+        LoggerHelpers.success("Removed Podfile.lock.");
+        LoggerHelpers.info("Deintegrating pods...");
+        await execInIos("pod deintegrate");
+        LoggerHelpers.success("Deintegrated pods.");
+        if (cleanCache) {
+            LoggerHelpers.info("Cleaning CocoaPods cache...");
+            await execInIos("pod cache clean --all");
+            LoggerHelpers.success("Cleaned CocoaPods cache.");
+        }
+        if (repoUpdate) {
+            LoggerHelpers.info("Updating CocoaPods repositories...");
+            try {
+                await execInIosWithRetry("pod repo update", 3, 10000);
+                LoggerHelpers.success("Updated CocoaPods repositories.");
+            }
+            catch (error) {
+                LoggerHelpers.error("Failed to update CocoaPods repositories. Retrying...");
+            }
+            LoggerHelpers.info("Installing pods with repo update...");
+            try {
+                await execInIosWithRetry("pod update", 3, 10000);
+                LoggerHelpers.success("Installed pods with repo update.");
+            }
+            catch (error) {
+                LoggerHelpers.error("Failed to update pods. Retrying...");
+            }
+        }
+        else {
+            LoggerHelpers.info("Installing pods without repo update...");
+            await execInIosWithRetry("pod install", 3, 10000);
+            LoggerHelpers.success("Installed pods without repo update.");
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error: ${error.message}`);
+        }
+        else if (typeof error === "string") {
+            LoggerHelpers.error(`Error: ${error}`);
+        }
+        else {
+            LoggerHelpers.error(`Unknown error: ${JSON.stringify(error)}`);
+        }
+    }
+}

package/dist/commands/generateModule.js

@@ -0,0 +1,115 @@
+import path from "path";
+import { createDirectories, writeFile, getClassName, } from "../utils/fileHelpers.js";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+export { generateModule };
+function generateModule(moduleName) {
+    const modulePath = path.join("lib", "module", moduleName);
+    const directories = ["bloc", "event", "state", "screen", "import", "factory"];
+    createDirectories(modulePath, directories);
+    LoggerHelpers.info(`Creating module structure for ${moduleName}...`);
+    generateBloc(moduleName, path.join(modulePath, "bloc"));
+    generateEvent(moduleName, path.join(modulePath, "event"));
+    generateState(moduleName, path.join(modulePath, "state"));
+    generateScreen(moduleName, path.join(modulePath, "screen"));
+    generateImport(moduleName, path.join(modulePath, "import"));
+    generateStateFactory(moduleName, path.join(modulePath, "factory"));
+    LoggerHelpers.success(`Module ${moduleName} created with full structure.`);
+}
+function generateBloc(moduleName, blocPath) {
+    const blocFilePath = path.join(blocPath, `${moduleName}_bloc.dart`);
+    const className = getClassName(moduleName, "bloc");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}Bloc extends BaseBloc {
+    ${className}Bloc() : super(
+    ${className}Factory(), 
+    initialState: ${className}InitialState(),
+    ) {}
+
+    @override
+    void onDispose() {}
+}
+  `;
+    writeFile(blocFilePath, template);
+    LoggerHelpers.success(`Bloc file ${moduleName}_bloc.dart created in ${blocPath}`);
+}
+function generateEvent(moduleName, eventPath) {
+    const eventFilePath = path.join(eventPath, `${moduleName}_event.dart`);
+    const className = getClassName(moduleName, "event");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}InitialEvent extends BaseEvent {}
+  `;
+    writeFile(eventFilePath, template);
+    LoggerHelpers.success(`Event file ${moduleName}_event.dart created in ${eventPath}`);
+}
+function generateState(moduleName, statePath) {
+    const stateFilePath = path.join(statePath, `${moduleName}_state.dart`);
+    const className = getClassName(moduleName, "state");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}InitialState extends RenderDataState {
+  ${className}InitialState() : super(null);
+}
+  `;
+    writeFile(stateFilePath, template);
+    LoggerHelpers.success(`State file ${moduleName}_state.dart created in ${statePath}`);
+}
+function generateScreen(moduleName, screenPath) {
+    const screenFilePath = path.join(screenPath, `${moduleName}_screen.dart`);
+    const className = getClassName(moduleName, "screen");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}Screen extends StatefulWidget {
+  final ${className}Bloc bloc;
+  const ${className}Screen({super.key, required this.bloc});
+
+  @override
+  _${className}ScreenState createState() => _${className}ScreenState(bloc);
+}
+
+class _${className}ScreenState extends BaseScreen<${className}Bloc, ${className}Screen, dynamic> {
+  _${className}ScreenState(super.bloc);
+
+  @override
+  Widget buildWidget(BuildContext context, RenderDataState state) {
+    return Container();
+  }
+  
+  @override
+  void listenToState(BuildContext context, BaseState state) {}
+}
+  `;
+    writeFile(screenFilePath, template);
+    LoggerHelpers.success(`Screen file ${moduleName}_screen.dart created in ${screenPath}`);
+}
+function generateImport(moduleName, importPath) {
+    const importFilePath = path.join(importPath, `${moduleName}_import.dart`);
+    const className = getClassName(moduleName, "import");
+    const template = `import 'package:flutter/material.dart';
+import 'package:opticore/opticore.dart';
+
+part '../bloc/${moduleName}_bloc.dart';
+part '../event/${moduleName}_event.dart';
+part '../screen/${moduleName}_screen.dart';
+part '../state/${moduleName}_state.dart';
+part '../factory/${moduleName}_factory.dart';
+  `;
+    writeFile(importFilePath, template);
+    LoggerHelpers.success(`Import file ${moduleName}_import.dart created in ${importPath}`);
+}
+function generateStateFactory(moduleName, factoryPath) {
+    const factoryFilePath = path.join(factoryPath, `${moduleName}_factory.dart`);
+    const className = getClassName(moduleName, "state_factory");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}Factory extends BaseFactory {
+  @override
+  BaseState getState<M>(M data) {
+    return DefaultState();
+  }
+}
+  `;
+    writeFile(factoryFilePath, template);
+    LoggerHelpers.success(`State Factory file ${moduleName}_factory.dart created in ${factoryPath}`);
+}

package/dist/commands/openProject.js

@@ -0,0 +1,46 @@
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { execCommand } from "../utils/execHelpers.js";
+import { platform } from "os";
+export { openIos, openAndroid };
+async function openIos() {
+    LoggerHelpers.info("Opening the iOS project in Xcode...");
+    const command = "open ios/Runner.xcworkspace";
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Xcode opened successfully.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error while opening Xcode: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error while opening Xcode: ${error}`);
+        }
+    }
+}
+async function openAndroid() {
+    LoggerHelpers.info("Opening the Android project in Android Studio...");
+    const osPlatform = platform();
+    let command;
+    if (osPlatform === "win32") {
+        command = "start android";
+    }
+    else if (osPlatform === "darwin") {
+        command = "open -a 'Android Studio' android";
+    }
+    else {
+        command = "xdg-open android";
+    }
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Android Studio opened successfully.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error while opening Android Studio: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error while opening Android Studio: ${error}`);
+        }
+    }
+}

package/dist/commands/updateVersions.js

@@ -0,0 +1,79 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+const currentDir = process.cwd();
+export { updateFlutterVersion };
+async function updateFlutterVersion(version, build, iosBuild) {
+    try {
+        // Always update the version since it is required.
+        LoggerHelpers.info(`Starting update for version ${version}...`);
+        // Update pubspec.yaml only if an Android build number is provided.
+        if (build.trim().length > 0) {
+            LoggerHelpers.info("Updating build number in pubspec.yaml...");
+            await updatePubspecVersionAndBuild(version, build);
+        }
+        else {
+            LoggerHelpers.info("Android build number not provided. Skipping pubspec.yaml update.");
+        }
+        // Update iOS settings only if an iOS build number is provided.
+        if (iosBuild.trim().length > 0) {
+            LoggerHelpers.info("Updating iOS version and build number...");
+            await updateIosVersionAndBuild(version, iosBuild);
+        }
+        else {
+            LoggerHelpers.info("iOS build number not provided. Skipping iOS update.");
+        }
+        LoggerHelpers.success(`Update complete. Version set to ${version}` +
+            (build.trim().length > 0 ? `, Android build set to ${build}` : "") +
+            (iosBuild.trim().length > 0 ? `, and iOS build set to ${iosBuild}` : ""));
+    }
+    catch (error) {
+        LoggerHelpers.error(`Error while updating Flutter version and build: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+async function updatePubspecVersionAndBuild(version, build) {
+    try {
+        const pubspecPath = path.join(currentDir, "pubspec.yaml");
+        if (!fs.existsSync(pubspecPath)) {
+            throw new Error(`pubspec.yaml not found at ${pubspecPath}`);
+        }
+        const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
+        const updatedPubspec = pubspecContent.replace(/version: \d+\.\d+\.\d+\+\d+/g, `version: ${version}+${build}`);
+        fs.writeFileSync(pubspecPath, updatedPubspec);
+        LoggerHelpers.success(`Updated pubspec.yaml with version ${version} and build ${build}`);
+    }
+    catch (error) {
+        LoggerHelpers.error(`Error while updating pubspec.yaml version and build: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+async function updateIosVersionAndBuild(version, iosBuild) {
+    try {
+        const currentDir = process.cwd();
+        const projectPbxProjPath = path.join(currentDir, "ios/Runner.xcodeproj/project.pbxproj");
+        if (!fs.existsSync(projectPbxProjPath)) {
+            throw new Error(`project.pbxproj not found at ${projectPbxProjPath}`);
+        }
+        let projectContent = fs.readFileSync(projectPbxProjPath, 'utf8');
+        projectContent = projectContent
+            .replace(/MARKETING_VERSION\s*=\s*[^;]+;/g, `MARKETING_VERSION = ${version};`)
+            .replace(/CURRENT_PROJECT_VERSION\s*=\s*[^;]+;/g, `CURRENT_PROJECT_VERSION = ${iosBuild};`);
+        fs.writeFileSync(projectPbxProjPath, projectContent);
+        LoggerHelpers.success(`Updated MARKETING_VERSION to ${version} and CURRENT_PROJECT_VERSION to ${iosBuild}`);
+        const infoPlistPath = path.join(currentDir, "ios/Runner/Info.plist");
+        if (!fs.existsSync(infoPlistPath)) {
+            throw new Error(`Info.plist not found at ${infoPlistPath}`);
+        }
+        const infoPlistContent = fs.readFileSync(infoPlistPath, "utf8");
+        const updatedPlist = infoPlistContent
+            .replace(/<key>CFBundleShortVersionString<\/key>\s*<string>\$\{MARKETING_VERSION\}<\/string>/, `<key>CFBundleShortVersionString</key><string>${version}</string>`)
+            .replace(/<key>CFBundleVersion<\/key>\s*<string>\$\{CURRENT_PROJECT_VERSION\}<\/string>/, `<key>CFBundleVersion</key><string>${iosBuild}</string>`);
+        fs.writeFileSync(infoPlistPath, updatedPlist);
+        LoggerHelpers.success("Updated Info.plist with the new version and iOS build.");
+    }
+    catch (error) {
+        LoggerHelpers.error(`Error while updating iOS version and build: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/styles.js

@@ -0,0 +1,7 @@
+export const boxenOptions = {
+    padding: 1,
+    margin: 1,
+    borderStyle: 'round', // Cast to the proper type
+    borderColor: 'blue',
+    backgroundColor: '#555555',
+};