From 51a2da6fb9af8c26f882630d5cfedb2ddd3de4f4 Mon Sep 17 00:00:00 2001 From: Daniel Imbert Date: Wed, 7 Jan 2026 00:10:46 -0600 Subject: [PATCH 01/20] Update ci.yml --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 71ac373..42eda2e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,7 +2,7 @@ name: CI on: push: - branches: [ main, develop ] + branches: [ coreV4, master ] pull_request: jobs: @@ -24,4 +24,4 @@ jobs: run: chmod +x gradlew - name: Assemble - run: ./gradlew assemble --no-daemon \ No newline at end of file + run: ./gradlew assemble --no-daemon From 23a2bc77ccaae9568ccafcd9b3c4647867d66ee8 Mon Sep 17 00:00:00 2001 From: Daniel Imbert Date: Wed, 7 Jan 2026 00:22:39 -0600 Subject: [PATCH 02/20] Update ci.yml --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 42eda2e..b16c5ab 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,4 +24,4 @@ jobs: run: chmod +x gradlew - name: Assemble - run: ./gradlew assemble --no-daemon + run: ./gradlew composeApp:compileKotlinJvm --no-daemon From 76d409e74cbf308cd8d0f433e9f9af7d7d9d3bab Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Wed, 7 Jan 2026 00:45:49 -0600 Subject: [PATCH 03/20] CI --- .github/workflows/ci.yml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..c5098c0 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,26 @@ +name: Android CI + +on: + push: + branches: [ "coreV4", "master" ] + pull_request: + branches: [ "coreV4", "master" ] + +jobs: + build: + runs-on: ubuntu-latest + + + steps: + - uses: actions/checkout@v3 + - name: set up JDK 11 + uses: actions/setup-java@v3 + with: + java-version: '11' + distribution: 'temurin' + cache: gradle + + - name: Setup Gradle + uses: gradle/gradle-build-action@v2 + - name: Build app + run: ./gradlew assemble \ No newline at end of file From f919dc72db0282e505c1b7d0902235387e9c23e0 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Wed, 7 Jan 2026 00:50:00 -0600 Subject: [PATCH 04/20] CI --- .github/workflows/ci.yml | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c5098c0..1f46a9d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,26 +1,34 @@ -name: Android CI +name: CI on: push: - branches: [ "coreV4", "master" ] + branches: + - main + - develop pull_request: - branches: [ "coreV4", "master" ] jobs: build: + name: Build & Compile runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - name: set up JDK 11 - uses: actions/setup-java@v3 + # 1️⃣ Checkout del repo + - name: Checkout repository + uses: actions/checkout@v4 + + # 2️⃣ Setup JDK (AGP 8.x → JDK 17) + - name: Set up JDK 17 + uses: actions/setup-java@v4 with: - java-version: '11' distribution: 'temurin' + java-version: '17' cache: gradle - - name: Setup Gradle - uses: gradle/gradle-build-action@v2 - - name: Build app - run: ./gradlew assemble \ No newline at end of file + # 3️⃣ Permisos para gradlew + - name: Grant execute permission for gradlew + run: chmod +x ./gradlew + + # 4️⃣ Build (falla si algo no compila) + - name: Build project + run: ./gradlew build --no-daemon \ No newline at end of file From afa38a02e2835df7c97aa494068188a13a250b79 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Wed, 7 Jan 2026 00:52:14 -0600 Subject: [PATCH 05/20] CI_new --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1f46a9d..c27b1b8 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,4 +1,4 @@ -name: CI +name: APPMakeup_CI on: push: From dd77013dab51d34a47b45a24a3f491a900dc489e Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Wed, 7 Jan 2026 00:54:49 -0600 Subject: [PATCH 06/20] CI_new --- .github/workflows/ci.yml | 22 ++++++++-------------- 1 file changed, 8 insertions(+), 14 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c27b1b8..d5d64ce 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,34 +1,28 @@ -name: APPMakeup_CI +name: AppMakeup_CI on: push: - branches: - - main - - develop + branches: [ main, develop ] pull_request: jobs: build: - name: Build & Compile runs-on: ubuntu-latest steps: - # 1️⃣ Checkout del repo - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@v3 - # 2️⃣ Setup JDK (AGP 8.x → JDK 17) - name: Set up JDK 17 - uses: actions/setup-java@v4 + uses: actions/setup-java@v3 with: distribution: 'temurin' java-version: '17' cache: gradle - # 3️⃣ Permisos para gradlew + # 🔑 ESTE PASO ES OBLIGATORIO - name: Grant execute permission for gradlew - run: chmod +x ./gradlew + run: chmod +x gradlew - # 4️⃣ Build (falla si algo no compila) - - name: Build project - run: ./gradlew build --no-daemon \ No newline at end of file + - name: Assemble project + run: ./gradlew assemble --no-daemon \ No newline at end of file From 4af106b637986f3210fd1277f92ac029e154ea5f Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Wed, 7 Jan 2026 00:57:58 -0600 Subject: [PATCH 07/20] CI_new --- .github/workflows/ci.yml | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d5d64ce..71ac373 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,4 +1,4 @@ -name: AppMakeup_CI +name: CI on: push: @@ -10,19 +10,18 @@ jobs: runs-on: ubuntu-latest steps: - - name: Checkout repository - uses: actions/checkout@v3 + - uses: actions/checkout@v3 - name: Set up JDK 17 uses: actions/setup-java@v3 with: - distribution: 'temurin' - java-version: '17' + distribution: temurin + java-version: 17 cache: gradle - # 🔑 ESTE PASO ES OBLIGATORIO - - name: Grant execute permission for gradlew + # 🔑 OBLIGATORIO Y ANTES DE TODO + - name: Make gradlew executable run: chmod +x gradlew - - name: Assemble project + - name: Assemble run: ./gradlew assemble --no-daemon \ No newline at end of file From 5cad5eda506be836a8c9402af58a5dce44315790 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Wed, 7 Jan 2026 01:12:03 -0600 Subject: [PATCH 08/20] CI_new --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 71ac373..52269f0 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,7 +2,7 @@ name: CI on: push: - branches: [ main, develop ] + branches: [ coreV4, master ] pull_request: jobs: @@ -24,4 +24,4 @@ jobs: run: chmod +x gradlew - name: Assemble - run: ./gradlew assemble --no-daemon \ No newline at end of file + run: ./gradlew composeApp:compileKotlinJvm --no-daemon \ No newline at end of file From 88c99c700b4d23557b576b0c90ad0ef11b5f0af6 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Wed, 7 Jan 2026 01:17:02 -0600 Subject: [PATCH 09/20] ci test --- .../src/commonMain/kotlin/com/elitec/appmakeup/Platform.kt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Platform.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Platform.kt index 3269f82..6749e96 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Platform.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Platform.kt @@ -4,4 +4,6 @@ interface Platform { val name: String } -expect fun getPlatform(): Platform \ No newline at end of file +expect fun getPlatform(): Platform + +// \ No newline at end of file From afefd3c123c09414c8ce74e56e4b706e0d1d3e03 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Thu, 8 Jan 2026 21:23:17 -0600 Subject: [PATCH 10/20] Architecture correction --- .../appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt | 2 +- .../com/elitec/appmakeup/exports/ProjectExporter.kt | 0 .../com/elitec/appmakeup/generation/ProjectCodeGenerator.kt | 0 .../elitec/appmakeup/projects/filesystem/DirectoryCreator.kt | 0 .../com/elitec/appmakeup/projects/filesystem/FileCopier.kt | 0 .../com/elitec/appmakeup/projects/filesystem/FileRenderer.kt | 0 .../elitec/appmakeup/projects/initializer/ProjectInitializer.kt | 0 .../appmakeup/projects/persistence/FileProjectPersistence.kt | 0 .../com/elitec/appmakeup/recent/FileRecentProjectsRepository.kt | 0 9 files changed, 1 insertion(+), 1 deletion(-) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt (91%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/exports/ProjectExporter.kt (100%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt (100%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/projects/filesystem/DirectoryCreator.kt (100%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/projects/filesystem/FileCopier.kt (100%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/projects/filesystem/FileRenderer.kt (100%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/projects/initializer/ProjectInitializer.kt (100%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt (100%) rename composeApp/src/jvmMain/{java => kotlin}/com/elitec/appmakeup/recent/FileRecentProjectsRepository.kt (100%) diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt similarity index 91% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt index 5b05639..4e224a9 100644 --- a/composeApp/src/jvmMain/java/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt @@ -4,7 +4,7 @@ import com.elitec.appmakeup.core.v4.contracts.GenerationResult import java.io.File class FileSystemWritingStage( - private val options: WritingOptions = WritingOptions() + private val options: WritingOptions = _root_ide_package_.com.elitec.appmakeup.core.v4.pipeline.WritingOptions() ) : WritingStage { override fun write( diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/exports/ProjectExporter.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/exports/ProjectExporter.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/filesystem/DirectoryCreator.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/filesystem/DirectoryCreator.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/filesystem/DirectoryCreator.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/filesystem/DirectoryCreator.kt diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/filesystem/FileCopier.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/filesystem/FileCopier.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/filesystem/FileCopier.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/filesystem/FileCopier.kt diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/filesystem/FileRenderer.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/filesystem/FileRenderer.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/filesystem/FileRenderer.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/filesystem/FileRenderer.kt diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/initializer/ProjectInitializer.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/initializer/ProjectInitializer.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/initializer/ProjectInitializer.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/initializer/ProjectInitializer.kt diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/recent/FileRecentProjectsRepository.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/recent/FileRecentProjectsRepository.kt similarity index 100% rename from composeApp/src/jvmMain/java/com/elitec/appmakeup/recent/FileRecentProjectsRepository.kt rename to composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/recent/FileRecentProjectsRepository.kt From 5804eb66939b24473427c6380fb8b88df793777d Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Thu, 22 Jan 2026 22:48:30 -0600 Subject: [PATCH 11/20] UI init --- .../kotlin/com/elitec/appmakeup/Test.kt | 27 +++ .../kotlin/com/elitec/appmakeup/main.kt | 82 +++++++++ .../navigation/MainNavigationWrapper.kt | 13 ++ .../presentation/navigation/MainScreens.kt | 11 ++ .../states/ProjectEditorUiState.kt | 14 ++ .../viewmodels/ProjectEditorViewModel.kt | 163 ++++++++++++++++++ 6 files changed, 310 insertions(+) create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Test.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Test.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Test.kt new file mode 100644 index 0000000..fc4d204 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/Test.kt @@ -0,0 +1,27 @@ +package com.elitec.appmakeup + +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.size +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import appmakeup.composeapp.generated.resources.Res +import appmakeup.composeapp.generated.resources.compose_multiplatform +import org.jetbrains.compose.resources.painterResource + +@Composable +fun test() { + Box( + contentAlignment = Alignment.Center, + modifier = Modifier.fillMaxSize() + ) { + Image( + painter = painterResource(Res.drawable.compose_multiplatform), + modifier = Modifier.size(400.dp), + contentDescription = "" + ) + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt index 1aea421..f0cd34f 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt @@ -1,14 +1,35 @@ package com.elitec.appmakeup +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.filled.Maximize +import androidx.compose.material.icons.filled.Minimize +import androidx.compose.material3.Button +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.Surface import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp import androidx.compose.ui.window.Window import androidx.compose.ui.window.WindowPlacement import androidx.compose.ui.window.WindowPosition import androidx.compose.ui.window.WindowState import androidx.compose.ui.window.application import appmakeup.composeapp.generated.resources.Res +import appmakeup.composeapp.generated.resources.sinfotow import appmakeup.composeapp.generated.resources.toolicon import org.jetbrains.compose.resources.painterResource import org.koin.core.context.startKoin @@ -28,6 +49,67 @@ fun main() = application { onCloseRequest = ::exitApplication, title = "AppMakeup", ) { + Scaffold( + topBar = { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.End, + modifier = Modifier.fillMaxWidth() + ) { + Surface( + shape = RoundedCornerShape(5.dp), + color = MaterialTheme.colorScheme.onBackground, + onClick = { + windowState.isMinimized = true + } + ) { + Icon( + imageVector = Icons.Default.Minimize, + contentDescription = "", + tint = MaterialTheme.colorScheme.background, + modifier = Modifier.size(20.dp) + ) + } + Spacer(modifier = Modifier.width(8.dp)) + Surface( + shape = RoundedCornerShape(5.dp), + color = MaterialTheme.colorScheme.onBackground, + onClick = { + if(windowState.placement == WindowPlacement.Maximized) { + windowState.placement = WindowPlacement.Floating + return@Surface + } + windowState.placement = WindowPlacement.Maximized + } + ) { + Icon( + imageVector = Icons.Default.Maximize, + contentDescription = "", + tint = MaterialTheme.colorScheme.background, + modifier = Modifier.size(20.dp) + ) + } + Spacer(modifier = Modifier.width(8.dp)) + Surface( + shape = RoundedCornerShape(5.dp), + color = MaterialTheme.colorScheme.onBackground, + onClick = { + exitApplication() + } + ) { + Icon( + imageVector = Icons.Default.Close, + contentDescription = "", + tint = MaterialTheme.colorScheme.background, + modifier = Modifier.size(20.dp) + ) + } + } + }, + bottomBar = {} + ) { + + } } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt new file mode 100644 index 0000000..47598b6 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt @@ -0,0 +1,13 @@ +package com.elitec.appmakeup.presentation.navigation + +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.navigation.compose.rememberNavController + +@Composable +fun MainNavigationWrapper( + modifier: Modifier = Modifier +) { + val navController = rememberNavController() + +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt new file mode 100644 index 0000000..4c81415 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt @@ -0,0 +1,11 @@ +package com.elitec.appmakeup.presentation.navigation + +import kotlinx.serialization.Serializable + +@Serializable +sealed interface MainScreens { + sealed interface Splash: MainScreens + sealed interface CreateProject: MainScreens + sealed interface ProjectEditor: MainScreens + sealed interface Export: MainScreens +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt new file mode 100644 index 0000000..1727491 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt @@ -0,0 +1,14 @@ +package com.elitec.appmakeup.presentation.states + +import com.elitec.appmakeup.projects.model.AppFeature +import com.elitec.appmakeup.projects.model.AppMakeupProject +import com.elitec.appmakeup.projects.model.AppProperty + +data class ProjectEditorUiState( + val project: AppMakeupProject? = null, + val features: List = emptyList(), + val selectedFeature: AppFeature? = null, + val properties: List = emptyList(), + val isLoading: Boolean = false, + val error: String? = null +) \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt new file mode 100644 index 0000000..5e024a5 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt @@ -0,0 +1,163 @@ +package com.elitec.appmakeup.presentation.viewmodels + +import androidx.lifecycle.ViewModel +import com.elitec.appmakeup.generation.GenerateCodeUseCase +import com.elitec.appmakeup.presentation.states.ProjectEditorUiState +import com.elitec.appmakeup.projects.model.AppFeature +import com.elitec.appmakeup.projects.model.AppMakeupProject +import com.elitec.appmakeup.projects.model.AppProperty +import com.elitec.appmakeup.projects.usecase.feature.AddFeatureUseCase +import com.elitec.appmakeup.projects.usecase.feature.GetFeatureUseCase +import com.elitec.appmakeup.projects.usecase.feature.ListFeaturesUseCase +import com.elitec.appmakeup.projects.usecase.feature.RemoveFeatureUseCase +import com.elitec.appmakeup.projects.usecase.project.LoadProjectUseCase +import com.elitec.appmakeup.projects.usecase.property.AddPropertyUseCase +import com.elitec.appmakeup.projects.usecase.property.ListPropertiesUseCase +import com.elitec.appmakeup.projects.usecase.property.RemovePropertyUseCase +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.update + +class ProjectEditorViewModel( + private val loadProjectUseCase: LoadProjectUseCase, + private val listFeaturesUseCase: ListFeaturesUseCase, + private val getFeatureUseCase: GetFeatureUseCase, + private val listPropertiesUseCase: ListPropertiesUseCase, + private val addFeatureUseCase: AddFeatureUseCase, + private val removeFeatureUseCase: RemoveFeatureUseCase, + private val addPropertyUseCase: AddPropertyUseCase, + private val removePropertyUseCase: RemovePropertyUseCase, + private val generateCodeUseCase: GenerateCodeUseCase +): ViewModel() { + private val _uiState = MutableStateFlow(ProjectEditorUiState(isLoading = true)) + + val uiState: StateFlow = _uiState + + /* --------------------------- + * Project lifecycle + * --------------------------- */ + + fun loadProject(path: String) { + try { + val project = loadProjectUseCase.execute(path) + refreshProject(project) + } catch (e: Exception) { + _uiState.update { + it.copy(isLoading = false, error = e.message) + } + } + } + + /* --------------------------- + * Feature management + * --------------------------- */ + + fun addFeature(name: String) { + val project = currentProject() ?: return + + val updated = addFeatureUseCase.execute( + project, + AppFeature(name = name, properties = emptyList()) + ) + + refreshProject(updated) + } + + fun removeFeature(name: String) { + val project = currentProject() ?: return + + val updated = removeFeatureUseCase.execute(project, name) + refreshProject(updated) + } + + fun selectFeature(name: String) { + val project = currentProject() ?: return + + val feature = getFeatureUseCase.execute(project, name) + val properties = feature?.let { + listPropertiesUseCase.execute(project, it.name) + }.orEmpty() + + _uiState.update { + it.copy( + selectedFeature = feature, + properties = properties + ) + } + } + + /* --------------------------- + * Property management + * --------------------------- */ + + fun addProperty( + featureName: String, + propertyName: String, + type: String, + isIdentifier: Boolean = false + ) { + val project = currentProject() ?: return + + val updated = addPropertyUseCase.execute( + project, + featureName, + AppProperty( + name = propertyName, + type = type, + isIdentifier = isIdentifier + ) + ) + + refreshProject(updated) + } + + fun removeProperty(featureName: String, propertyName: String) { + val project = currentProject() ?: return + + val updated = removePropertyUseCase.execute( + project, + featureName, + propertyName + ) + + refreshProject(updated) + } + + /* --------------------------- + * Code generation + * --------------------------- */ + + fun generateCode() { + val project = currentProject() ?: return + + try { + generateCodeUseCase.execute(project) + } catch (e: Exception) { + _uiState.update { + it.copy(error = e.message) + } + } + } + + /* --------------------------- + * Helpers + * --------------------------- */ + + private fun refreshProject(project: AppMakeupProject) { + val features = listFeaturesUseCase.execute(project) + + _uiState.update { + it.copy( + project = project, + features = features, + selectedFeature = null, + properties = emptyList(), + isLoading = false, + error = null + ) + } + } + + private fun currentProject(): AppMakeupProject? = + _uiState.value.project +} \ No newline at end of file From 6d1e513b18cb39fdcce9ba8ddb4ba312579a156e Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Thu, 22 Jan 2026 23:54:16 -0600 Subject: [PATCH 12/20] UI init --- .../projects/model/AppMakeupProject.kt | 6 +- .../navigation/MainNavigationWrapper.kt | 52 ++++++++ .../presentation/navigation/MainScreens.kt | 9 +- .../screens/CreateProjectScreen.kt | 64 ++++++++++ .../presentation/screens/ExportScreen.kt | 68 +++++++++++ .../presentation/screens/HomeScreen.kt | 70 +++++++++++ .../screens/ProjectEditorScreen.kt | 115 ++++++++++++++++++ .../presentation/screens/SplashScreen.kt | 37 ++++++ .../states/CreateProjectUiState.kt | 9 ++ .../presentation/states/HomeUiState.kt | 6 + .../viewmodels/CreateProjectViewModel.kt | 52 ++++++++ .../presentation/viewmodels/HomeViewModel.kt | 25 ++++ 12 files changed, 507 insertions(+), 6 deletions(-) create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppMakeupProject.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppMakeupProject.kt index 0906e0f..e0675d7 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppMakeupProject.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppMakeupProject.kt @@ -7,6 +7,8 @@ data class AppMakeupProject( val name: String, val packageName: String, val path: String, - val features: List, + val features: List +) { val exportPath: String -) \ No newline at end of file + get() = "$path/export" +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt index 47598b6..4925141 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt @@ -1,8 +1,16 @@ package com.elitec.appmakeup.presentation.navigation +import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.runtime.Composable import androidx.compose.ui.Modifier +import androidx.navigation.compose.NavHost +import androidx.navigation.compose.composable import androidx.navigation.compose.rememberNavController +import androidx.navigation.toRoute +import com.elitec.appmakeup.presentation.screens.CreateProjectScreen +import com.elitec.appmakeup.presentation.screens.HomeScreen +import com.elitec.appmakeup.presentation.screens.ProjectEditorScreen +import com.elitec.appmakeup.presentation.screens.SplashScreen @Composable fun MainNavigationWrapper( @@ -10,4 +18,48 @@ fun MainNavigationWrapper( ) { val navController = rememberNavController() + NavHost( + navController = navController, + startDestination = MainScreens.Splash, + modifier = modifier.fillMaxSize() + ) { + composable { + SplashScreen( + navigateTo = { destination -> + navController.navigate(MainScreens.Home) { + popUpTo(MainScreens.Splash) { inclusive = true } + } + } + ) + } + composable { + CreateProjectScreen( + onProjectCreate = { path -> + navController.navigate(MainScreens.ProjectEditor(path)) { + popUpTo(MainScreens.CreateProject) { inclusive = true } + } + } + ) + } + composable { + HomeScreen( + onProjectCreate = { + navController.navigate(MainScreens.CreateProject) + }, + onOpenProject = { path -> + navController.navigate(MainScreens.ProjectEditor(path)) + } + ) + } + composable { backStackEntry -> + val path = backStackEntry.toRoute().path + + ProjectEditorScreen( + projectPath = path, + onExport = { + navController.navigate(MainScreens.Export(path)) + } + ) + } + } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt index 4c81415..1543bf1 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt @@ -4,8 +4,9 @@ import kotlinx.serialization.Serializable @Serializable sealed interface MainScreens { - sealed interface Splash: MainScreens - sealed interface CreateProject: MainScreens - sealed interface ProjectEditor: MainScreens - sealed interface Export: MainScreens + @Serializable object Splash: MainScreens + @Serializable object CreateProject: MainScreens + @Serializable object Home: MainScreens + @Serializable data class ProjectEditor(val path: String): MainScreens + @Serializable data class Export(val path: String): MainScreens } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt new file mode 100644 index 0000000..178e361 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt @@ -0,0 +1,64 @@ +package com.elitec.appmakeup.presentation.screens + +import androidx.compose.foundation.layout.* +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.elitec.appmakeup.presentation.viewmodels.CreateProjectViewModel +import org.koin.compose.viewmodel.koinViewModel + +@Composable +fun CreateProjectScreen( + onProjectCreate: (String) -> Unit, + modifier: Modifier = Modifier, + viewModel: CreateProjectViewModel = koinViewModel() +) { + val state by viewModel.uiState.collectAsStateWithLifecycle() + + if (state.isCreated) { + onProjectCreate(state.path) + } + + Column( + modifier = modifier + .fillMaxSize() + .padding(24.dp), + verticalArrangement = Arrangement.spacedBy(12.dp) + ) { + Text("Crear nuevo proyecto", style = MaterialTheme.typography.headlineSmall) + + OutlinedTextField( + value = state.name, + onValueChange = viewModel::onNameChange, + label = { Text("Nombre del proyecto") }, + modifier = Modifier.fillMaxWidth() + ) + + OutlinedTextField( + value = state.packageName, + onValueChange = viewModel::onPackageChange, + label = { Text("Package base") }, + modifier = Modifier.fillMaxWidth() + ) + + OutlinedTextField( + value = state.path, + onValueChange = viewModel::onPathChange, + label = { Text("Ruta del proyecto") }, + modifier = Modifier.fillMaxWidth() + ) + + state.error?.let { + Text(it, color = MaterialTheme.colorScheme.error) + } + + Button( + onClick = viewModel::createProject, + modifier = Modifier.fillMaxWidth() + ) { + Text("Crear proyecto") + } + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt new file mode 100644 index 0000000..b30d6b3 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt @@ -0,0 +1,68 @@ +package com.elitec.appmakeup.presentation.screens + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Button +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp + +@Composable +fun ExportScreen( + projectPath: String, + onDone: () -> Unit +) { + var isGenerating by remember { mutableStateOf(true) } + var error by remember { mutableStateOf(null) } + + LaunchedEffect(null) { + try { + // aquí llamas a GenerateCodeUseCase vía ViewModel + // exportViewModel.generate(projectPath) + isGenerating = false + } catch (e: Exception) { + error = e.message + isGenerating = false + } + } + + Column( + modifier = Modifier + .fillMaxSize() + .padding(24.dp), + verticalArrangement = Arrangement.Center + ) { + when { + isGenerating -> { + CircularProgressIndicator() + Spacer(Modifier.height(16.dp)) + Text("Generando código…") + } + error != null -> { + Text(error!!, color = MaterialTheme.colorScheme.error) + Button(onClick = onDone) { + Text("Volver") + } + } + else -> { + Text("Código generado correctamente 🎉") + Spacer(Modifier.height(16.dp)) + Button(onClick = onDone) { + Text("Volver al editor") + } + } + } + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt new file mode 100644 index 0000000..165eb2c --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt @@ -0,0 +1,70 @@ +package com.elitec.appmakeup.presentation.screens + +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.material.Divider +import androidx.compose.material3.Button +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.elitec.appmakeup.presentation.viewmodels.HomeViewModel +import org.koin.compose.viewmodel.koinViewModel + +@Suppress("EffectKeys") +@Composable +fun HomeScreen( + onProjectCreate: () -> Unit, + onOpenProject: (String) -> Unit, + modifier: Modifier = Modifier, + viewModel: HomeViewModel = koinViewModel() +) { + val state by viewModel.uiState.collectAsStateWithLifecycle() + + LaunchedEffect(Unit) { + viewModel.loadRecentProjects() + } + + Column( + modifier = modifier + .fillMaxSize() + .padding(24.dp), + verticalArrangement = Arrangement.spacedBy(16.dp) + ) { + Text("AppMakeup", style = MaterialTheme.typography.headlineMedium) + + Button(onClick = onProjectCreate) { + Text("Nuevo proyecto") + } + + Divider() + + Text("Proyectos recientes", style = MaterialTheme.typography.titleMedium) + + if (state.recentProjects.isEmpty()) { + Text("No hay proyectos recientes") + } else { + state.recentProjects.forEach { path -> + Text( + text = path, + modifier = Modifier + .fillMaxWidth() + .clickable { onOpenProject(path) } + .padding(8.dp) + ) + } + } + + state.error?.let { + Text(it, color = MaterialTheme.colorScheme.error) + } + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt new file mode 100644 index 0000000..22379d9 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt @@ -0,0 +1,115 @@ +package com.elitec.appmakeup.presentation.screens + +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Button +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.elitec.appmakeup.presentation.viewmodels.ProjectEditorViewModel +import org.koin.compose.viewmodel.koinViewModel + +@Composable +fun ProjectEditorScreen( + projectPath: String, + onExport: () -> Unit, + modifier: Modifier = Modifier, + viewModel: ProjectEditorViewModel = koinViewModel() +) { + val state by viewModel.uiState.collectAsStateWithLifecycle() + + Column( + modifier = modifier + .fillMaxSize() + .padding(24.dp), + horizontalAlignment = Alignment.Start + ) { + + Text( + text = state.project?.name ?: "Proyecto", + style = MaterialTheme.typography.headlineSmall + ) + + Spacer(Modifier.height(16.dp)) + + Row( + modifier = Modifier.fillMaxSize(), + horizontalArrangement = Arrangement.spacedBy(16.dp) + ) { + + // Features + Column(modifier = Modifier.weight(1f)) { + Text("Features", style = MaterialTheme.typography.titleMedium) + + state.features.forEach { + Text( + text = it.name, + modifier = Modifier + .fillMaxWidth() + .clickable { viewModel.selectFeature(it.name) } + .padding(8.dp) + ) + } + + Button( + onClick = { viewModel.addFeature("NewFeature") }, + modifier = Modifier.padding(top = 8.dp) + ) { + Text("Agregar feature") + } + } + + // Properties + Column(modifier = Modifier.weight(1f)) { + Text("Propiedades", style = MaterialTheme.typography.titleMedium) + + state.properties.forEach { + Text( + text = "${it.name}: ${it.type}", + modifier = Modifier.padding(8.dp) + ) + } + + state.selectedFeature?.let { + Button( + onClick = { + viewModel.addProperty( + featureName = it.name, + propertyName = "newProperty", + type = "String" + ) + } + ) { + Text("Agregar propiedad") + } + } + } + } + + Spacer(Modifier.height(16.dp)) + + Button( + onClick = viewModel::generateCode, + modifier = Modifier.fillMaxWidth() + ) { + Text("Generar código") + } + + state.error?.let { + Text(it, color = MaterialTheme.colorScheme.error) + } + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt new file mode 100644 index 0000000..250538f --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt @@ -0,0 +1,37 @@ +package com.elitec.appmakeup.presentation.screens + +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.size +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import appmakeup.composeapp.generated.resources.Res +import appmakeup.composeapp.generated.resources.sinfotow +import com.elitec.appmakeup.presentation.navigation.MainScreens +import kotlinx.coroutines.delay +import org.jetbrains.compose.resources.painterResource + +@Composable +fun SplashScreen( + navigateTo: (MainScreens) -> Unit, + modifier: Modifier = Modifier +) { + LaunchedEffect(null) { + delay(1000) + navigateTo(MainScreens.Home) + } + Box( + contentAlignment = Alignment.Center, + modifier = modifier.fillMaxSize() + ) { + Image( + painter = painterResource(Res.drawable.sinfotow), + contentDescription = "", + modifier = Modifier.size(200.dp) + ) + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt new file mode 100644 index 0000000..25c4c06 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt @@ -0,0 +1,9 @@ +package com.elitec.appmakeup.presentation.states + +data class CreateProjectUiState( + val name: String = "", + val packageName: String = "", + val path: String = "", + val error: String? = null, + val isCreated: Boolean = false +) \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt new file mode 100644 index 0000000..816f65c --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt @@ -0,0 +1,6 @@ +package com.elitec.appmakeup.presentation.states + +data class HomeUiState( + val recentProjects: List = emptyList(), + val error: String? = null +) \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt new file mode 100644 index 0000000..a075364 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt @@ -0,0 +1,52 @@ +package com.elitec.appmakeup.presentation.viewmodels + +import androidx.lifecycle.ViewModel +import com.elitec.appmakeup.presentation.states.CreateProjectUiState +import com.elitec.appmakeup.projects.model.AppMakeupProject +import com.elitec.appmakeup.projects.usecase.project.CreateProjectUseCase +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.update + +class CreateProjectViewModel( + private val createProjectUseCase: CreateProjectUseCase +): ViewModel() { + private val _uiState = MutableStateFlow(CreateProjectUiState()) + val uiState: StateFlow = _uiState + + fun onNameChange(value: String) = + _uiState.update { it.copy(name = value) } + + fun onPackageChange(value: String) = + _uiState.update { it.copy(packageName = value) } + + fun onPathChange(value: String) = + _uiState.update { it.copy(path = value) } + + fun createProject() { + val state = _uiState.value + + if (state.name.isBlank() || + state.packageName.isBlank() || + state.path.isBlank() + ) { + _uiState.update { + it.copy(error = "Todos los campos son obligatorios") + } + return + } + + val project = AppMakeupProject( + name = state.name, + packageName = state.packageName, + path = state.path, + features = emptyList() + ) + + createProjectUseCase.execute(project) + + _uiState.update { + it.copy(isCreated = true, error = null) + } + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt new file mode 100644 index 0000000..9428a06 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt @@ -0,0 +1,25 @@ +package com.elitec.appmakeup.presentation.viewmodels + +import androidx.lifecycle.ViewModel +import com.elitec.appmakeup.presentation.states.HomeUiState +import com.elitec.appmakeup.projects.usecase.project.ListRecentProjectsUseCase +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.update + +class HomeViewModel( + private val listRecentProjectsUseCase: ListRecentProjectsUseCase +): ViewModel() { + + private val _uiState = MutableStateFlow(HomeUiState()) + val uiState: StateFlow = _uiState + + fun loadRecentProjects() { + try { + val recent = listRecentProjectsUseCase.execute() + _uiState.update { it.copy(recentProjects = recent) } + } catch (e: Exception) { + _uiState.update { it.copy(error = e.message) } + } + } +} \ No newline at end of file From 0c0d9a38cecec9a6594bf9a6bf990730e96cfc69 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Fri, 23 Jan 2026 00:07:36 -0600 Subject: [PATCH 13/20] di and routes --- .../elitec/appmakeup/di/applicationModule.kt | 40 +++++++++++++++++++ .../elitec/appmakeup/di/presentationModule.kt | 34 ++++++++++++++++ .../navigation/MainNavigationWrapper.kt | 0 .../presentation/navigation/MainScreens.kt | 0 .../screens/CreateProjectScreen.kt | 0 .../presentation/screens/ExportScreen.kt | 0 .../presentation/screens/HomeScreen.kt | 2 +- .../screens/ProjectEditorScreen.kt | 1 - .../presentation/screens/SplashScreen.kt | 4 +- .../states/CreateProjectUiState.kt | 0 .../presentation/states/HomeUiState.kt | 0 .../states/ProjectEditorUiState.kt | 0 .../viewmodels/CreateProjectViewModel.kt | 0 .../presentation/viewmodels/HomeViewModel.kt | 0 .../viewmodels/ProjectEditorViewModel.kt | 0 .../appmakeup/di/infrastructureModule.kt | 32 +++++++++++++++ .../com/elitec/appmakeup/di/initKoin.kt | 13 ++++++ .../kotlin/com/elitec/appmakeup/main.kt | 14 +++++-- 18 files changed, 133 insertions(+), 7 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt (98%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt (98%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt (89%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt (100%) rename composeApp/src/{jvmMain => commonMain}/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt (100%) create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt new file mode 100644 index 0000000..4656823 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt @@ -0,0 +1,40 @@ +package com.elitec.appmakeup.di + +import com.elitec.appmakeup.generation.GenerateCodeUseCase +import com.elitec.appmakeup.projects.usecase.feature.AddFeatureUseCase +import com.elitec.appmakeup.projects.usecase.feature.GetFeatureUseCase +import com.elitec.appmakeup.projects.usecase.feature.ListFeaturesUseCase +import com.elitec.appmakeup.projects.usecase.feature.RemoveFeatureUseCase +import com.elitec.appmakeup.projects.usecase.project.CreateProjectUseCase +import com.elitec.appmakeup.projects.usecase.project.ListRecentProjectsUseCase +import com.elitec.appmakeup.projects.usecase.project.LoadProjectUseCase +import com.elitec.appmakeup.projects.usecase.project.SaveProjectUseCase +import com.elitec.appmakeup.projects.usecase.property.AddPropertyUseCase +import com.elitec.appmakeup.projects.usecase.property.ListPropertiesUseCase +import com.elitec.appmakeup.projects.usecase.property.RemovePropertyUseCase +import org.koin.dsl.module + +val applicationModule = module { + + // Project lifecycle + factory { CreateProjectUseCase(get(), get()) } + factory { LoadProjectUseCase(get(), get()) } + factory { SaveProjectUseCase(get()) } + + // Features + factory { ListFeaturesUseCase() } + factory { GetFeatureUseCase() } + factory { AddFeatureUseCase(get()) } + factory { RemoveFeatureUseCase(get()) } + + // Properties + factory { ListPropertiesUseCase() } + factory { AddPropertyUseCase(get()) } + factory { RemovePropertyUseCase(get()) } + + // Recents + factory { ListRecentProjectsUseCase(get()) } + + // Generation + factory { GenerateCodeUseCase(get()) } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt new file mode 100644 index 0000000..5e45bd3 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt @@ -0,0 +1,34 @@ +package com.elitec.appmakeup.di + +import com.elitec.appmakeup.presentation.viewmodels.CreateProjectViewModel +import com.elitec.appmakeup.presentation.viewmodels.HomeViewModel +import com.elitec.appmakeup.presentation.viewmodels.ProjectEditorViewModel +import org.koin.core.module.dsl.viewModel +import org.koin.dsl.module + +val presentationModule = module { + viewModel { + HomeViewModel( + listRecentProjectsUseCase = get() + ) + } + viewModel { + CreateProjectViewModel( + createProjectUseCase = get() + ) + } + + viewModel { + ProjectEditorViewModel( + loadProjectUseCase = get(), + listFeaturesUseCase = get(), + getFeatureUseCase = get(), + listPropertiesUseCase = get(), + addFeatureUseCase = get(), + removeFeatureUseCase = get(), + addPropertyUseCase = get(), + removePropertyUseCase = get(), + generateCodeUseCase = get() + ) + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainScreens.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt similarity index 98% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt index 165eb2c..bfd0d4e 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt @@ -6,8 +6,8 @@ import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding -import androidx.compose.material.Divider import androidx.compose.material3.Button +import androidx.compose.material3.Divider import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt similarity index 98% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt index 22379d9..2177686 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt @@ -13,7 +13,6 @@ import androidx.compose.material3.Button import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable -import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt similarity index 89% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt index 250538f..8e932d0 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt @@ -10,7 +10,7 @@ import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.unit.dp import appmakeup.composeapp.generated.resources.Res -import appmakeup.composeapp.generated.resources.sinfotow +import appmakeup.composeapp.generated.resources.sinfoto import com.elitec.appmakeup.presentation.navigation.MainScreens import kotlinx.coroutines.delay import org.jetbrains.compose.resources.painterResource @@ -29,7 +29,7 @@ fun SplashScreen( modifier = modifier.fillMaxSize() ) { Image( - painter = painterResource(Res.drawable.sinfotow), + painter = painterResource(Res.drawable.sinfoto), contentDescription = "", modifier = Modifier.size(200.dp) ) diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/HomeUiState.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/CreateProjectViewModel.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/HomeViewModel.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt similarity index 100% rename from composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt new file mode 100644 index 0000000..34e1712 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt @@ -0,0 +1,32 @@ +package com.elitec.appmakeup.di + +import com.elitec.appmakeup.exports.ProjectExporter +import com.elitec.appmakeup.generation.CodeGenerator +import com.elitec.appmakeup.generation.ProjectCodeGenerator +import com.elitec.appmakeup.projects.persistence.FileProjectPersistence +import com.elitec.appmakeup.projects.persistence.ProjectPersistence +import com.elitec.appmakeup.recent.FileRecentProjectsRepository +import com.elitec.appmakeup.recent.RecentProjectsRepository +import org.koin.dsl.module + +val infrastructureModule = module { + + // Persistencia de proyecto + single { + FileProjectPersistence() + } + + // Recientes + single { + FileRecentProjectsRepository() + } + + // Export / generación + single { + ProjectExporter(get()) + } + + single { + ProjectCodeGenerator(get()) + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt new file mode 100644 index 0000000..522a3f5 --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt @@ -0,0 +1,13 @@ +package com.elitec.appmakeup.di + +import org.koin.core.context.GlobalContext.startKoin + +fun initKoin() { + startKoin { + modules( + infrastructureModule, + applicationModule, + presentationModule + ) + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt index f0cd34f..944395c 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt @@ -7,6 +7,7 @@ import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.width import androidx.compose.foundation.shape.RoundedCornerShape @@ -19,6 +20,7 @@ import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Scaffold import androidx.compose.material3.Surface +import androidx.compose.runtime.LaunchedEffect import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color @@ -31,6 +33,8 @@ import androidx.compose.ui.window.application import appmakeup.composeapp.generated.resources.Res import appmakeup.composeapp.generated.resources.sinfotow import appmakeup.composeapp.generated.resources.toolicon +import com.elitec.appmakeup.di.initKoin +import com.elitec.appmakeup.presentation.navigation.MainNavigationWrapper import org.jetbrains.compose.resources.painterResource import org.koin.core.context.startKoin @@ -39,8 +43,10 @@ fun main() = application { position = WindowPosition(alignment = Alignment.Center), placement = WindowPlacement.Floating ) - startKoin { + LaunchedEffect(null) { + initKoin() } + Window( resizable = false, undecorated = true, @@ -108,8 +114,10 @@ fun main() = application { } }, bottomBar = {} - ) { - + ) { innerPaddings -> + MainNavigationWrapper( + modifier = Modifier.fillMaxSize().padding(innerPaddings) + ) } } } \ No newline at end of file From d0248a25111a080191be23d55be07ddebc9c849c Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Fri, 23 Jan 2026 10:08:32 -0600 Subject: [PATCH 14/20] di modules definitions --- .../v4/generators/CompositeLayerGenerator.kt | 15 ++ .../v4/validation/ArchitectureValidator.kt | 46 +++--- .../v4/validation/DefaultValidationStage.kt | 30 ++++ .../screens/CreateProjectScreen.kt | 12 +- .../presentation/util/pickDirectory.kt | 3 + .../presentation/util/pickDirectory.jvm.kt | 10 ++ .../com/elitec/appmakeup/di/coreV4Module.kt | 134 ++++++++++++++++++ .../com/elitec/appmakeup/di/initKoin.kt | 2 + .../elitec/appmakeup/di/validationModule.kt | 22 +++ 9 files changed, 246 insertions(+), 28 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/generators/CompositeLayerGenerator.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/DefaultValidationStage.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/util/pickDirectory.kt create mode 100644 composeApp/src/jvmMain/java/com/elitec/appmakeup/presentation/util/pickDirectory.jvm.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt create mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/generators/CompositeLayerGenerator.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/generators/CompositeLayerGenerator.kt new file mode 100644 index 0000000..267ac03 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/generators/CompositeLayerGenerator.kt @@ -0,0 +1,15 @@ +package com.elitec.appmakeup.core.v4.generators + +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.pipeline.GeneratedArtifact +import com.elitec.appmakeup.core.v4.pipeline.LayerGenerator + +class CompositeLayerGenerator( + private val generators: List +) : LayerGenerator { + + override fun generate( + context: GenerationContext + ): List = + generators.flatMap { it.generate(context) } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt index 65a2c46..1bf6327 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt @@ -1,45 +1,37 @@ package com.elitec.appmakeup.core.v4.validation import com.elitec.appmakeup.core.v4.definition.CoreArchitecture +import com.elitec.appmakeup.core.v4.definition.CoreFeature import com.elitec.appmakeup.core.v4.definition.CoreLayer -class ArchitectureValidator : Validator { +class ArchitectureValidator : Validator> { - override fun validate(target: CoreArchitecture): ValidationResult { + override fun validate( + target: Pair + ): ValidationResult { - if (target.supportedLayers.isEmpty()) { - return ValidationResult.Invalid("Architecture must support at least one layer") - } - - target.dependencyRules.forEach { (from, dependencies) -> - - if (!target.supportedLayers.contains(from)) { - return ValidationResult.Invalid( - "Dependency rule defined for unsupported layer: $from" - ) - } + val (architecture, feature) = target - dependencies.forEach { to -> - if (!target.supportedLayers.contains(to)) { - return ValidationResult.Invalid( - "Layer $from depends on unsupported layer $to" - ) - } + // 1️⃣ Layers soportadas + val unsupported = feature.layers - architecture.supportedLayers + if (unsupported.isNotEmpty()) { + return ValidationResult.Invalid( + "Feature '${feature.name}' uses unsupported layers: $unsupported" + ) + } - if (from == to) { + // 2️⃣ Reglas de dependencia + architecture.dependencyRules.forEach { (layer, allowedDeps) -> + if (feature.layers.contains(layer)) { + val invalidDeps = feature.layers - allowedDeps - layer + if (invalidDeps.isNotEmpty()) { return ValidationResult.Invalid( - "Layer $from cannot depend on itself" + "Layer $layer cannot depend on $invalidDeps" ) } } } - if (target.canDependOn(CoreLayer.DOMAIN, CoreLayer.DATA)) { - return ValidationResult.Invalid( - "DOMAIN layer cannot depend on DATA layer" - ) - } - return ValidationResult.Valid } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/DefaultValidationStage.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/DefaultValidationStage.kt new file mode 100644 index 0000000..bb35889 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/DefaultValidationStage.kt @@ -0,0 +1,30 @@ +package com.elitec.appmakeup.core.v4.validation + +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.pipeline.ValidationStage + +class DefaultValidationStage( + private val featureValidator: FeatureValidator, + private val architectureValidator: ArchitectureValidator +) : ValidationStage { + + override fun validate(context: GenerationContext): ValidationResult { + + // 1️⃣ Validar feature (incluye entidades) + val featureResult = featureValidator.validate(context.feature) + if (!featureResult.isValid()) return featureResult + + // 2️⃣ Validar arquitectura vs feature + val archResult = architectureValidator.validate( + context.architecture to context.feature + ) + if (!archResult.isValid()) return archResult + + // 3️⃣ Output path básico + if (context.outputPath.isBlank()) { + return ValidationResult.Invalid("Output path cannot be blank") + } + + return ValidationResult.Valid + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt index 178e361..967d0e3 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt @@ -6,6 +6,7 @@ import androidx.compose.runtime.* import androidx.compose.ui.Modifier import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.elitec.appmakeup.presentation.util.pickDirectory import com.elitec.appmakeup.presentation.viewmodels.CreateProjectViewModel import org.koin.compose.viewmodel.koinViewModel @@ -47,7 +48,16 @@ fun CreateProjectScreen( value = state.path, onValueChange = viewModel::onPathChange, label = { Text("Ruta del proyecto") }, - modifier = Modifier.fillMaxWidth() + modifier = Modifier.fillMaxWidth(), + trailingIcon = { + Button( + onClick = { + pickDirectory()?.let { viewModel.onPathChange(it) } + } + ) { + Text("Elegir") + } + } ) state.error?.let { diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/util/pickDirectory.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/util/pickDirectory.kt new file mode 100644 index 0000000..788c0ad --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/util/pickDirectory.kt @@ -0,0 +1,3 @@ +package com.elitec.appmakeup.presentation.util + +expect fun pickDirectory(): String? \ No newline at end of file diff --git a/composeApp/src/jvmMain/java/com/elitec/appmakeup/presentation/util/pickDirectory.jvm.kt b/composeApp/src/jvmMain/java/com/elitec/appmakeup/presentation/util/pickDirectory.jvm.kt new file mode 100644 index 0000000..57d9c3b --- /dev/null +++ b/composeApp/src/jvmMain/java/com/elitec/appmakeup/presentation/util/pickDirectory.jvm.kt @@ -0,0 +1,10 @@ +package com.elitec.appmakeup.presentation.util + +import java.awt.FileDialog +import java.awt.Frame + +actual fun pickDirectory(): String? { + val dialog = FileDialog(Frame(), "Selecciona una carpeta") + dialog.isVisible = true + return dialog.directory +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt new file mode 100644 index 0000000..f2cecbd --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt @@ -0,0 +1,134 @@ +package com.elitec.appmakeup.di + +import com.elitec.appmakeup.core.v4.contracts.MapperContract +import com.elitec.appmakeup.core.v4.contracts.RepositoryContract +import com.elitec.appmakeup.core.v4.generators.CompositeLayerGenerator +import com.elitec.appmakeup.core.v4.generators.data.RepositoryImplGenerator +import com.elitec.appmakeup.core.v4.generators.domain.DomainEntityGenerator +import com.elitec.appmakeup.core.v4.generators.feature.FeatureSkeletonGenerator +import com.elitec.appmakeup.core.v4.generators.mapper.MapperGenerator +import com.elitec.appmakeup.core.v4.generators.repository.RepositoryGenerator +import com.elitec.appmakeup.core.v4.generators.usecase.UseCaseGenerator +import com.elitec.appmakeup.core.v4.pipeline.DefaultGenerationStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultPlanningStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultReportingStage +import com.elitec.appmakeup.core.v4.pipeline.FileSystemWritingStage +import com.elitec.appmakeup.core.v4.pipeline.GenerationPipeline +import com.elitec.appmakeup.core.v4.pipeline.GenerationStage +import com.elitec.appmakeup.core.v4.pipeline.PlanningStage +import com.elitec.appmakeup.core.v4.pipeline.ReportFormat +import com.elitec.appmakeup.core.v4.pipeline.ReportingStage +import com.elitec.appmakeup.core.v4.pipeline.ValidationStage +import com.elitec.appmakeup.core.v4.pipeline.WritingOptions +import com.elitec.appmakeup.core.v4.pipeline.WritingStage +import com.elitec.appmakeup.core.v4.validation.ArchitectureValidator +import com.elitec.appmakeup.core.v4.validation.DefaultValidationStage +import com.elitec.appmakeup.core.v4.validation.EntityValidator +import com.elitec.appmakeup.core.v4.validation.FeatureValidator +import org.koin.dsl.module + +val coreV4Module = module { + + /* ------------------------- + * GENERATORS (CONCRETOS) + * ------------------------- */ + + single { FeatureSkeletonGenerator() } + single { DomainEntityGenerator() } + single { RepositoryGenerator( contracts = get()) } + single { UseCaseGenerator( contracts = get()) } + single { RepositoryImplGenerator( contracts = get()) } + single { MapperGenerator( contracts = get()) } + + /* ------------------------- + * VALIDATION + * ------------------------- */ + + single { EntityValidator() } + single { FeatureValidator(get()) } + single { ArchitectureValidator() } + + single { + DefaultValidationStage( + featureValidator = get(), + architectureValidator = get() + ) + } + + /* ------------------------- + * PLANNING + * ------------------------- */ + + // Para MVP: listas explícitas (aunque estén vacías) + single> { emptyList() } + single> { emptyList() } + + single { + DefaultPlanningStage( + repositoryContracts = get(), + mapperContracts = get() + ) + } + + /* ------------------------- + * GENERATION + * ------------------------- */ + + single { + DefaultGenerationStage( + domainGenerator = CompositeLayerGenerator( + listOf( + get(), + get(), + get() + ) + ), + dataGenerator = CompositeLayerGenerator( + listOf( + get(), + get() + ) + ), + presentationGenerator = null, // Core V5 + repositoryGenerator = null, // ya incluido arriba + mapperGenerator = null // ya incluido arriba + ) + } + + /* ------------------------- + * WRITING + * ------------------------- */ + + single { + FileSystemWritingStage( + options = WritingOptions( + dryRun = false, + overwrite = true + ) + ) + } + + /* ------------------------- + * REPORTING + * ------------------------- */ + + single { + DefaultReportingStage( + format = ReportFormat.CLI + ) + } + + /* ------------------------- + * PIPELINE (CLAVE) + * ------------------------- */ + + single { + GenerationPipeline( + validationStage = get(), + planningStage = get(), + generationStage = get(), + writingStage = get(), + reportingStage = get() + ) + } +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt index 522a3f5..d6d5bea 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt @@ -6,6 +6,8 @@ fun initKoin() { startKoin { modules( infrastructureModule, + validationModule, + coreV4Module, applicationModule, presentationModule ) diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt new file mode 100644 index 0000000..7fc4f5d --- /dev/null +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt @@ -0,0 +1,22 @@ +package com.elitec.appmakeup.di + +import com.elitec.appmakeup.core.v4.pipeline.ValidationStage +import com.elitec.appmakeup.core.v4.validation.ArchitectureValidator +import com.elitec.appmakeup.core.v4.validation.DefaultValidationStage +import com.elitec.appmakeup.core.v4.validation.EntityValidator +import com.elitec.appmakeup.core.v4.validation.FeatureValidator +import org.koin.dsl.module + +val validationModule = module { + + single { EntityValidator() } + single { FeatureValidator(get()) } + single { ArchitectureValidator() } + + single { + DefaultValidationStage( + featureValidator = get(), + architectureValidator = get() + ) + } +} \ No newline at end of file From 3c70b3e1bbabfec9808a767875a971acd2194195 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Fri, 23 Jan 2026 10:28:50 -0600 Subject: [PATCH 15/20] dry-run generation test --- composeApp/build.gradle.kts | 3 + .../com/elitec/appmakeup/di/coreV4Module.kt | 2 +- .../core/v4/GenerationPipelineDryRunTest.kt | 152 ++++++++++++++++++ 3 files changed, 156 insertions(+), 1 deletion(-) create mode 100644 composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDryRunTest.kt diff --git a/composeApp/build.gradle.kts b/composeApp/build.gradle.kts index e65739e..fcdc0b3 100644 --- a/composeApp/build.gradle.kts +++ b/composeApp/build.gradle.kts @@ -60,6 +60,9 @@ kotlin { implementation(compose.desktop.currentOs) implementation(libs.kotlinx.coroutinesSwing) } + jvmTest.dependencies { + + } } } diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt index f2cecbd..2fba65b 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt @@ -102,7 +102,7 @@ val coreV4Module = module { single { FileSystemWritingStage( options = WritingOptions( - dryRun = false, + dryRun = true, overwrite = true ) ) diff --git a/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDryRunTest.kt b/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDryRunTest.kt new file mode 100644 index 0000000..dcb8717 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDryRunTest.kt @@ -0,0 +1,152 @@ +package com.elitec.appmakeup.core.v4 + +import com.elitec.appmakeup.core.architecture.DefaultArchitecture +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.contracts.GenerationResult +import com.elitec.appmakeup.core.v4.definition.CoreEntity +import com.elitec.appmakeup.core.v4.definition.CoreFeature +import com.elitec.appmakeup.core.v4.definition.CoreLayer +import com.elitec.appmakeup.core.v4.definition.CoreProperty +import com.elitec.appmakeup.core.v4.generators.CompositeLayerGenerator +import com.elitec.appmakeup.core.v4.generators.domain.DomainEntityGenerator +import com.elitec.appmakeup.core.v4.generators.repository.RepositoryGenerator +import com.elitec.appmakeup.core.v4.pipeline.DefaultGenerationStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultPlanningStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultReportingStage +import com.elitec.appmakeup.core.v4.pipeline.FileSystemWritingStage +import com.elitec.appmakeup.core.v4.pipeline.GenerationPipeline +import com.elitec.appmakeup.core.v4.pipeline.ReportFormat +import com.elitec.appmakeup.core.v4.pipeline.WritingOptions +import com.elitec.appmakeup.core.v4.validation.ArchitectureValidator +import com.elitec.appmakeup.core.v4.validation.DefaultValidationStage +import com.elitec.appmakeup.core.v4.validation.FeatureValidator +import java.nio.file.Files +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class GenerationPipelineDryRunTest { + @Test + fun `dry-run should generate domain artifacts without writing files`() { + + val tempDir = Files.createTempDirectory("appmakeup-test").toFile() + + val feature = CoreFeature( + name = "User", + layers = setOf(CoreLayer.DOMAIN), + entities = listOf( + CoreEntity( + name = "User", + properties = listOf( + CoreProperty("id", "String", isIdentifier = true), + CoreProperty("name", "String") + ) + ) + ) + ) + + val context = GenerationContext( + architecture = DefaultArchitecture.value, + feature = feature, + outputPath = tempDir.absolutePath + ) + + val pipeline = GenerationPipeline( + validationStage = DefaultValidationStage( + featureValidator = FeatureValidator(), + architectureValidator = ArchitectureValidator() + ), + planningStage = DefaultPlanningStage(), + generationStage = DefaultGenerationStage( + domainGenerator = DomainEntityGenerator(), + dataGenerator = null, + presentationGenerator = null, + repositoryGenerator = null, + mapperGenerator = null + ), + writingStage = FileSystemWritingStage( + WritingOptions(dryRun = true, overwrite = true) + ), + reportingStage = DefaultReportingStage(ReportFormat.CLI) + ) + + val result = pipeline.run(context) + + assertTrue(result is GenerationResult.Success) + + // filesystem vacío + assertEquals( + 1, + tempDir.walkTopDown().toList().size + ) + } +} + +private fun pipeline(): GenerationPipeline = + GenerationPipeline( + validationStage = DefaultValidationStage( + featureValidator = FeatureValidator(), + architectureValidator = ArchitectureValidator() + ), + planningStage = DefaultPlanningStage( + repositoryContracts = emptyList(), + mapperContracts = emptyList() + ), + generationStage = DefaultGenerationStage( + domainGenerator = CompositeLayerGenerator( + listOf( + DomainEntityGenerator() + ) + ), + dataGenerator = CompositeLayerGenerator( + listOf( + RepositoryGenerator(emptyList()) + ) + ), + presentationGenerator = null, + repositoryGenerator = null, + mapperGenerator = null + ), + writingStage = dryRunWritingStage(), + reportingStage = DefaultReportingStage(ReportFormat.CLI) + ) + +private fun dryRunWritingStage() = + FileSystemWritingStage( + options = WritingOptions( + dryRun = true, + overwrite = true + ) + ) + +private fun sampleContext(outputPath: String) = + GenerationContext( + architecture = DefaultArchitecture.value, + feature = sampleFeature(), + outputPath = outputPath + ) + +private fun sampleFeature(): CoreFeature = + CoreFeature( + name = "User", + layers = setOf( + CoreLayer.DOMAIN, + CoreLayer.DATA + ), + entities = listOf( + CoreEntity( + name = "User", + properties = listOf( + CoreProperty( + name = "id", + type = "String", + isIdentifier = true + ), + CoreProperty( + name = "name", + type = "String" + ) + ) + ) + ) + ) \ No newline at end of file From c6b213035349d0955ede056aa42697331673d844 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Fri, 23 Jan 2026 10:55:41 -0600 Subject: [PATCH 16/20] dry-run data, domain generation test --- .../v4/validation/ArchitectureValidator.kt | 12 +- .../validation/RepositoryContractValidator.kt | 12 +- .../v4/GenerationPipelineDataDryRunTest.kt | 124 ++++++++++++++++++ .../core/v4/GenerationPipelineFailureTest.kt | 78 +++++++++++ 4 files changed, 217 insertions(+), 9 deletions(-) create mode 100644 composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDataDryRunTest.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineFailureTest.kt diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt index 1bf6327..6d62375 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/ArchitectureValidator.kt @@ -20,7 +20,15 @@ class ArchitectureValidator : Validator> { ) } - // 2️⃣ Reglas de dependencia + // 2) (Opcional) Asegurar que hay reglas para esas layers + val missingRules = feature.layers.filterNot { architecture.dependencyRules.containsKey(it) }.toSet() + if (missingRules.isNotEmpty()) { + return ValidationResult.Invalid( + "Architecture has no dependency rules for layers: $missingRules" + ) + } + + /*// 2️⃣ Reglas de dependencia architecture.dependencyRules.forEach { (layer, allowedDeps) -> if (feature.layers.contains(layer)) { val invalidDeps = feature.layers - allowedDeps - layer @@ -30,7 +38,7 @@ class ArchitectureValidator : Validator> { ) } } - } + }*/ return ValidationResult.Valid } diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/RepositoryContractValidator.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/RepositoryContractValidator.kt index 1cc6790..0c5d3ef 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/RepositoryContractValidator.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/validation/RepositoryContractValidator.kt @@ -8,13 +8,11 @@ class RepositoryContractValidator( override fun validate(target: RepositoryContract): ValidationResult { - // 1. Validar entidad asociada + // 1️⃣ Validar entidad val entityResult = entityValidator.validate(target.entity) - if (!entityResult.isValid()) { - return entityResult - } + if (!entityResult.isValid()) return entityResult - // 2. Al menos una operación debe estar soportada + // 2️⃣ Al menos una operación if ( !target.supportsCreate && !target.supportsRead && @@ -26,11 +24,11 @@ class RepositoryContractValidator( ) } - // 3. Operaciones de escritura requieren identificador + // 3️⃣ Operaciones de escritura requieren identificador val hasWriteOperations = target.supportsCreate || target.supportsUpdate || target.supportsDelete - if (hasWriteOperations) { + if (hasWriteOperations && target.entity.identifier == null) { return ValidationResult.Invalid( "Repository with write operations requires entity ${target.entity.name} to have an identifier" ) diff --git a/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDataDryRunTest.kt b/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDataDryRunTest.kt new file mode 100644 index 0000000..7db8d10 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineDataDryRunTest.kt @@ -0,0 +1,124 @@ +package com.elitec.appmakeup.core.v4 + +import com.elitec.appmakeup.core.architecture.DefaultArchitecture +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.contracts.GenerationResult +import com.elitec.appmakeup.core.v4.contracts.RepositoryContract +import com.elitec.appmakeup.core.v4.definition.CoreEntity +import com.elitec.appmakeup.core.v4.definition.CoreFeature +import com.elitec.appmakeup.core.v4.definition.CoreLayer +import com.elitec.appmakeup.core.v4.definition.CoreProperty +import com.elitec.appmakeup.core.v4.generators.CompositeLayerGenerator +import com.elitec.appmakeup.core.v4.generators.data.RepositoryImplGenerator +import com.elitec.appmakeup.core.v4.generators.domain.DomainEntityGenerator +import com.elitec.appmakeup.core.v4.generators.repository.RepositoryGenerator +import com.elitec.appmakeup.core.v4.generators.usecase.UseCaseGenerator +import com.elitec.appmakeup.core.v4.pipeline.DefaultGenerationStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultPlanningStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultReportingStage +import com.elitec.appmakeup.core.v4.pipeline.FileSystemWritingStage +import com.elitec.appmakeup.core.v4.pipeline.GenerationPipeline +import com.elitec.appmakeup.core.v4.pipeline.ReportFormat +import com.elitec.appmakeup.core.v4.pipeline.WritingOptions +import com.elitec.appmakeup.core.v4.validation.ArchitectureValidator +import com.elitec.appmakeup.core.v4.validation.DefaultValidationStage +import com.elitec.appmakeup.core.v4.validation.FeatureValidator +import java.nio.file.Files +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class GenerationPipelineDataDryRunTest { + @Test + fun `dry-run should generate domain and data artifacts when repository contract exists`() { + + // GIVEN + val tempDir = Files.createTempDirectory("appmakeup-data-test").toFile() + + val userEntity = CoreEntity( + name = "User", + properties = listOf( + CoreProperty( + name = "id", + type = "String", + isIdentifier = true + ), + CoreProperty( + name = "name", + type = "String" + ) + ) + ) + + val repositoryContract = RepositoryContract( + entity = userEntity, + supportsCreate = true, + supportsRead = true, + supportsUpdate = true, + supportsDelete = false + ) + + val feature = CoreFeature( + name = "User", + layers = setOf( + CoreLayer.DOMAIN, + CoreLayer.DATA + ), + entities = listOf(userEntity) + ) + + val context = GenerationContext( + architecture = DefaultArchitecture.value, + feature = feature, + outputPath = tempDir.absolutePath + ) + + val pipeline = GenerationPipeline( + validationStage = DefaultValidationStage( + featureValidator = FeatureValidator(), + architectureValidator = ArchitectureValidator() + ), + planningStage = DefaultPlanningStage( + repositoryContracts = listOf(repositoryContract), + mapperContracts = emptyList() + ), + generationStage = DefaultGenerationStage( + domainGenerator = CompositeLayerGenerator( + listOf( + DomainEntityGenerator(), + RepositoryGenerator(listOf(repositoryContract)), + UseCaseGenerator(listOf(repositoryContract)) + ) + ), + dataGenerator = CompositeLayerGenerator( + listOf( + RepositoryImplGenerator(listOf(repositoryContract)) + ) + ), + presentationGenerator = null, + repositoryGenerator = null, + mapperGenerator = null + ), + writingStage = FileSystemWritingStage( + WritingOptions(dryRun = true, overwrite = true) + ), + reportingStage = DefaultReportingStage(ReportFormat.CLI) + ) + + // WHEN + val result = pipeline.run(context) + + // THEN + assertTrue( + result is GenerationResult.Success, + "Pipeline should succeed when DATA contracts are valid" + ) + + // filesystem debe estar vacío (solo el directorio raíz) + assertEquals( + 1, + tempDir.walkTopDown().toList().size, + "No files should be written in dry-run mode" + ) + } +} \ No newline at end of file diff --git a/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineFailureTest.kt b/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineFailureTest.kt new file mode 100644 index 0000000..ed7ca2a --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/elitec/appmakeup/core/v4/GenerationPipelineFailureTest.kt @@ -0,0 +1,78 @@ +package com.elitec.appmakeup.core.v4 + +import com.elitec.appmakeup.core.architecture.DefaultArchitecture +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.contracts.GenerationResult +import com.elitec.appmakeup.core.v4.definition.CoreFeature +import com.elitec.appmakeup.core.v4.definition.CoreLayer +import com.elitec.appmakeup.core.v4.generators.domain.DomainEntityGenerator +import com.elitec.appmakeup.core.v4.pipeline.DefaultGenerationStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultPlanningStage +import com.elitec.appmakeup.core.v4.pipeline.DefaultReportingStage +import com.elitec.appmakeup.core.v4.pipeline.FileSystemWritingStage +import com.elitec.appmakeup.core.v4.pipeline.GenerationPipeline +import com.elitec.appmakeup.core.v4.pipeline.ReportFormat +import com.elitec.appmakeup.core.v4.pipeline.WritingOptions +import com.elitec.appmakeup.core.v4.validation.ArchitectureValidator +import com.elitec.appmakeup.core.v4.validation.DefaultValidationStage +import com.elitec.appmakeup.core.v4.validation.FeatureValidator +import java.nio.file.Files +import kotlin.test.Test +import kotlin.test.assertContains +import kotlin.test.assertTrue + +class GenerationPipelineFailureTest { + + @Test + fun `pipeline should fail when feature has no entities`() { + + // GIVEN + val tempDir = Files.createTempDirectory("appmakeup-failure-test").toFile() + + val invalidFeature = CoreFeature( + name = "InvalidFeature", + layers = setOf(CoreLayer.DOMAIN), + entities = emptyList() // ❌ inválido + ) + + val context = GenerationContext( + architecture = DefaultArchitecture.value, + feature = invalidFeature, + outputPath = tempDir.absolutePath + ) + + val pipeline = GenerationPipeline( + validationStage = DefaultValidationStage( + featureValidator = FeatureValidator(), + architectureValidator = ArchitectureValidator() + ), + planningStage = DefaultPlanningStage(), + generationStage = DefaultGenerationStage( + domainGenerator = DomainEntityGenerator(), + dataGenerator = null, + presentationGenerator = null, + repositoryGenerator = null, + mapperGenerator = null + ), + writingStage = FileSystemWritingStage( + WritingOptions(dryRun = true) + ), + reportingStage = DefaultReportingStage(ReportFormat.CLI) + ) + + // WHEN + val result = pipeline.run(context) + + // THEN + assertTrue( + result is GenerationResult.Failure, + "Pipeline should fail for invalid feature" + ) + + val failure = result as GenerationResult.Failure + assertTrue( + failure.reason.contains("must contain at least one entity"), + "Failure reason should explain validation error" + ) + } +} \ No newline at end of file From 1017824902d14ea2dec316f2eaf8a6d6a345e0a2 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Sat, 24 Jan 2026 19:49:23 -0600 Subject: [PATCH 17/20] dry-run data, domain generation test --- .../font/abrilFatface_regular.ttf | Bin 0 -> 67364 bytes .../composeResources/font/poppins_black.ttf | Bin 0 -> 151396 bytes .../composeResources/font/poppins_bold.ttf | Bin 0 -> 153944 bytes .../font/poppins_extraBold.ttf | Bin 0 -> 152764 bytes .../composeResources/font/poppins_italic.ttf | Bin 0 -> 182012 bytes .../composeResources/font/poppins_light.ttf | Bin 0 -> 159892 bytes .../composeResources/font/poppins_medium.ttf | Bin 0 -> 156520 bytes .../composeResources/font/poppins_regular.ttf | Bin 0 -> 158240 bytes .../font/poppins_semiBold.ttf | Bin 0 -> 155232 bytes .../elitec/appmakeup/di/presentationModule.kt | 1 + .../appmakeup/generation/CodeGenerator.kt | 2 +- .../generation/GenerateCodeUseCase.kt | 4 +- .../navigation/MainNavigationWrapper.kt | 16 +- .../screens/CreateProjectScreen.kt | 3 +- .../screens/ProjectEditorScreen.kt | 121 +++------- .../presentation/screens/SplashScreen.kt | 2 +- .../screens/components/AddFeatureInput.kt | 39 +++ .../screens/components/AddPropertyInput.kt | 50 ++++ .../screens/components/ErrorView.kt | 32 +++ .../components/ProjectEditorContent.kt | 122 ++++++++++ .../states/CreateProjectUiState.kt | 2 +- .../presentation/states/ExportUiState.kt | 11 + .../presentation/states/ProjectEditorState.kt | 11 + .../states/ProjectEditorUiState.kt | 2 + .../appmakeup/presentation/theme/Color.kt | 226 ++++++++++++++++++ .../appmakeup/presentation/theme/Theme.kt | 98 ++++++++ .../appmakeup/presentation/theme/Type.kt | 36 +++ .../viewmodels/ExportViewModel.kt | 79 ++++++ .../viewmodels/ProjectEditorViewModel.kt | 49 ++-- .../com/elitec/appmakeup/di/coreV4Module.kt | 2 +- .../appmakeup/exports/ProjectExporter.kt | 5 +- .../generation/ProjectCodeGenerator.kt | 4 +- .../kotlin/com/elitec/appmakeup/main.kt | 129 +++++----- .../persistence/FileProjectPersistence.kt | 4 +- 34 files changed, 877 insertions(+), 173 deletions(-) create mode 100644 composeApp/src/commonMain/composeResources/font/abrilFatface_regular.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_black.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_bold.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_extraBold.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_italic.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_light.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_medium.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_regular.ttf create mode 100644 composeApp/src/commonMain/composeResources/font/poppins_semiBold.ttf create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ErrorView.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ProjectEditorContent.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ExportUiState.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorState.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Color.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Theme.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Type.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt diff --git a/composeApp/src/commonMain/composeResources/font/abrilFatface_regular.ttf b/composeApp/src/commonMain/composeResources/font/abrilFatface_regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..e761f7b9c3c77290511fd87c296c8a3077d5db44 GIT binary patch literal 67364 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 z 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 literal 0 HcmV?d00001 diff --git a/composeApp/src/commonMain/composeResources/font/poppins_bold.ttf b/composeApp/src/commonMain/composeResources/font/poppins_bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..00559eeb290fb8036f10633ff0640447d827b27c GIT binary patch literal 153944 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%0AC7VmlS@LZ-TEZV}oirP&oT11@@uCp8_l( zWV^OlLJ)W@j2HvSB~PiWm}?y|RJ zrzB1>DH$fKKF6XjAIsmr_TCFf?uC71;yx7cHvlzatZ1jkSfe4cP7U;n^u$Hskz$9x zWl?Szh9{|s6U(A)dd9W3a`PT`E9+WYfwS6Bj1TB>2f*^yihn+(+&9adZeJ;D1|T*P zJKb<-D^oV&+C5x0dVS4 z%N-@CFK88_<*xv(ewBHu9U%=Hz}_&-gvxxQ6zmqcMIy(|)nhZe+ADW#11`lAKvl%cEJt-xCtN1FTf`Y^Ow;+OW#gNeumS37uK)xddSB&vR-11C=-?2=3ydRh}S`*f9`P%L8fT}F0MB`2( z@y>;!$!FvO2GYrYCzNj$Ykj0KP33E#=WB+M|07fdH!jJKKs$7Hc>-#>iN1{YVq=R7>ma}+@94V}NROI%gY zj`0G`#NQ+599W?baSQm?3O`pSe=oq5Q4dVr*UWPH@8@w}{B4-)u`nurOo4BlW*;72 zQe6t^y=d(o?Y@|~+f!C*bKg@RSShJ8nR6_-QPC;{mizjK=P>(Q0sWB2Qt& zGK&sa6;ORr94Dz@=k}$mLosz`<_|komT|*8UkPkhusT#*ZBVATN8G0fUrh8VVO2B9 zUmjDW0arP`lj5;Bmp>)cB*{VHt@Z1>Q>2j$vTI-3&QL6wy{FvV$2>zzpjO4a8jw*| zl?7+#HApN8Kanx2r02!@I`vM7?Dn&L`~*LV|CB6Yg8Gz?58+BHNU6#_7JDIKN6W|| zN6+xQCBrQa)J@j~CF%P6u}G;HiiQ5TzxCAgqz*GOjS{{4Vh zgaJjc!V7P1w4xU%w30p{N#%-8GY&=M6_>Bhlk(Ns=j07h`&Q2-y?ZkHXnZ=9u}&#A zU8an+WkbiHl$GA*6$|GpWKro~2fXn(6EU-z_W=CR9&r1wqbXMVc9IT{m%PFe~RvKy71xmJsCIgjLt`NuSi`eN{qKbud%tIniS=y8A@Kuui4YG1CmY(0d3%a)SWMf;O}ai_nIq^k<}}IS+AG+1j{; z$`y+>8jrLm4VZ!Y;UCz41G&T0S7~>LQmppjo>}5q`K=U^IFZrRloyni-*)3M7yahc zkEs>2~HeyEQkz#J1fdW374cUEYr41)Hk#S0$zP6;!Uvukm<( zL~<4G3-$@1gH)dUC=r@oiAkiJF(foB7i&GSHlW8{Q0%_VlxwurA8KhiRA)7sP44|2 zO73>{mG7K!y4?i@@UK8qVSh?;Pf_i9r*nO6(W>OszI>h_?=SK#mVEq|_v<*FB!_I3 zBvBC&2q}K$X;dQ22_z+m3JN!H%wXr>&4!*eKDsKhhR@|~E*&dk99n$?cd(?j(&Z?> zt$ebj{YWj@p{6M0Uaa-L$Zg(URT6GDqk`_J&D-1(9}{mWFSfhO^BT98mhEh$Th+WT zt*mCUJ6ap86%o2zD#f?i`+!yh=Km5Yl6r8cV_Ys4yX|&HRaaSDRdDeD^8Nsw(Y z+1&fvmvFbT-+uBAO^!X^VKmwW`K>SIDt44Q`}6a6W9YyD~fz|TByq6b)d&evY~Ljj}lgTt`~YIjG0|^2Uo5$@=Wx_k^@zd%Zmpp1zRX=!)NWAhYvdIYM;ue0qr|n zkNfHrmE23U-chD&(++Z^-k()h7r3gcU3j*K>-Ox9&9yk2YbQ!db~KX(cHTGOP}5ef zthZD|Xmb`-Ih~bN4hQ6!5FK&9nJdkJQol%ROn@}8@+s$#c#?sZ63|)?8 zqL=%W{oZdtk`?ZPeD{z&JIhvR&t``zmhT$qD&`8er>YzSMYfK_)V`uM+m}~*JYNwB zf;2l^hV>D)+^jreNuFZc;jAlRdpNO?6iG>64e0mMJQOiUc=(d22Wh7{7iOWKWM*&K zd0=~nK09aIuHBoqoRHtjIE{u(yJ_7-u{PsY)|q3-beP5_Mq28*2ieid=a}a+;+9r+ zG_QnTo396X#`pRmz$MXd8Ku zeYVeMxRElU#fyk|KFU8v$~SGUUA3~=Rhg6!nD=AP!D<3cd)KwV zB1HKwxtD6V1y5}quPhCB5VLitcF&%r5eZ4@39<3nw#rw z6%iVMaRMLQ3oQ0WJ50G*Stb;_ zA;aZtn?$ic#BM!yQEf@kxk_vX=K1LO#KkP5sB3oVxRxF93Ar71TWf4wl_6P|nxu^@ z>Y`fX{gzoZA-7pFpxA@n^97ij{t3>{6RmAfr4ioFg8s+go{h1u{lKc#m$~E3tF_Mx#R#CsnS?uwgr!~W`6j*mFf@sIjBE}Mf z?DKY^IpOaxRVbAe0v+P~3Wv_wHw_;$>T}H+Zn|SbPlu~EH6bQNHX&cr*g16Fp}x}{ zbf2Z75pCvo!e)P2QxtBuprt%mGr2d8O-fcLb+^>^nzIwql42sm6Bm`&^)(J|t~k_9 zHe7n&Xslp#b!S~=O2Hq#z+$x=r@hQ~LUVKs(JAEN4K0zMgTzyDRVBs6CBdn5)wlE% zAB(Hb0b2@IFdt4Kk-LU{=G!|GbVW7xtlT_$8X4MH{xpip+A3F?xT+gd)2*wVdF=^l z>#KS3b5mw(hOICIfbAsKm;V4L*W+7*s9OOc2CaI~)hR%yIOkH&WEP;9sGZ_*0Hdup}NbRsIK{LY(L9AB;ivL!v`Ufl5F+%O!qX z_U`JP^+$Pc_!COS%*=5@1ACUb!UDjdH$@*BZQdbxL4g!X$U@=)tDsy#tsTy-v_iiY zFPHf(o0LL785M;#Xtz*0Z`%4Cmq4X8r^H#ax}mXNAoJoyUSde!SMpx~eGWtzisyEj z%My~tiO{!X9i{OP_w4jOPHFtsJXb@Y^vNeBXB(z?5hzW7DO=g}t_yF`^f?Q?0|hll z(HAWUkmxsx7kMcAHbR8r$CtiM4>X&8feTB9q=GsLA51@%ft@z0%nUW@UV>hRo8a?P zLsas}1(ZleA$)pZ0punr;O{0%(Os8*OGuHW1}k+~`-+FhP6d)CmN#gP(E_vydQZG6 z2KQL1z)T-2=t1NIKSf&ye?wuB0RO(GM7d|msC-@ts8!s4lmKS}2@;DFG**>kbryG# z@Ks}4Z$S^vS7L+F1R<*L0SXGUX91F3wbsFd)Y7OD{bS}jN?2(Kn3_Lj_lZqR)KY~h zI)F0l@`mh~5W@%fe$#FJ-g+gKe-eT49DqRqx53{Qm^A#1|YEyda^eCI82I7_DX!T+)X-*^c|Oo?ajAeF6Ef)~W&o;z7jKq%2!vKYRKoLqjU zl+qGxrj#NGV@mfo9x#=d>d)jnqo&Ymy+zKD_SJU%sx4qaa#^0DAQ8tWfP_?3S?ntF6*iadb@45*}OjMYb zdwkU@r47d^371oTY4{BHhTq^7#+~mhqqC3Q6Vow;{&TZAbr z*wDdr`;T3Tbv5wpwQO~@Rm3Mmx0b}GdKUC`xNS_bI9CWQAynfqPsoz?OZfU-;eps+ zFM%7t;ZLnWfr=Kb!pq??22F0=J8HjoL$g~Za%(lXlrCze$ANJ zfR5Zu5^ntJ=)et3g&<3ad^5Zxrz7wa3!@i#`yWSQF(uAA5X~p$XZg~lFFZK0`>Nm! zEv_u7mGH#8;m47%5Htu=pVatql_>H=YPmARPw*Rj{rc(AgF@9D|B)>jK0j4lS6&j8 z1ryA(k1=0)Ka!=PD4De-`E+1;tMeE<;6mK@8H5bqg5Q~eZ@9jEERy1Hm&S6+pw-;K|cV6EVM5kn!qp8DSX0;P#` z69tln3i4O*b^YkZ*ryLHAS{~11rYjtK5xv0zrlMB0=2HjaY(WLJ3ct6Ue zvyP#XN+Q7UtAHMpZ!Ux&LO!^`tbLB#pgmgt02Jw!48JO{C2R3eNo8?CLiUbR7Y?x7 z+bS-d3BL^#@vsAq%`#*r4BpUR6m061$j(ECywLpYQ#pQOI@}5RiTr$<%YP zG|#7!>B%F4qu4*S%fo*#>JJl+b37`bzwwH@P~dGI(J+B`f)u0Yj)+k_5UL}EjD;EA zyUd^T@JXDG={NRe-Ubzz_Tn#8=_nT=(#C3~i{9#aBkjb)dD_y3Ua5BE{3FiDiofW;_-?Dq71))$V4(`aKp&n1*0x^QGODTddEKI zuvZuUB0wZmSo=Vbi5~wZK~B|%$wT2ZQI119_}Nj%UIt$ zMn(o&bTBf|1Xqe$$^*bdKu21DCqyF|+zlQGvaI5^y;HcD;=KIESw`4NL1G%eRTTTC zf_p%es8%>(-bzCF!tk++hEGuauzA)PK2ermK(}1hxi9^PZ!(iBiurY`Rg)QMN!|nU zCjs};+|I~kFjAKwU#`~}DobArXPVgfWU_@d&$O(_SmE&uwvI-!GDii@AVmMi5PZTn z>q(nq&uKb`Js_Y1G4lRU765wEBE-cJ7Y_U%M>S4)GIY)4D4-lZ&xoh;?ezwYXi3vc zZL6YJB-%i_#~8MX`lP ze7e6fTH)_2aTKK=j41pQ9!6BOu7tZ6hl7OVA^dNECK^k4Gkv%qIF86RRKDm6c+={n zh$718Ip8yY&K#U?${{ic=8FuE6Uu+8g>8$RB`$~Co15b!mZs#Kh`kXGA_I72*Mh}gk*8HwRxSL#uicu%a z-9JBP?cRulZzr#<#7P7)=2icySkZ=x%kcN3a!Xzj1m#?>v{HtBoC+tz0>4Lp&}Et0&9V&gB*jvauwsDS~)GvqM% zG;O%Nal1NWf9=T!f^iexP}jAQS=?4}0ou_SoR%S|Ahe;o^734_T^)=KOZl3Pg|W1| z2!>-6))LG=;o}_P1AB`k8Pk*)aAQxJ!`8h%XR;c8PF4d%@srPGP-ZaEAf0%uUpcLSl zoS+o2)FBjD35p%g6wguE?JgeYTbVjXzDARknQQT!HTId>@(L{G;;lWo+;`dG>&`Jx zJK|F&QW8?sCIk1U0}gey&04ik9$8_juc-ET{*9a^FF}Zv{mwGD{NiHtgfIz(a}Zl0 zq_<^L+@f5oAgWvxUe(?vUYMaJ*T)=THEF!8i0~RVIZ>48Q@Ga^r{MH)>rWN+DL#vf z0wZ;VKw;tyq5qM{QCehRV6U^{l+XW{kqI!{o^tth2UJcr>AC9^_lPZ`+z*c5eS}0Z z;_juYA@jC(@~uXPC7XNw=D0*yGezk3O@`rq`Qe9zhcDPez=IAtMxn;!e+B}nRK`Bd zU9N;KLNKZLPWpY#O$*mVt>Q(XgC^|BiJhiyk z%G_i%8UWqked(B1?_87b>`6>$b&ihX)#l!fkS*H0JnBYnW<}KQ=+s<-p#lU1(nohQ z2GB=Sf7HwXJ0lRtYq8TH61Z^Dk$W~(tqelpuZpb+K%|7is6}UYEZGh z+OuKZ;KZS^oR$51w+~vmZ^^FWX3jpZ%E(l`$sFUpbf``Gv~)E)G}FpxRa^FM>>KN? z99lKp2Qqy-EhQ=S)x&B{veuXhG5=Q(_~YwwJlbyRO(_+=s|}74J5qc#3&9ewzZf}J zcyeH}(3o4)mbdgB_G9n9vh?gswJTqpVKvtEqXzC-)zxS(S*VC`<>uSVJ)X(Lq=cm1 z$*@GHy%Tc|?h=bKA-Uxh>zY7;orx{B688~TlT)}VH(RgIM&EHYd)4?wfZ>>IS;jok zhy2H$)Kq(q)7G9C-=5EF*xTW9i{4#qSp;0wB95uBVj?a_C8sqL27JOpQj7%>(+ zVp=qG9vWz%UbsFreM{Y@>v2HUhPHrlV-=Q)l?x+1YnUuA#DM_;Q*J&~5$&d2Q-5z! zeWYwzM@7q^|LifH%3<$W;}zZK(2?yEzxTiUp6>5(2Lr>(-)4MNWkE@8^lmx(jS<{qv&b752KDZdVSE zj1+zJJo*}Hpq%_QQahFol$)clS3W{+E<3@d#u0ud$T^YMeF;PUhG`yt$PATWq47lE zfVesAe1nm2bNLB61rF>!Se5s|#$gtQulpfiyQS;jo#N%>;|3wv_XjL!#oP_R!TA#K zLO_?ga#x~nAlnXWExrpkDLxm`3tq3du`zVJx;}-zV+@r;G@%IqGWZrZ;^fq?lsNIE z0=5?5X7Vk3Eaa;ekmnu@d-&8-crOBGLvxOKPUzJYQc);p0;Uj2mJUum2Ok5SXft6lvQ zrYF+ioQuawAW~#2vT|(sIb{_yx$>XQOu_-{O?1*8^!^NWx^v7W^i>K@bIPbSWMS8j z_cQ3wgukkx9h%XK)j(So;FZZIBj!H2Gx%J>hiiS^CC2rMx;{fNH+Z9tFh zzW$kI*7jIYORZzK=Okuk=Xp;mHgnH#U+S`AmYdAI{X3?#$%)!UhnKir-YijRajZ+< zbq#A)?@!6HlL>;Tqm>m&%j65o^8rC#n2~kJq_f)lx-+d=dKEMbRCFxkp7+ga!un^l z{1)KWh_yyvEFv~p%vDTUq=n!}`r;-_mtrB8?3P@-lkUEmd*t^6Ci0g&<^HHhQhdRNuLPDnSO8dL6jW}1b#~Lo@C2L!ZkQvlGpMVW@6>P zpBW;AQS}zLc)Ot!NK|pZ2UlX1!;b((i2nB5@iymOW6rq;f98-_;_xFvMN_h$`~Q;m z9e{0BSHrqbPm)KLr@S>Sd1?<&dGEdL*iK?QiJk52MWzFk5CRE=kdTBu11W`%Fxrn% z#@Et8OUo!7l$N$Y>7Y<3*n0lYz4txoNtW&Kmo_0d_SHG(o^$TmCxHMBL0l}F894nh zc~*YXpZ=J9%E!%Qu%T!rccn$>s0OAEN{Kv>3$hA{T z??DM5^E0q^`zMeV@uX*0EdDY%e??*O>LToR7HO6jIJ;C+R`#{2gCb({yS8C&M?rp% z#k#Dta@Yo2jMC0ecpt<0ZL=O!2_J9$Gr(33k&(_B@4>8r))~YPOfm&-FOvUxwlIJ4 zQ4zU1BSfQeTz}mP-k# zWEVyBf=M5w4TTa2Oaos9g!ocqxv({RyalQuw)wF@J9>sS$*DToaj62voc~^}AKY^N z1VgJKyph5U;g}wjMO?Lkau9&O0v3WMLt#WzbZiVRjMy;XtBdeH9$b-t>$&h8_*H^; zh$8^h7n-4BWiK z|3Q-3qPSv`oD)TK4_*;TW{L1lg$pzhg?i^FN{FCuwvQ}0=J_7G6(pNXPVv8+bDMPJ zHNtTP@oOZF4~T0;Y!y91*Ohb|rjD^kVCseUuLKRVIKD|DT3IU58>GQOxfjK6(DY>% zPr)F)cL8uJlw>(~h-Zj*_Ha{1NI=7xa}Qo$(H;uYiI9Na7KWZa8@;}JE>KCVXp$A? z7&VKn5fN4SXmPN1nFVB4;p?zUAr@)}d=3(XV-bA3iD;DB%}G)J@+{#NXH>u@9QJcE-F;xcLfseVHz(KJ znyJ>pNO13?%xj`4@3qb%huM*DZS0?#suFMojqyOXsjIm!Da+wACQFMG!f?zbcF9D@ ziSPbMDz7Q9SB|$HjR#;#{PH=>=lSuS)m<0s46*CJ>4qyJMV+(AX?BEm=qI;}Xam|5 z4~Oq)ze4(?hnNq4QD6^Jc`*G9i@Abs93d{h!cIgIjImiAjrl1Rf-|IH=(`VJ-?>G; zxHxxy?w}-@$sG^M!v1hZ)?S-cwD7;-5FF>|;W7Es9%{s0<*-x&oZ6sB~MvJ(ee{qWMRj#z-#L@Es019X5`WzR5h zdG{XTi@w4y@zWzlLlGNX+`0IGfAGH44#k~eigY2UTH8IDPVfOQY1X;>WI1dy4s3ld)m= zD!S1Dk_6s&1?j~a7Ii_oz&=o<(@~#>1ZAsr8M@S{#qmp05+-27Lnd0pZKi9n$BCn= z*MlEJbyG6nhC6krCqv#`^6v1Bh9NboxJ*cdBGy=ZIgQYa=ucRRaaJS~edSyG5P8t= z&l1d2r9RAOU;N;w1NH2L4G`%X-n+x9s}WOTag;y_bBGNPn|#hLt<%LhvU+%rhhayk zxFUy;;+tQ5=<*zx8!BWk#gvi%SXeL3tR@>V<|fVUY27YcYa(|DRTLGv@PcXYG`|+Z zPaXaphLzKi@pMPVoD|Zgr)vVbI!@6=8GbTR&Vi*>c&fS)I-+6dCynLJL7fmK*5ZeF zGw!9utKuW}`(G}`Gj&pSm`s%ZgkNar{f)r<_$dy>`?&J@P%yJYE&@i;;i+^+@)G0C z(!Ae6)GGx%gyV;;hq+6z#n-2>i_5Vi52gD24yI)4graixa%?^l%x}OE>avX*OCb(a z5TOoTnLSS8^f)j31Kww zwgR5bV}NR2$XfcL45e$t(MdtI#@qEG)?ptPij5V!L{IcicQcf=P35sK`Kpb*pZVT7 zVHt*2?5`SwD%t|=&gm~nr>YAkR6tD^;rCE^EFCDvAZnBHE}XNXrcYq3Qq~!iqC!sh zVm}@aHE!2pimNtfZUXKKuf zTf+{mY}iy}&dyzQ*sl&yO>Rf))HCeh!Ao4SARUh=6H^ySS9d0+yK+q~U1IlW{+jB7 zr76kcG-5UsRz4|`1{{NnW%1m}RNOHatOsZ<3^wPmZ0o6PW2eo{obZYC>RXcRwcD=h zV&fmZj+;C-#_8NHqb*z{u7hpb8@E0Wqg^tWqDJV|GioH{1xRDn@X2xHr2-qvpHIfN zC$S=79s|V0iAn)|Z}6K-(gkF&%Zd}p_D1~KR&TpCB6>|7H|}1|0T5O6PP zQfm5_Gy@P8VXO;{Lt>4P1a<+{>HG(gu3kS8@aAoTJudrUL2~!eMz!JVVoZ6P_jIwP zuv_~(4o6zKn5vM*!Q^gdfZ=}SAtu|S9~khR0v?nKJu31{wk-#uFi>+qSUMVn8Mlm zth#%Y7}9@|#3J}XX-N@Gb@c{c*DJp61uJ|0=zB~m-ui?#dwmV zdduD}_IYSju{#{9>;2Ckb9Y^1|W-==yNJu zpU^7A?jY|%*KTz|f75zb7klm0q(x4)yl}VK?2IL7&P}DqQNFza-=;GwDH3`x$c_5O z++aPBCd0bWPU^LN`pD>1f~8E|-8j*}3U?gwk@0W5wwl?s%T~GkaLZw;|L&vem%@_YUqFvYMf`-2ZZy4yY_d< z*_}kafgyQWY#OiHCbLyEt#EFH4@io@szFdP=2b)&NlR&ntxRyHQkS(xqzket1==lEuQ+mul z15riA5Pfs?*&?#6uyuu>q)wpKqVK~C4I5VwC;1+psLuWeCaP0Sgr}Bgf)DQ7y#NgB zo7U#E&cq16=lJ%CHq_$>7Dp(Q($9R)dgnx)$z*d-d}OEatK-FDFf z4>MuI9L3dn+@}c1#c_^{RfhWqr>@*rF@RyNe2H-a|&q;XPAtSrb z_wsH%fe&SjDnCC|^5Z*oPwHgfAY?u%HfVWT{?@v7-so7|=@%&?)93Ytd z!kZgkW6r5fEbI>bFhW#du_DJB3aOhQOsEq#ZxSqID*=lnz#|Lvoan8b9eBMG*o0ae z*!pqGR^pelcVl!+iPg^Y$M&g37+!QC>f5G1bi3#c9qx3`1nvWN@U*9oKBknmw*gd6 zu&Jvgkm0_9*K{Va{jX{;!0e}?AJ?vROCmB=0uJ(rzJ6DP!_hh4*%cj0YCl>N+)I?- zDPH8oB|8u<%Q0SB^ur*@eFP+!-o_8%@3GYqV$;lQ%%q3nO1}0rzykas3D@kpAuKFQ zXAv&u-N}atQm-~7Shxq24Oa9SUF}W#*)Q212=WBVF*$PA4-A`ltZ%xx$Z6zQUa5vLm$#I83He?vf$R;L1 zC%d=3MrFlM~Qa8onU^50W%$+d)_i+egdv0BrxSo>&j23Y4fcw z!aL5r;4&KQj&!4o@+JEr;D`Ib_*qDNKL_;zFo5`S;$fyQH6}?y7`Lebx^nm$ZdGGH z9J;V|eD#1;zrLz{XKBfQKzgjNu#c%pyn90I$VF38Neho?y?JX zY(wD8g^=t(!a%r>)0b+Tt>F&W`3M5Ni&THP2UO~jqMBW`<=g9Xl9N;NfCHpqVYcEP6Hgg`ZI4QQrPN8+gevZ_ zQeshk$l}SFT4HCHQqAG7?Fr&uei9p~3pcU9#bIN;zy$B}Hnz1}ReON)aKlDT8O))W zTEzZqDp&WWLW-FBVssN9OXVU&3Z6DiYg7%Cm+d*0%|z^?;ukC2jUNk&x-)nj0(^0*>By4=t~i9Jc+JfU{}x~u{@p`%nz@&0Y9=TK6E&J;ZoJU! z1UtqrG~>)f6k!Erfm8c-Bsb#6V!ukCsc)tjH0llF&1NhW$`|TV?n+KA<*^{|68j}^ zEyVy&W5+dV0Zo#^qe^rfv2u)YfQt(oK~U--;3T}RqO1q|FKqD-(N**RPb|)M?>IPD$(9E)Hgvb2r;)?Y&eKelPws&;b#}omb2rl zEN!XU)nydFw$1ANjhyGi;I5ye{+{&J zdy^B>GbobzHeHo2Q-M*;KnpR7%BV$*U}EIz)oD5y(M50WR^UIC@CNvEs{y(Oya;MS zfbRDdmj%B8?5#uR)x)L5!&=RTIv$lR8l%>GHTwW}vb`g+p{%~!yCdMD;BCF2&(Ldg zY!vVU+oDoCwiTLpFR&Lat)6KsK->+mh7Ljc5?rBI5u^(+-zj~wvUoufn2%kVS5dUR zJ$6yDwZNQh$~l~!lWQrkCNGLD9adHCpqN#TYEv4rz=L4Zd!`IB*W^cmc&$s?)Ly@( z3|+@~oaTaZM?!+VBH!ZlFxMeVPANq;Gd(qpAEWhXz;j1$Mj;10adlKLWF94=n=ydZ zBafRkyeL=`Jd)&J0Ta!rT^oFT3OV)(OQ6O^k)bi?&VzMqccr~ES)DQ&uTVmMzqy0v z&%y$!;JpJZ!XsM~G;|3AofO#PT3fquxxFum{ll_SJ5YxG8X zeHpq6oc|XT$XC92rqiz(r@vzV37XLgm3t*%-GXKWFt9n!dxn90>30ExH*WD4*qEeAh{J?;n zTLNCxEuk8bZVbqTxE#iZ@Z?OtFc2rIH*is^!XC_W?7KqS6;5MU4=F3xP)z#vr0(=K zuzw|OR$hk~eBw!o{J&DSgW^zA7{0q4$`{J5VFAJ<#r?6cs}Wb^Q9Vu`Cvh~6*XP7F zwF~Ux+sF%d3})Z^i*w6!ZY4*jH{3Fb06O!@MYACY-hQ zPDbm4ef4&M=o~9{T!2Ydl9P9%mg?GWZ>0zqDDfA{>VlC7QAr10h{QepfDGf{g4l_; zpV9~~EhNP0Q#1}W~>sQ z%!?|u0flD^@s1=AfaQc3n5DpkU#uKRM#77=IHrAjF}p4VM_yF7n<~2FS$(hf1L>~G z+k7|Z9{^eG^1oZIVtBV;0A!jnG=HWE?-=(Fo;e9`vabLg@LYRR;ft*&!F#__WI>hV zh>}l(i=>WyC8+W-kV)sLbRnj}5qy)liVK$O z;cSHH%Kqqc>bIU)v}4nnvX!m_!=>E)FisMAzx-!O*VW!tqQV?sYqB*9tXaAi1m=09 zoD=8`al7}}V*nT4iVT@5e|^U6WCzHwGjAY{eViCPsoC$(7Yr3hw}}8e53c-oRu&n! zhcMF!c`3cE=a)P8m>i9bch@fKu zLzDuRQRa-Eg#gt#4@|gcp}cd+6+uOYTX$E?4j7IigTa7jm!$EYZH3r^4SB;zaB<^g zd>~vf$VC^;{z_Qb&4^j@WA7#P@_cY{y_1YIvfg7$ckqtwRuMJ9v-OPEEQl2Yo}K{? z?uoY`(9@FgAn|L}JawV^4}=KETlJ)Ks0wNT19z;k97zKpHm+o zMyt>N#d(15lgSIgH>mKnyw2dSE4smVhEB_Gzi)5fCNYBSN8WE=!3`c%JauHzfx$qG zX1_w}N6B`>E0hU$SVS#wV*dGH4|<8<^032%gAzyst2H4VBlT--5hu!a4`0{|GCbm5 zxX&-j%zsoF8;AFLhtW;$h2h-)o)m6GTWBzmCGDgI14kr4ha0qhR^+1*pENeeg-6uQ zb0V!pHv$$8@|N~PbWrRM`jyYD$naJYMu|E@#JY786{Vp5ph!uH&{P5JQMKebU&d;Qpmor|K=4 znc_Q^zXKQ*05-jnk)Zf*AU3n!vmk-69yjQwXEUQjXv^OTvZx|wT(-}u^6nGexAaxM znPl>}0u{8vea~zr3BGe`YX#i8XdE%$Od{Mokp+-w91Eb+`a|`S_@tXpSpYRO@EVIP z91-4Fln)WMj@<6&ZrRbPVRSvWow;!6(A3Wayi$cffO|j!iy+2ggy4-9OdSDaUJIoG z%!vSX4)#ZBG)H7P_%c{?_m0TY#5Lf=V3e6>ZxX@YrEg~c&}is}5MtA&$({!IiXp3r z`|JO|y%wNz9I0%>)5uAB-mg5_F9a`zkE`)s%A#1v)U#Vfl>Z^Fay#&Zs>6g+^xm~T zn)|(z8BsOro%l^SsCYYp-I97I z_l2}>Cxnx@DD;F7Mf#@?3!#?;x~qKfa-V3^A)0i8`>QXE#B)B4ynH3w3%Vf-V(b;P z>LoCaM5+aZXf&NONK~D#zyL6ynjaUR6K4|^SWvG8-Uj9~1B8>#KsagBL6OW$7n9xX zB#6X4KBU*eR`+wT)%|89=f-$+P)3Wt(x6sA=<-DPma*+S(Dy(YG9PgN=PXudz?gor z+5PfC+H8ey1bSqK;YKn6FYNylxtJMI!WCb^B8{&Eyee#514F{GMICc@n+CKum zm29i`x^nK)OQZ&H>d&GJLGBG?a)0wWyUl1xd-kqcZ|K<~iUkwgQmz%e9ji6cf(2*Otp z;PT%9mrN$%{jh?SY1+|>1IO5i_VSNqQQ(DbYwBbgD{M6j!;e5Vjr&yGmPDN}b543D zzh4p(01yf;taW7d5BohaLU|B}9|5e%Gdk9M*0=yD6tMD83lQUiZlM5z{Sm1Mt{>Ox z)>U;MX&{iYznS`=fx&;|-fHSZon_2$P+_pcVsXNnTCxRm!ux4Yby@;c2V-c9tI;uE zfiRuwB>fB^P4w59V*$m3DeSTFZYZLhQIsM5jKBm%80$|;Pj%R9i?~ddg+Lq7uDQy$ z>}$uEbi*d6ok47MInI?3Qo(R|JWu^5X&HPb@Bc%#4Rr9V-6lGsFfcUyb~dUwFk_gSKU7UQY!_1@yC^P=4A;^;7Z~_49Y+u-jeO@%-QoNqCe-n$$S^kI_d5b)w zCHUR39@dv7<}ZVZmy`b|hjI|N%bWw-9?5E<;^0k>*XuI&jF{X3c@B7zTGqQt>|2tP zV1@536BFD>aVG5C%Qd;_YZQiO^3_2_!*aVMQ|*dR{3h z!kWI>hR=D)GRMA8tZBcJHvpB2Aci;~&`79s!dn6GBQ`%*5K)_NtD?MN_*_3qp-tiG;)RQ3Gmu2~8kJ^jFZvSdSBNxq>#!`yUK>8YfA#9N6^W5X zeNMIz9u8pk{Y}Fu;R*4o_^A@vud&_84EHaK3X!Rlvy6VF0fqQ5tu&qX_d58wT_JXr1~^XmIv72 z8ak2v4v)k}nK0Ex`d!eZWM?M$iPcJ<^b z*;*p_v~hCJp15%5EV7c7X~)}HDZCGYCxz=wMU%7U2a~5gu_+WF+f;GE?fE8e${rj( zpETaG`%FZ1q1hBl$;Ne8Iy#cu2Qt9>|q}Wa()@1cj-L>~# z0oqF<1JR~?k;*SHuW`83psA{!Z03U4HC~H!_3kSs#InwK+@&WnhKc;W2YaPIfIVG) z`SaDbUXfzN<}+BAzL}HK3;whiOt?k4vzU(NeVKL1x|M~7DOR=s(q#eZG3(0O+*u68 zv{aR*6|aOL&|hZ12IxVb`?Lp!o}W2+C3;;9K6#4-@X7SavW_c)KT-@nokF>$V_pOZ zPs)-2emm|o^T)fch#5%<53U)B$IhHA3Fpi@*T*XJLMw!r<`P}9w?>v7u=lmEsVJlz z**y^}gmtXcPm{L-oXxaLWlm3o`fpeC_K^4AmjPrS3f)%Ju_ijwkTxq;8kM(7J~Yox z)Bfg^)L9UX9GaM*J-xK|uNv^g)r@#Uf=^3em-I?dBBBsfUL~aHWYr`uSGlni$!0U0 zV>`+WRY{sbT#7n*x2%URMTHItT!M-fIV9+cHdJL;XTc^VSr<@_`ZCGa@!q8Dub}@L z=(Kr}vFvXrn$u{b+8qR)WPC(9ApSkWT=-X-@L354L+A^O>!`4HBo?-nxFZ)#t&px& z8zB|so5JOtb-H~uH3}Msq2O4CB45-;r=|(`@!Fz;1PUNB(X~n z7!8+wDulr2L#}ixO3si8OG3V5Ga%fmVe>`?#!o2ok*%FIYQC)qk^0mShyp8S)+MPr%s7x? z?4DG~i|6cgE8SA(ul6BTssj2Bk18!q6}as+Y$4#jOtMz2MP^qb-x%@G*BiEQw(Gr8 zI#|i=f4w*?ZT{PzpCB{&g7P%jaU_rO-)dNK*^|sc@(h)$Tu5dz%%*)ny(Xu1*dgyQ zd0AHFn_`6-99KK7uQY~sSsb3^WR*5(mKBL|f1-#3Y%(E6w_dP9;BrEFWWM|rwlnlX zt0%ah-{5VD7Deo2zX;{8HSHR0t@-MGg#k87n06Nx@9t^e>6w!x8MVpU)g=YR#V&h! znPa9KSJU6nh~2e~W$Q~z)|VBpubP!eX{lO0cTa`MTn4?&9&9;4_TnX=PmNC>&)y?B zr#|Dw-lx$Zq482+7Q>!n2<_0twwLAgClouThGoAb1HXti7S+c>e`HtYY<6^>TTzi$ zPG)`)i}NP-LBI#L+FnUUV}7FnuUrth;LGQTDd#RuQaj9{bawW7S4K`x>(n6o%p5W1 zl$?YrcL;ZUi^@bo&gA`MUj^)Rq?(6Fr@!XRCj5S~ap3C8W@TlK*b)r;7Z zeU(piSb9`t>)Ushc(%1dcYwOf0-Zvc?Auch3AIn=vjSnJlLWN5v2vd5sCv#C?oTvpfZ{i+BtVFlS3WXwe88>+I*6iBETDziB! zCOSITE`$LUHP4n?WQ)RexfonxL8tK%GvZYX!asMP_Y8`Q-n@X&{j8hJYu0N@M<_al zgDO>zmA-XTu*iI>r?AjT5t$=pY|Zsh{4!x&8UMm@ODl3sr35jW8Dnt-2hT_3Gh@7! z63j1xT`b}ewOE6*8AO9SyHW*q$y=(TN#d#Rv-#d;9$@rX;N%p8mS+^4e55K`0MM5x zrjyWblAZ%dozO8dxAck$?{jXk)|SKkF{-Vx+vR3DLW}FF!wWL3bsGx{Hq^Hi#Z~6C zde=xFJ$UK)jI1Tmxhk8-V=d5zNCl1cMtL@1j?YmhVu`#XIWa?-2!t-qmOvGF#q?J) z+(VWv>6eU3Br!pK63{RKCb&O%Ch$Ifimo7ggufkI6~rkMbJzROMq#)O?OZ*6@Os=j z0SWH&h{+qP8iVe7X|uA<>gl&Q2aEKo@Fg&DBim#-t!#CAmf5xpI~tVStWHS z%RnnJiBD&NhssD|reBpVmCE@ks{R-j1ZiMtPr5QrAS*W zsYgmm>C&N_;+ovHDrUn2C~IXzTzZ6SBF!3o^gAuwfX0VR$SyWOEG6L*kVUm>(U%(@&^F3p!U*7P<4?ShhkqWR`Gpw5z z9qNaqzmoZA^3kSnwLVh^%v1^6r_wES)*{*f3%7c5otE93qR(ZlD9&GMxAwSQ9XYPf zKIoyH%3u?0YE>@EQE?CF;>}5TZxu_l#sr}~-kS_v2H%|i)R-j-f`s{k9OF5!g55KG z;V|y5fYSXE?)Os1wB+z%?vp~O5>e^(S9B?@w4q{nwb(i4^Vb6&;`|S>A~Y{L|erp%sc*t^;d!qbj;j#I5s12X+4p1(i4*nJ1f4~9bKt+ z?XLo$T3}8brFBjkSUYjg5dWLG4 zA^HEFxc&(uanr98&5dUvLWPDX|A5)g9ZKW^v^B^Y%s}BIQdo5>n_R9=Q(a-((MMk{ ztDp)y%l19L!bUw#olXO5vW-M_C+RYBTdgI7F^2Kj(;0%kwm0YYiS;!nt9LR{3$yj< z*)Zjb$k<`vL_v3#F^QnNNjHS711t^`L~!`cWpl<(vBkvO9!@+ZR7SoVp5$mi9Y6Qt zhJ5K0vlMJp4l9e=n>M(+WGkl*rz|am>J0A-=j{>i78Ige=Bv=C_E@U+w7_V{i#b*( z$l#tzSDooCsqPe4WlX<8u(Ck6Al-~RYi)`G2jlt01k@Z1jaR@d(hzu=nA2gmKeRKu zJjT;G3uZr}r6*>0=;D)GBA=RAke_J|gJrpkbd(BLh)@GC>-P!1e1eZn zj`bz0i;zoiXyEpH+A8y0Ww(~?Ze4j(5`|j+Ka(pc(9(mo-tTeiw^VuLPRmp~K>>R{ zTWcNbTNC0EtQeazN8^?f0UK@-Bg1{#QjM}Z+Zt>YVdWn%a-Ap9nm08K$P_gZfJ|yeAu+>(xWFBgF>{T7#w(WR)y(J{cK~lLlSscf~lk7zs zK*6B4$6_X?0Fn8_!LVWPT`6~C?L9}agiC+jMUOKVOQpRg_S3|O;`=EUMI!WM?d zZvW-3mPK6DSLMlwc@re_T#hr}m7D8Cw>n|7rpG>3!c}Z7aS!G@x|7pPcFHL~YIW2+ ze1}~csW=5f`L+vIt>$Hn5>1oFW&`~3(C0+w$ogJ|V2uL2A*ho8u~U*lhUGV=6toc# zi@cAgv|G6qyyp07M&&|xQ!a(-F@rU-S}o zx~-IhtEmt^QBASItbDL;=Z<)j)!ke>?h#PpenL=c1SVFswA5QG!t^=oC=>6ja=QtN znCjE#3DuLq`^9~FLZlnB@(e}>Wj+V#J8JjcF)(mpue~n%is;|IEA`CIou^}Kt#e)i zd4pJ7W2q!l3c-=2RxGvYX!aY|4uir_IyJf|?APKYLOe5nHgf)&E$fPxrl@+Hjd;2$ zJNePuNPSJZO0DJYwnqFizW~#a8Tx!=ca}k)Ng3kSTRBdXnW3#Qs808kRMTEJ`ON@@ z9wZFU=Hn+m2H9Y90~Ju3Dk!s?Njc~tFvZ%-zY;?#zxV4p0aE4#p*(c*4?dV7p~08Z zhJ+nP*ziT8gFF_LmUyy849J;Em~M@A!wfp|zPXQ%={P+*UYIseh^ffBrk;8mZ6(c& zT#FB)cMF;`tpWu}8{;AVqY1D5nZ=(SCrKdOM&AU|X?7)_j++-7OlgBfb9_Eow3MH1 z3kd?jUbYk<$b}ok(hS@_r!^BumN*UOuOPZep9r1vU00AcP(b)?-Q?kS&@dSu$t~w8 z6?&mkQzmb@+GfD=qDHI{w)kS2$S8B{5$eI^@0Gyg>eDegP8qQ=Ugd&em zThboNlK>soB6zEoXifpP2eDTYXctl-LvBTw3A6m9za6G|L#(q511`U3a#>+}DW_t# z2JJkU{IzLe7{+3wsPv!jkE!ygDIWi;57=oim>eI2QOe<08c@rZ-48g$g4V$^YIzH0 z1|qn?8*_!=cLCL%^cmex1iN#$rerxG^^M+@#WwDG=59fhyQVhdJ>_mUz=Fi zL4b04A59r5foziZi8F*b(S^X+WNir*XzmS@9YT}bQO7XtE8RR?q0%{|y8v{-63A$NypDMfu#8TXFtZ&Uk{21~$=;T9*LH|FzTAXdl(tfY7i23A8f)#?I&1}0s8 z=yPRA{_YKea|Kkp_0NT~$ddt<<<%I>U8KTEtQpM9!AKkY)?g^4dB3KzZ62(d@cF%) z=&h}D;@u~BIlytSaRkqu#nWEegDdMn<2VS|LTx=DHy6VGru0~a9+FukhKyeZ?2FTr zz^Kp*@l^P;VvR3Vi!52WCO%#~lLm@CU;op0^U}?^MFUvWei~nGL2HGcvCTeyASvA9 zb(N4Kf;r&OZ4jChxE~0dusq8JG6_R@xyO9+81Cl|&>0{Rcy>TG*mk0=y28UY4_&Aj z0PD|JR4@DS$nBZUk+HgM4HKui3p4otw^QSZRb||-5*dZw1Tnv+Ebd}&9aPiTuT{tgSNrdJM$o3vi7^wdmnFFJ}EYswtlZ>;WasHC@EJKVh{+!atsPcyY!0oP0+ zi{r0RpX>H0{d!GcQzj1SWTsCS14xk7~gD_6_|ZL>7d#=+0~l z9^6jgV=n-Fq*gB2FNffedoCz(?#8!ENt)&J(;>PYxIc*~9QND3bxDC`=0RJMsA3Ve zBJnU{4Qd9-B04;Z7k{DFcP~BOhzB2AiFhj6^11i3q@HfNSlE8WF$tj_! zs8&meuKQ9>tBFLL+OQh;r?jpFPT%4b1#VzX7d_tcBQut!Y&{|6ZV!fEeu{2T8A$kj z`kK<&m#6I6lNdJ>A-YQictfxE?@^)r@iNdJ$Li_(3E_EUz?uxkMN_vXl)lD)NiYGu z#lAdp`k9}iJ+U6WwI+g#3kIBhbISWk!ZYg83TJm3_IsZEA317DOtt3D1QYK(f=%ve z0_AN0TOQOwbn?*2G37DeeiIfEv@3-;K*7pwM5$J-a>-WEJvv)Ygy0={h4**)?Vv`d z_7Mg`_XHX&knK%MDRR3#SMAvoik1!rHUjdPKq6WC@P)+jmMynNarXz`3GGf|wKHNPrY^vqK>$Hi6}zVJRvjCF8XR?_R>)Hv{Egsr7&|RK?31XnA)F%@2~^mu%A^2<6S<4I1!Q*5>s zrKYE=7se+o)F#$LO&>O;=^ekv;#vy_R9K2)cUNdAh~_B49ZS>vb>c8SY35tO9)qgz zH+D1_xVnT_1FFMecv4shfqSdn(F&YNZ%)<%aOV0eC;fFS^Su>5JsjA!E81#}xVwU{ zM79F@cUL96pWBVb2TR<%naX!j5I4rst9*8IV*oP6-w` zLcpPEG=aM|7*zHpFOzWZF*GgODp6lP6SP;#Y){ga5`?0ECNLR+rat{jLtNhwDjbN& zYmVctnIA43kBF#n%mo_tTK)~xDgj&e%647M1#nz29h*Z3C>mD9b9;g@kjp2ZPk7>X z?9%skrqVlZG}*M4%Jwv6FME0 zn@Ui?+COUWygl{zgy&QntMGWJzc5PicqshLLD6~f#_Evw;4FgSP}~{Oa3~V1`ck$U z?gaC1o>03iL|f*SKa2$qs^ch(XaIw3wNQU8ov9LKJExixKE@%9A?EQ=tFxe>Ja$P) z4D`NfBxJM0mkJz5Hv`-_W7jRb*4RwqBQf*Xns5uy`2_HX2+)YoQDpn$G9$ZWGcQF^ z^!0TKh{3BVmobi@FpW2BW_V`PV9-WN^2&i22X3H*w4T-gqm6kzDFbXpTZH)9t+`|b zvl)KO@CEq-H!>NC*932sqz-&MT_VZ-hG`SlNMg2{xjj;VShOrsur2NfIBRI{!j)Ce z&EvMx87w}Dv9lk{T139Rh`T#j)@4uO0W511zONc7!bNp+mX1TAc+^bZ!yCsy?#)(M zkwWws`zYXurM^_)I$|SUvCIe9gY2U|C!4!B7<%?OuOi{;l#vQB1UUwMKgb4LUpW(6 z;3Hc;4q+|zn|)OK)&tZyYRPM=kh4kV;wKC?{JlaLR8l{5fxAJiPSc!5<9Kmv2#>fQ zZ!5bq;bZj58RcV`l~D0kv1PMtwfMgXS8+e6^4PGNEiZt?F7_9~nO^|pP8`Yh)$-Cl zd5Az_$~!?Az;lRK#>q+HE3FgrRqJZv6@p)3(4jDm(dxeQ#O6dpsi(LsBgN5a?LOX_ z@5;>Ss{c0^&U`S+UG^-9jgE?qOhS*uE47OvA3VB!dv#aB>B74Df-`Y#r6oPtXf0EJ zY_MsEKBgoyue=VzR!^a4;}R3&o<)R5Zj#}i3KQ60^^`~ac8$>&Y6{qw3hI_l(VxZoI`i9quvhcDJ`+!^;_j?$nrDR<5_?PGdvux06 zu5y}SVQNaxn*23Y1^p>8h3Ryp1zD)t*ebSl@LPA2tQIiJft(PXQ6_3kninGpK?GDS zj~EJiF>1++(Y0mqpR!>AY$%laCf`zi62AqOF5ZU`la_>fJ34B~4%lFnxbfnW6Hj8a z&=O&w73D0A6vy*(1c@NoV|X=0eobhm0!e^ZQn(~v=2Lod>OCy2heZ)8g>j{Ep@Jb~6J? zq0oVq!V8>-d2}WB@l$GbYO+q7f)QGhAP=wFQU9Cu%H-yPf*KSblW7_5^y!7h9qB&3 zz_sWTQGy<6lT)-pt?ojO0CT7~P_Gt6 zZDrph(Velfv_5CWSfVU(th{thaq*gxBV|&}DyR)l)uv6Yko{yDow^`xs;ujty3_5> z&dJNmLD%KEb8_6S9IUCq70u7gEq1$$VWD#M+Wakr?rh_tGAnLOzCV@8t6Ez9tSbk8 zEH}sL%*llx&%q9d_g(m{m0bw4f@oD3IGw^Aa?Fbuo47dCI(&Y3bmXQRM^1n5CvQAM zynkkBBCM*nw<_Cx@YJb;u~e5aTaT;a<5l<<^TzVAou(G+LPc7(+q`@!{$g5MJXC{aNpmIdOaBNJio1~k z_zD1?z8P-jpHfb;7(R~ztI+X{{~P-HI(lVCnM7qmGV?)4=ho3ajXuNJ3UI0t&0etO*IJ#h33H4jov=$3QWn;z$Rk;PW z`iZCG6P59u%NtjyV|O5=%g`iiRE)H#5pR)dC>Se$5onDs0;ZHi1A*UQ6_7bo0<9I2 z-HdYjGoU&C`k&zIdiW|KnhR^zI6w{$iox8Y(~|cdAjehy=tL(vCUvDH4r3Hf*qdNmy!zBd0##<9jo#w^I_tr$G%Ok&ib( zKC}$vvHVmZU;h()9dlx6Di{b^hzzM`(t#Hy$@J1iHHE>X@CnwoET@FQp9Qp7NNiaC z(`M2_^l^mjb5Mi-Z12F5&hlC5;e%nT#UrK&XJp=!3`jo&z5pr56p`FD{iOtvuiq&B z2xukCxUh4ofzq zYtoISc`^G@OnyND1RfZ2?j`BxboV|Y7Qg4ApF`Gd$!5#vb!ACbX~qZJKt5)SZ@!nEt7uKU$;ns z36Pc?wLl#wAC@aq3Y-f^;#>M1RX_*)xtGZ2LPbLbr!BPNd{J2pK*3`|^OkE_~8C6H6-m_g@&8;CAt0CArlpcG(5LK!wT6PhBpYgEvV3qFuk8N@1}pX8$7S9>epsaN!p@|8?Lh&^Cx__SoQ$pp0e1 zJcsHCnWIIY!t+;cJCa&3bu|Y6Cs8KDjK^d0ci=Np=SO9l=d;isDAvsACZ6BoMW4*G zT$7-M{XC~PiC`d%cMq?30S=tWxE<~}4Oc9Lps1g_#I)6R4|J^q+OGFxoAbr&g?`Ob znYHMT+)F>#7_ShxtItPlL_Ybu@X2^Dw?OM)-2I=9{{*~E>0UwETM-fjp2I5|`720E zUNi#^!sS>3cnW+-;DGrZ0XH#&y=H(Da4XmI93QzLBwRexH~TNh$Mrhp31kjv*Z4p#tHz`u#pU zwFrRsX&earFAaKKeQeXFHN7$F_{C~nx|%zgrbkhjalS$LLy zp3g&dhwk_zk3pPHB5K=Wp2>7%8FTFU{fA2mx!)gq;s>5m+N_mjdunP3<#J0JBGl=) zPpcwRovvNDXUX7D@zU5`CpL=uv)moI1L%h!qZN!ULzZCEkPa%z#FQd-$M_e59Y7h4^ z?>z4xOHD{hj2u{4Ra?@)Br8XIDwdhYq>U$s0~}=xEhvgbU`rp?Fxzu(j8!xrTN=H%s6Dg2jcTgiBQ-?Zz=<_rH{(tj;lvpS zmS0?YX8)?8UHp0d4{T$@nvV@cFX~_3)vnEA zBqz|xfA#_!-h9Kd=tawxw{_CPj^56n^$Z&^_gOc;Jbd<+>nD!VvlQ>V!A3M6UlFx% z#fsK$de*VC{8|5EBcbvXzYmyf(753z8bBot`}i#P(y5#IgZ}VGHuB+Hq85I?wTB*a z{0vVmHj7;#Iwz3&(Hg1yv$GFBcK$ zBM?0RB8_yF_ssvieAStHmK>${0x96EGfNh(UZJZmq)?qWEkJcU*!%c2HZIOc%e};> z={3?@kmAe>Z(Vn96Mvj!8YQv|A3C=LMUD;W>x$@sH{Z%b_e*vW;W9W6Ycq_d=s@5y z>5C}l_MYc2-16;KdZKL0e_mr3J$zwtWKCa=zMemDWTKLuC|kfT7EZ(v2A$|~>Fv^g zpwzSdKfZY9cRTnacOdCo?Ba*-T8tuU`{B@H3gt>Tls~l!{PJXsw@4a9fRbY`q0~KR zm;dVNM_%p5Gq;C_WxLVhKe9_&Pp(@WS=XPdZ}6Q9jj=?^Wc%5udCz?tW$r&a^5<8c z{`pdJ?uhIvl=M$Fs`Zxjiz4a=bJOcR6yDW-c%NdU=RJ2CxelLO{jXoV{M!Nk+=Iw4 z$ws%H+PE;HVbGM`z@IznKlh&yKM?4E$*T{%Frb5m%|PYXoLe`I-h2JSA^zYa$cn<) zn6^{n3sHFEGP6NAdQ7-Cc_te>@5ybb<+|H9ai4$k+s{_=Ctrh#Q5+lFcI)PaD6Dxo zoLoYQvF1nxrLlaNjq{z1nG9fN1Mg15?nVPQoZrHI`1N0=(HMX9QB;dGY+T#vEepb0 zR+tTq{K;#5C!b~G15eh>Jo#=kcGI~X+^@N>KIgtz#~*zI>O{G0eA{i?7KF79SqzP( z6zFwuG!OL~tTO0q^$e(AL)&h-eGm6j?vrW6eY}w9%RSA#!Ts-5{MqNxF|?jd>NvL-An#gj&k!Kr1c&pd|AS5Tojx1nr_d7*TsY3% z$UVfp$~}I7KmBfW8tr70JI?P5mv@iC;pLPp;{xPiMmA;Mv!6rHKYacqcZfUBJA0{zT-H14$Y|!z-VA3mlI7F?L0Qb(;59%b6G?T_Xkxoj6B(&u zPsG|_k$p~neh%|Cr$O&|HBMuO%avgSADNM4FcoO4R1H6^fF5Us&Ir5Jj887yx)3$M zZ&LMd;UD~c5Tuokf^C$HBN_-lmr!a#emU)Kh|sw03i2yXqf^+KAEoR%qq$RaKm5Ao z$&?e{QQxV)AAViMy?lSl{pj+<*)#CZ*@?5az&~dv;AlzC^g~RWGyyyyyj4M>hZhDO z8$5MBUg))toYYSVu%(diprM{yUC21F4 zFVm!QR~u52Gz*TypaF?$`rpzT=0}o9plyOgkGm$KsoN^Y$;fo1Lo684*a6W=M1SGJ zrZsg-RD<>P0|WK-gUkcmf&0)QZkt7!WJNCc68`eQ@kIFVBqg)8x3{egeqHdEGB5O1 zRcf_W+_(6zRcUqb-&!5qgB~DCV}1-&0-sQ0#9;WH2@HYQ0RbP|4HpCRGxTmFvAUU_ zvY~6+c9qrCB*i;MDyvpln7dGFLV`Lu^&+ES(=S?*bq{g`ti{R*KFCi@}X_W@bDujd)bmP?zd;pa372I~|M>ibbR2Vj0Dfl^eILd2n=m{m{>sjG>e>XOV7f$ujQEM;_+h9R&82)T1%< zI&fx{JNMAce&5+LkpyrCvRjoW0}mANSWo#M{pKc>|(wYnn~iK_eakIZ z<6r1#PE}RT605~xUBc*Ief5z`ufBR|)rJkLD*N2-KCsQOenJ-JUEq94j8g+K`D7IL zI8%6s*T58F=+h+;Oe*s+w%uF`58NlV+~Ra#0uptjfT)ABPCC4~*k=V~^8b@Gs2UApRH$ z{6Ro}`UkMqb?zgZ8`inYbMnjcH#F?Jk-Z;TOvdcu3boo^lA$xCOCMl%ZgVWnEALp$ z#`IQsmb-TB%(3UDTe7d$5Z-`;+4 z!GjMTK8jxEs&6@b7@gz*UWl+Ueax?+XH9}M{$@KYh9X!oh*28G%>5v?HmhO8bYxfS zj#B9Za#M!cWHD)T6!)QDFjYt6Q!3Y&Y`@MuT&l_}vRNIPWb_2U<(Zyh>fl~+pO!>| zNvz<5WrBl_wC31tW~Ly0 zWSuVKs!eqpJug1_+%ttM@?Wrt1_v-xMtMl8m;m4Cq9yE$~5Mhj6bpG zX1QEhIS!zeW7-Q+`d8pwBk&~sG+rlS$apq_yYWpAg7DGjP0pP7Msw-P{Nl|`x9l)) zTG6;JpS`fp=E%vh+b!2FTdUGK*EG~`EPDEh!w>Zq4HrId&#^e1rfescX(Gc+9prWH zg8Nb6-_dFKx^4OZTEdh`jPR9Ibfbh}?f^FoLCoV2`ZWj;NL9KK^sy4LKl;(zKmPF{ z^0+e4d3!Unje%JQ_zgxNLNfTpZ1et%vB0m))2F9TW8V(q5{J`SZF~+> z$iLA^UN7I-(73EPWEIOjM;rnb%&aZoRiUua`v`vJ-q(AOyQfZ`EwD`51**kg2&4El`wI_n8A?4IoI>AvbJ z<~eUU0_Dq1WA29vYi1+-%p#z$ny0W%6UFz#3xw81Q*{MTg}#38M(!C@v~G8qiyP0% z&CMEr$ZXBNYCq~>y9i=&Bjg^!hhcJx2@_xC@rk^2fMy4SBCYHMSj>%C)a^v+(O!CPyGhSqaqmxJ8Uenw89wm>NsR$~6NeJ+Z$++hY2U^^V=s z4;b!$GzI-$m%gEYXhUhy{yR!HR>BwIulB6x;kZCyhInuke%I{qJ9FV8_r=AFD1zLw zhI@~Bj{6$|@(?T~AHh$+%NqmV{SkocEhn%hO@D>HfInedJBp^($tEHw6GC6?Tf6C+ zhxHJCg_E?KcJ1Gmlbc~czvEA2?uVZPZqrB!05Nui(3_uJy!i1CxqqT0x2cSgSMf4r61-`k7yhEDl zub5An9{{evi!8A-1#K_aiA5I~?;9GrZ)D`Y0Gs{vuo9=F2%roqoel@4BR_9 zdf&jg@qxij8ql0pdc{yTKXtXHQX4>BZJ-J31yBfl~%bDl1FSz1-lk!{ucY%g{Y=0`L~|b2x$8 z5>ntw=I39%_0{D|-=<>Z{W}9C8VFmhEDPU@|7Y2!ULW7~`r}Wn+V{O( zs|g?fl(WHyAvBGD;h)8rJOMuodPrjg?Jc##b0dvGpWL|r`|tnx|8BVI`|o}D_Sigv{xeMIA_-6oX<~I15F#LI7=Ml(m`|RRp-~SdM%w>J}A$p5@7Z(U2+>OqF7-L+Z zjZuR)lWO8VM<#9w%He*A{(0=!Vf5Is!|!yFhz0SY_m<3i3FZ+@ zr({yg!5N8|q8(`5rj`dhoL~-;x8-9&3Sp|a^>at<74dy2-q7}mey5P)|C#A zS0Bc6Dk(j9czJpNn0)c!OnSKclP+FN=qm)c1L;rf+#H9^1T?{3Z?_cJsDbB7gd7U1fHulF11`2g-2)dro*i3a!mSwt=uU10y7Tyw z(RJvARGR~j4Zz6#jqrpDdu2G#B8b1>;n0o*Y)HE70T9GyLis3BMC1b@Rg)FFy2(4?q6+V*q&ckKBjc$NYDL)$xJI z>iEE$0{>0Uk$%KDAUYOI5kG0DGm6V9q#O4>oDZ!5_-Gb(t=k3BL~*-Zk(!At;ZJN1tyODBtT2qP(dd2Jcb+UIF|~YzBDW2#?^W z9X}vqo8jY$hQ=f9?ME7$u5PzhRal`Bz#0au+&xiU4Gb|+eM@acMQu%GMJ=4_;l2PZ z!fUBOErPisE`SLcf$0kRLTV9Lji?m>rPYYr-g|!NZD`1gQ zwY|#O36h`M;jDymg1dEjsauDNcbJM*Do<`M`JK`j z-3By34zyQY>|wOH08Fn|40wuHw9miNvzhpy8x|d$7Gg%>@waKzl)n3H{EN za`qvqMW@!;@`_puoTD{sc86bJvvp}|yUWvDh}@%`#Em86o8jqD*Igs=p%kc1Edh^!6m0yKn0K}5xA zKoFZ&)WIlx*sT&qN5pOk;Gn2&t39LkH{IH!Jw0mM`gNLAzW=%Ry{Z>L9r&dxxpm%M z&OP_sv;6O^mYxsy-F^4IkHbUpWF8_r-B?nH9K+7kRR)<7#KY_$-rYBKVNS{79EenA zK6eehRhQt*TUo;@y;o^9vova-Y>8#41^Zq?u$xQ-mUsK}uf6@+3&+?#v1FMN0Ozb7 zG}qe^YWu;L7PP#0sBhMy=i2M31-8O_fV;eF*?r#i>|Uy$6kau+z21(v`%W{ka)d>)pu>l~pL##XGr;eB%WuOowBs`}Jz(J6=6&?c*8hBY+g9$nc9BJJtM@V1 zhWg2;c@wl`N5C}54koAO!>_!v{`3iZ>fU?rX5shVP5o#YcCx3{{S=c5re&goc_lo< zBAj^<79*D$7+^6MKx&Y|Y;VbMjb&q(HC5YVB1VtN#`9xFN5t5xo0g&2mBEg4d%U$_ zbdzmf``(Di(E83OPxV+nt|~XGv(6G3xwn13t!Z?FH7=Q>Ck2RReyXOC7P4S%ecIQz zP5nP8uR;$G$sP){i&)coRL(AfJ_0r(x+Ka)r>VOZGwb>O9!^b;6CIr2zBe+`Qr8)k zTQ!c4t@cE9)`vz$>}{VXIv8)~ccUi}%A35Cogj-`L_KjD!nfIrixW&XS5JM6J2otC zO3s*{Oj$<1hr`t!yO|ZQ2o9b&v2^u{kSTb>ecs*MK+>mPTutV{OKeS@rVM}A+i-uD=*fL zNu{NyD^!DzKwdc95nkuzVQHzi&JHeIRrRAy0Y`aKa#HHJanC&*6W6h^D0Q10Xbk2yn<%ja%Nzr>Bib+g0X}BQv6yoMeFNuWjxD(lrusQ{ zVm&Kdw`I{a-77XcK-beq`H1E=(&)8v5MGePrC%msT z#P^kWu`7uvGu?bBzW0M>&%k6`94UQB7_m4}xTkXbe2iyVRrhTHCjxSEt;NNSbKSXB zH(thR-PnX}B(t}Du@om%aTjdjuw`Z<=bWZn42qH#jX zg*?iPUZ&yqEO0r-krI7Ed*>@1(a{?BC3nW|)|NfBwR>7xch9KzEG;iz>S>;lk(-l~JJnLR03!}(ZR`bp z0g*XEfy3I!B*POMhX??PE^7IP@YFh2ee$+#_L=E3Q+KAu#H7*>uW3xpNcA3bq@^}` z5*;ZBr==vIUZ-*!)Y`ky^w9ATXT)FK;&t2HxsNn8m5JBePHF#W<)taVUn2mGS2c|`W|dLGLlo0OXzWaDtFDukTE)4+7n zjhn2b%j4-PF7C?B?JBOGKfjuOI?YqujY)ykt8I=A5tAoJ@Qa?s#YIF|RJ_=OEEIc(TI@K8+mBN>FcFvj8 z!F8pD3)SZ~v%M$1{G`Z}b+;cp*nVikhC_HFj&-n3eu*$s!SsOKE8>8eBr&5UcJie6 z@*TMo$63{_YRk;(x||aBt0f&XYzY%4#pmOT!{c+JQO_jS%Gyv*f`1%H8sT}!3Y-)z z>O(9RB4e^y<~CN$i;tPHpnBfCfSqd8#31vOxCr~?Nf7~e@Ew)YT+xXpHKfqxDantX zJUJ*RH+JGA+Pc9_zvpbq_Wa|^FL{6W#vkF6TG)&mv9lZO8@q5(bo*vwUwBiVCG;s_ zhLiQtn4C7+`?U%`g)DGs-$2&+?T9lV9*wI$#ebR6#c5D}`@Kc?T4vvpnR&}>wwf0V z{fY%m>&(wzJdLCPg7U%bT`n{KSdlwh22ggmoxa5nq7J2a9DF^3pcm*5y4mM7lMcwXoBW9AVW<`b zm!>g95bka(C}?wM;kDJxLLAXi$w|@C4t#ro%QZVYyD=@TG20H^Z+E05qTWob%~AT= z47O8JBSF0GZh8dklI6-byS_LBa2un-zZU%*1J1(&kiDf$yq2YfndP>d+)3#FRFQFK z)}(E(?teDvvHE&BqE3qC4s9(eD*y2P9os0fpENwo2en#bP$wiOh$>{?A*D+Se6_E- zL10BAtb_9SLyuiAy8#qg0+NDcHyLNNv32Py@%ttC#u4U!pG^1rhkn;fV(8x`BPpBD799vH2iFV%#-ZZxTa66J6de(=y3QwN>S#b4? z#??Jy)Yp}RtHyHTs-Oo~Z!ypl_hdbT%0f|&mB&Vl`d`%QpK!Bs)Gx}1{|@>zmFgGt z>ILAJG0VfyTWmU_r&>859R7DP3jq*BgryO8NA5x2Ph+tgBXc9SQ<@h1u>L2To1a|m z{d;k-$Xs>IK6J>JyJBJcSlG}zE0Mn1wQrZk7yhhDQt}G*TfL(6iGGV*hZxU!IUc6o ztXvHoQBLC#^x)SY4D?jLEWe_>Xeg&~%K8VDw=hnI8**0gT)u#8lLRukVQ$0Jwy=SF zcCX&ObIs1}Yj*BkanGJr_v~D~bLXm^dr4b`!lJtdi!MxwA$`cS=nA$zas3ZgDj826 zw_;(52>9h0Ao3E zOwfa4k~5N?I3w#BR8EL`gl8b?e_hN}pmI@22F0i-dn7V4diDr9|7Q846D$4sql6^| zJNdu%=5>`cr#l?!P&Q1-82*M2z)%uem{y{&L4*w~O@7Uw5bT4aEwNVQp9{ufzs{)G z+Elw9m=iU0tSxV5Sx(pVt~c(M#g2#uZfNh56g69XFbJRR!qy7o8c^uQ!PQJ ziDBkQq^cX7U9Hjh-a$)rP;{X)Iz85E3yHSnWDb49LrGdiG#YXHIQ|ZJph7pksobO- zJT{hx>-6C9vwnL1rLX)7R=uwtco};AgUZkRVAN_hfy9NtfHzC73b#DaB=dXH5Do|$7-kg^Sl! z<}Qf*dExEVYl}~@awNRQd@IrnRc7Of%^WxPeK|rlB0OW-O1?=`m~f8R%85Jdh7=f>uO5@eo}z zNrieR>gW7zIs$TIxf-aIV@G2JDx^Zvs~4^bdYs5sSUt_YR?pynp&UD41oX=i#GNBZ zyNLatmVxFJTcBm|9ZRs%JZ2NuR|1Ry9$zwZN8{{W^)*{&7UYFSEia0VKN{7ZaeH}X zT6#rgIx3rVG)-VI^|EqVQ})Y;P7?j;H0sfbc&z{ zC!g`t3*8~>8B`8axr~mA`u{9uFi?38?|KaX53u)Q@VBOGAy~p`LIj`2>5s6pxLYbV zl$UR)SXO{cpe-*dI@cy&c~(vDoH@PK3%rl3e;IzXC>om6DPDc8i(ZM=VeRb@y_Htx zCX51#ANxLorXwp;=KDTFxzuz_*=e9Z;iJE#yyT}>Ek627%41@5lZWm6ee6mCvmf9) zE9N0QHFDY}F*Nr$&QGSKyQeo!jY`shMrjF=me31L^KYNjF{vOg+8wr0ppHU=qJn~^ zu-hf}h}NW?uYt7K2!m{>{|1E{q%}2SX;wPY+|%boC&o;f@9&~qh5S4&I4S9W z>Z8BRQvLK|rX>Ak<+ldRgk|}H=+A(14t9b{Gppu8 zi&5qoJAjteG3Ig=3K(Q(inywPSyE&j#yRD=4S8KPqN*aRc)Rzop2MVcw=uoT?$57m zoL)NlPVag>i3xr{uLuj4t8qd?NYb7}e*~)2cN2`RRzod%>;yLsN$Y}i>XSuUa#?n% zva+wp`=&N!eAduu-zMm?uWBqS8~U?8QM4aOTc2cJ+Vq4V)MdVo{{`i=KLx6+OX@&L zPckp*FDb2ldey4Yo779nR-sEJJy~v&{<3D#(MaorE~WZS>Sg6)a0A)JVLSUP)=1nLa^)U1^Ao8jvWE8_dGcGtv;_zuL~(2Lq~pj}RmVhQ$7 zx&=v5D2!mn9WR(~n7#1kWEANKkp*K#i)lZMFW9d&9`ge@18h|AD_E=W1*K1VW%vSd za`=6e3mZhUm#)y(;G?JYB_K65RIO_A?ZIuJ;h>XCH!0KZ7Fb3hr~U^K<62(6%N&Q zL!~+pB0`t>=me_VkBS(|n4)hCJbvgcYDUv6%76L2cC7Fc;my`!9N!=&3dswGbM#Fg zg+1{%?f#cE{9`CZI#m%V1q3o!gqNfe=1*MJ;E>i3n(h&h$aMuisgkuxT!pC32dz+z zwe`FsVHSbGRTbIAeyqj$!aS+2bsc$8c$qJw?B3zGb(J)Gh3LWybID$)f@|>|noK^Dow2$>xg2~%ulX-<2PqY><>n$RahVYls z?k(yA5S7J?oRcF4k<{0Au<4GN7zfgRP%*N{M||xfl4_L0BA9b2DM(YLL{rNw4k@gZ z6eJAMS;EP%chT|$k@F0Kqk+cZXP5!Z+c154AMCzfHaYnIU>5ax`2FDs;mBubpC5-m z@RcC)p&$>-E$zb-rK}|c5bO{fgJZ?suS2vsM+}G}j;KJ)`IodVrSBmu80mWiD&z}D zX_J^)pdk#XSpzry2-*+CRQPeUei6`WlK2`V7p})P5yHl}97dpR#)%bi6U@!faed0Q z5j-nwAvv-E<*YudKx9yK=#MDpYTzckVN9fJ zb9A$rIR&Gv@$Ogr5atggfcdyo!Uh=gO2RM?{j)A`+S<_2Okrr-h-WhD zVjs525==VBfN=7fe458MQnH=oNC)8kYb%pIB5Z#-(t$;24D>f5EiJz`xk+|&PPNDXpNhMgLFfLzyLSLWAlPrI}E|0&O6laLuPN?I5Ei= zsNXz(b<6i)v`L%AAZA5qFZ57e(PYRMpi92vaNmvog0kG}Pad?a9re9Hu$G2oU-xbw z-&6BFh_I4{6B2wpC;v?Hd_cL^z;m*1iRXdpz-`bO7*QBTM40obki;7~4#~udwgs_v z15Xpr^60bver*9V9r$$AWk!B;Km5*wn{nqlXd1MK&CJTdiidhd&a*+osTDR&^hfU= zbZ*iyYY))qAjRAxH0T8(IRo%@C@VxbxGQQka_2E9H*UZ%tkBd*WE}hT7_kjJ9~M!l z1LV}C3~N#4^!Ukl4z-8+pmHR|G6GIHg8|Xz6~vxM>Lr4XqP8;faz%?}NP5!RlAghn z@Y7Q)L(((!-CsXxZApI#5gZ@A@GvC(C7faP(^Fma=+a~&6CR!WPd(Y`HXX&01(272-V1wEo%hXluwTjp_Mr}#I~ZXkR{nh97N>`k## zkgI{6Vgue#F6pTrNqS~ zAH(IUp=G0ml0C6<7p1eq_+mfGBe2hpHqAfU({p5g0J|2js3LpTwTyXQ=AAMHJ@ zwpQ}jn~$$tdAxbf(OW_swe!;*)vJnzF4mM3*1>mr#rq9gq|zyU=pK{FZL+Co%7zP` zJ;8XzR*Qq*NeL=%m^eFo-1-jdL~Cq7cJ{;^K5pCQNqmbn#=Orvv3t$~cJ|di^NPg} zfIER0`X2QS_-Rxtb{Do;p>kM90YSt~H5cWGbg@%nv<~dM@?=jARD@Amf7f0@>@ez* z|HV0<7NJ;v__R-(?m}?vDVH<^@%8=s?pcA4V0o>K%i8grR5hJQDE5 z4BG&02gb0RIGx10$bs9gA5yyZAG-fWdf9tP!zV*#Z-!6?Y|-cR7}3hf!n!eHmivu% zjfmD@AC~7dL|$-&jp+IZdP%w*5DcvuMtj_}9u zc~cYBsH49)BHZ$cCe{ue51&(^0pNl_8RP^;t9{YTnQikD)6x>>^V7{Ojlr>Taj^(K zP(M~GN3s6lQyG0X9dGEz8Da*;@FvBJT%klNiZ%pj&};}bWqYf#vMMXHvZ`vW<`Anj z#BAjcm6m!u_zAUIL(LHpw81J95g`mvW)j*QXNM^pU<_J#h77wvbxV>#@2Ax#2I2Wp zyp8=7*&|do1sMh%7>scXqupeSTo)P}HYId?Lg0ch{Z~^H|8l~Fv16S7Bwk5xjpYm3 zGpYl&G&D2m58NN&UcbEdt_91R@8%1yUcE}a1*`Ze>@4JYO4$|i%THDI_4ieBSFd+2 zdzyX(YEbS8SD+)sp1|K`w=4H!#^jzrR=n5~P!4T_a!G$xr-zm~ZrDS7^eC?}(BH4q z^FbU6BW)$>7rI>5Kd1}}dKtYXtK$r0gOCtqLYGU)rwrM9Bs1!j9@Kz(McGdEYv_5hYG_a6>Xp@a12-#K7+=et0MEfqU@q4V{f0dO zK$7@GZS{YmwqE;8`y>(TXAIU4#hZ|3`OT>{>rpZu&*&?QKEbhpZhQiB0eA2!;ll@& zYuFd@2@d1fX5y2_@BwC>YNNBw+N{%wa9QW6lWW#dz22`;H|~wV@8A09PzTdmU>2VL7 z@&bE+{ekpDjxQG>_vxz@Nl6vS4tjOG;QKAPB8j8{cOW2R_N-#VT?b!a{_xHyw!r0` z2*6o?6R;VQPI*)E<}-k|uAnRomL(}h7If)~#&xtosCHigVRGOU-gTlL?*6`!y|dCAVY1q&J)@FOnSX(=lsh3DO^719UvQzpyhD{&eKViqk> ziW+`cB8LTLSj+@IkC&fI45Nl#B-kQ-J{D|A=jViE15?P;MW=xdEI}bY4?zZC7~Ygq z$BL1@g5QVeEnTf7!VVhVpYZWeix#|*#q|5SP&)O$=@+r}#f%ltiv7i%bSFS)T}FDH z<;hoZ(Da05X2wBR%DU~ns~3)$5k_>s{!ioih=1NWk;bx-c@Ik08R)~zRZ;a{wCUULi^IDWY^@?*;iOP-}C?A1rZ zSA^w1i9rHS+Ua*RFMWe}3`e+i$b>ix z-;uA12jgS$m4RAjj#B@=qZpxP{$+QE_p9zD^X4t-_I}m5wEg&!CCA&}X~eOM?VY#Y z+PQu1uHHEh_dGmz?!!IchYk3Oi@=MAicA%0Lc`811pBiMBYCIhH4#Sn^17 z!$T{UA8zo5RW7L9m^1A$PiylumSmcJ^r56`ywJ=9IHDDVaY*?Qy8R0`X9B z3y8$gQ(f8GnxdsQ67U^Yv$?k15q@V(TtV(n?yBF{R=T2yt#sJ3ic)OuA~xr~St*-M zO+mjr@{_Y&dF$tH$XYZb*VA1`GfO+*WeD*oai&_p&DB_yJ;y?aYFOw}*3<_nKi}KS zi-yiKM5pAQ`CB}3{hs;T%D&%Y&pg*Vbe@QLQ7=&^4PRkjfOGkzbAH;G{-<3yUPpe^FcD^ISVao)5ws;8KKg2k+!Fl|p*!|HF3Gw&U`e zWd|28#!Dxp#f>L_Bkr#OzZp(Jc-#!Nu(6lv9vkm!w$Hnc_4fDod#ksTbd8|*cnBCy zt-3E=diV9$-y!OYAnvc+E+ny;$MPPzcaKq3i^tAmy@Pa}Njv_rPWp`ndIvi?+No}E zhc~G~uoR(_f&na*|Dlw~coiq5a}3$DK~~rIbDWx9ziP@DXZ$666^b)2*Cmb=jyyn} zl4-ZQad;^coTN5p;~aJz?p1=k@Q>IsymMrjAepeP zkB8npc@jkMG#h}zxs&8SN4hcc6xijudaJc|e_nZQb6G@O&_hId<)yMUYKeaSdiwNfUW&sOD?!AS8N&@s;klpzPKG|$a#OOkf1G}PW_^UU z_5q%I^5oEPsop3wEgF_L4hfVlx=2UhG=MW;e&WU3*>q_o{#8sZX-HV@OhY~|^U3oal1x|KkIXosC z;%Yy;p&ryPak$sfe};MldQ6rJF4*}ra6#UB?oYn!vB#TmM00vopSb2^^B@_Fj1Rpz zdxTHCOfV=a*QVjPa)9Hykz3MXX5GXu@XgPg8uVRad`IvMy59!BaF5Odj42A%#nZTL zG?8M5xPMZgTR*Ud&MMxVd4KG3#l<O2TmX&)U3%gm?#goRzPwY*?99zF-;ltFbI?#{86c zyC-Yz+ML{uY2_Q|_uR7ybvki=-HDmjH5-l8pMSy0DuJIdu?tI!*4M4SSACMXT*(>J z++DlBV&{&t6RTUxd-CYk!OWEO+|@hxZ#zmWBNcvACTbOT7U}02qy>nBHEIrmp}LU? zW*u6bTehKQ=El;*l)iuIx0**~cq6iB1L}N)}G$t`7mL$d& zW7HUvSfkNIV~Zt4W5M1_OgFvA{k~_I<18IL;Qxg&ak8vp%7}ob6LvE;qZ8w&rjINwD)IIRnv8fq z@V6g{0O!4?E};K_3mQ3Q{N&o;FI*UNKgF2qyo##gqVLrb!I;y0#vHT86ipthzRLZ; zdlAmBvS>`{zUzLKjH$;NGrc#qs%CtL_eZ|OSbS^70v0ipO$}rVSOZqY%YzmtSI1PUaTZlhJ3>JleWugMGM${l& zRmLiQ%!GQJC#W@gXqXRWF+7*#T6E#4T?c~%(XF6sFSeJl--T8-wMx|ZG4>qsh-h&T z$d9Syfm7f-07+X9ri%A~Uqo*(GjC80!8x5f@a8;_NAq}|#Ru_HKAk_q7xD+9xfmdJ zi^JlGxTNg0C>Cc+LyMcm!xCnRvcy^vEnO_#EIlo`mZ6qXOO<7;rP}u~-#xzH`~K?J z(9grq+t1f8z%Rrv%CCc8hTl5BjefiQ_V_pU5AYB1j|>n2<^Y!f_W;iT?*QL`RsmT7 z!vac!j|LzAU0AKqOw-Mut>jMJmxuB8JdtPfp?sv&?GMpZ>UIda)j~IJFi(do3#(quxeEj^RZi%{XJO4vBH|W;P z(5*!3#-SUx{%E~{Hp~;bB1d!=T}2m>CQ?La5h+^p{d_&IfX*BhexJEA_LD5lPY-@} z`MD8eKRe5^v7Zxv`WC)sKYRbQ>Q?Vt&2QehdE@Hr8%J*(zH#Wr!5bgk*m>ja8|$vz zx{=D*jhO3~u77g<`1OO=?qB=n+MR2+uidWdBQ8 z0lrE$R_DeT13im9F8vzRqy83=gn##MDn`UZ7%lFs5pzL5?8TB<7dD+e%siPFYl5-U z4E?b=#*QyWQ6PGyKgNzT`lki4>;upo93bzIwP|5v;XNE1(!lWfkBoWz}e-B2eXQ zB7A-<2C;rDR>JlYCjKpN5gUUxB^fo4QHfbG1M}nrHXO1`SsR3ohrb&16v!-M`D`3w zi)4r&xT_FfgP3xp^@F4dz{Ln79@3~vhL4dcMzb1Af~Acmh51<`F+-$U;xRY0#TXO_ z@wD^+Y+}jA%n=95!x9B(vV>Za5!V@^Hoi=RMmD@UqGq^V|Qi0{R^vTRm>bmfTigOBQGJg9t7BS1|u z>Q>{Z0B133pK>cj{(iECOF&nH9uG;>;`yu_n(6^ez1WY1p;wnm-6^gNj#?>Pj*afJ7Aj@` z&XuW0B80{irOO5{_2Wu#caynkT2NhSdT4cBugRZ#NSpuChuT5gDEzg9!~)bJ*xkOgmjc_EcB+*m&vxF*&<3ht@Ww4{;EkX_^a3` z#C*Y_ zjl;tZs~j#mhB)?de97?;b|&dqQw2p#p$|pxO0*79OvT=92#UdnB8DY zgX;}jH!Nznvf;5tN~5lgUTAdJrMXL}ORP(>OAnWRF2ycYE)Tivb#36<+O^PiwCiHm zGp==Ro!!Q{O>>*;w#aRj+d;Rx?m_NR?ql88xF2%=qjCGjHI3IaKGFD+M{|#!9*Bf5jy!Ln<^!mu_wAUrC zTV7u^scN#M$*WCvHf_>0t7)I6HO&&5b>G&$qkNzBJ=@Z)<)D^JTOMn97CW!relz^u^H=?c`tJ(} z4k!#*9`Jo&Lg15uTLSL|{uC4xR1vf!=u&W#;K1Ov!5xD$gKL6c3ceV8H>6caS;&(i zAB0##(?cH)eIs;d=r>{EVfkV6!$7bV+AL{v zH8LmiXxs3%uSGSBdMN7i=#=OeVq9ZOWxHAJtZ^gbzG^?b{ptAO@gFB7 zC%l!InD}Xjz8%hYe72KMr|F&Mb^0}Fbkd}xYe`>q?%%nj^QF$8Cy!2kCHcFQwkZ`U zn^GI3&P}tV6{PJW?|;ltmv#+Ss!(a z?)Gwb$L`&_59q$K`>#C)_t=@;AUijEW%i|>fjujG?#pSIlb16z=k;Emy=L^flbe{k zCii~t0lk;^{vt0q?}@zH{Mh{2`Bw|l3f2}p=u_6`MBm81)qQvOYuK;2-XVC>!wcz@7tl4Qe^)i9wqO{V_Oe@QT5Ahx8co*pPigqleBL`dMN7!fAzvh6N9+ z8uorsyQ1a8U58H|UR&I;_~GLHCBY@dC3{Q#ODjwFlpYz;ctqZaC1q;a+_E1>4jy@^ zymR^4QNg2L9QDQMtkKVo{;eXjV%He|F>5O$D`!@otxBufIyP(U-f{iLy;<#7J*s+p zP0N~jH9w7?KB3WsvI*xWwx0O-#Lp*{Og2rPIr;XKpeduLtefgEwfEE~r`~=j>Y<4b zoqX8);nIiqJp9qLfN7Ja&7O8=di?ZPr*C`2>5+#Yxjv&{#;Y^lp4oinoSA24h0j_x zJ9_rQ+221p=+Q%u`8@XI+4%DY`wLO zZHwBraNF{2C$~4-9=v_f_E)yQx&7jfW;=p+6zzCp$EA1N-|7F(l6NlcjM>>?XV;x` zckbWizN>uKtGj-EH}~Bs@2-6J@Vj5`cHJGfd(iHgyI-OE+XZ;}hgYpj^{@~yTf9!YM@3B8!DXwji9hdw%VY)6CYjs=<|=G zK2G|$^yBFtulo42kFR~Ae&YX0t53RoQt-))PhR-sz$d?cn)&IpPv?HR=+jl7zVYeK zPY-^2_eAiC=o3jNx}E5AqUgk!6H`t+cH-?5drllVar(ry6JMS9^a+8o-Tv(UXLYBXPI;XQI2C!S!>P%q9zC_- z)Us3SPHjE4_tclCBTlzJopw6s^uW_2PA@*a`t+vLyG|cEee#SrlXa%x%&;>RXC|L{ z^vr@Y%g$UpbMtJAv*Bms&ZeI2d3M0r(z6TCo;!Q%?007$)LLpiYyE47*1lf5qjrDo zC$$%9@6>*O&huQ>xq@@U&&@rz>D;b!htAzNXFcz8KH+@-^ApZLbN;pSTh70K{^kXb z3w{?`Ur4x+aUu7@;0q%!jKA>aMRu{l#ikc~U7T=n=EbKjzHsr?i$7dSyOeWj;H7Do z-ng{$(ydG1U3zfYa@q5;|K&E96EAnU-23v7%Zo05eEIz4+n4WOuDjxN#p_DImB=d{ zu5`VUcV*6%x3BEEa^$M#)uOAju5P?~+#pqulKq>=z7`p@z-ZwfBO1M*VkR&ef`AsTi2~O0&aA^k#l3~ zjRQAM-MD!(@Miwa**BlO`R2{*x7==J-72~@`PRZ)D{j4Z>&;t-Z@b-&zMXV?=wVqf-lWb4ZUWpwxSepJx(fvM41zZn=Jqq_STrAx42%8T~=>l1lC;@$)bx=}) zHzKSS_)XxEELs@?`gb@t_!j{$1ukVB#U9{f__Khw!;NKeNfjbo|&4C~BCvjt)STcGY@2_hRe49xmD+zjy~ zcE-%=O66zl!6y4U`>$h{wV}~|Rm@qo zAIZ||Lv0LR>JNImsg%e6rmgJsl5MpFb^kBhiu980A|> zyF%-IQv_)A15*evcvbXC6Z)Nl18^n6(2q^;!I|K0!GT|r zySBjOzR=xO;BL@)8}LZDnV`$yE+XA}xNL-V)$~v|gDwZ{s`0AOi<}ALQGE$G4fuUH z$W%$r063JFoC#yW)DrYQV3bR`d%$QT>83y~#)j1Dxq=+E4b3^?70@WZSObT45}DQ?)dRq&1F;ry z9f7Gld*G-XHE^FHd?(xsT3Yo2Fxtlf`4Ki_?ofXQov%3s^{uYAeyzfM-_aI-P*yb1l_l;yw~)^7-# zz$c(5In!>$(fB)V{Yi{~tUA`gyoYr#`Lhn{cDP*7Xak4Kh@ z1^67|&`-_Z!$H1EvP$6!;l4!}@{u?QeBB|h0sN~qXM!B*Mj_lAy!+uF3pyHDfahgk zw5xd``fMv;E5eeX_cy>8TeN1GJ^-eA_0f2#f69IdeU#rpuR}VL4M+XgMD+(}R)Bi} zqrSwU+@!00!ogK(F0NAr#g_@C3#n9|`#|8*D!Kk0J~e(;!Mfl=3T z{y`aNUNU_TzOR725dSOiUhqE+w*{^keiN`G@}Ca+2J1*p>Cc=^Gg(LUrH<--g!P60 z31ELXgvt2XpyQARPWcV8U(&Ej@+hy@G^~CN8ht?Z)tspZ@F|3$9p$)l1&)Lqnlq@+ zq8_MUm`V`-1l&j99S6JvxEaFH#K)E>5g27Mp-c|Jpi!qZ=cq3Lcf?pZ z3QYBr2R$E!|3kRv;YU64%m?_b&gz7nmOt=pakt~RP z&mypg$mD0N4@3~_C3<4-(SZetG#13$z-_R8|8Msr9P)T2_G}GU2=Ztx99V?#W}cXj zdWi3tqga9c$xqBrTmcS(i-!9V{yQvzw*#GpJyr5l*Z^$zpqjg>@5`n2(~ebRNr`#5&d#E&;z$ z5^gF+vZj0jYbfbWGXF3hYrP`oXu7Daz>9F?t))X6{yzK(tT}%bdTwIv#9U@kCNLq! z!#!jDo&V0f`Iju4d$KU#WU(5*`e5(QQTJj9_Hrv&fXHE;NLRjum5W~Be*(YLIIsYI z0sFda>;u2V-VSw-4SFEo%AELB_c|7Ss-Q4(-rfbJpK@JL^^K^@Ob*s4eWBC}OSQ z_mFKt?O}7&7FwG{>h-SGxz+}fR)bM4Y74Z3z2k#er0yE>LDnC{OvKyTf!e~}bz#9` z9CMIuLG594XbaiagsI$=?_V*Mo$~)HM&DEhBAm*-3z+JLbo`$%^<&D%hJVrgsKb3I z$0^`rz*m6p0{;&Dhvv}V2BAHFMn2T{(D!Bif1~w7oHY_S(G>n7+|Ow5LFfY*8&od} z=|%Np^K0X!sXlHDtokuO)dBip49R}{hK_B18dvDsa(vlij5XQc39m)Jr#7Z~{+F1> zryL{HC#XI2aY|!_#;ZM6@Y^KMv+kk3sfIw;7j>O%I-ni+KcclaJ-imRG`Am6^wNShu<1YHb1i0@oR=&pk z8;vtvLv3#57{kgZtg+IH`SD2WF`6@QmTS#_#rTIqo46p)hGIQy$QQF=T*dfw#(a^& zQusq`2*!958QvPYHAVYjOmGIB$bG6gB@pwE0fJK#*PK;pzfJF=z7l>uB8W8w1+4(r=`Z%)FFc%Gq!{HT^#;_23 z2w@~ik(lyU8x}a8S0bPRN#n3X;flM%!+;I&d;2pEqr`9G2l2JIE3S)+4k->D#2N9a zIEwHC;ys5B!0(97Vxw3qR*Dy8{PW^z@r3z9^9SbL=G|hJd4qY4dAWJHcvwsnW5p;@ zVxB67ivIX5X1K@`+2&kWK%|Hc<^<8s+!{6zVPPqmx5>25w3`3I@AEHB^YAwvzw%7xxA|3mo}V%e&J!yiVRHr_-#8fzi|Y4wpNR9>fzC)+5Z zF~mQh(W8wW+sMI~S!x?K#)!dK;Tg(6-kB%R2+_yKvAQ==mtWPrg1GXb#fWNKG~okNTQ*hlJ+<`%=%s=@C3?42@$o zLCS}5|p(BO^v059#*6>HI?*8nag$x!8vprK`DQll#nlD_fv?{QqB+o6s|lY zr5%zy-6X$v9r~u)N@~@Lq$vwXA7z*1aifx|=~ABn;#7j_VACkt)NPWm7SPMO9N~j0 ztr%N}TmZjBs&w`g}*`>m|#6TIThG)bKv#D3WAr9;q9FcC<=*QC$h> zMRjOd(Y5Xb=*@MrK&Qz0;9a8muDY4XQI*=}%Tl~9CEt{#7%g**t9uQ4z9M;kA$@S4 z0-YVN6K(ED{N}#IZ(1y4YpocU>RFlgxGdc+Ne_}TugG@4LLt~!$o3+rn5|=>&r4QU zg#S>7@h!rsZuwbj9N;2r8^F!hzJNQar}1B`eE=6)TZ1!+>PO^LzWglJBuc$XhNF)` z@-c+GL@g+OAPupvp?t$hH^@g{f_#($^3j(dpCtT3<%RqwNDlF{XK-o^gEdzqEP|q7 zc@xJHVe6Iwi;pbWoAiVY%Odsydx@=JE7>ZxnyqCU*qhj+ZDZTnE_RJwXSdm1_BCt= zzh^(NU%B84H}j@Eh_}L+jNu)4N1g;b%^t9Z%;CLwZ=T2Vc^|BJ{rLbs5cZpcc@Zz> zWBE8fkw3y`@R@uTpUoe`n16!L;|ut6{CU2Jzl^zH1z!hi#m#&h=7$}aCEn);_z`}T zALpm|MShdt;XhzL`2&`qicp0~n1z#Y77c~F@DxpiH|Cud!dJ8ue!^dbh)@wOB19|E z2J=!|*rB!;okWsI6Xmjk95ZHRrHg$S90qg*>Ypu@Lv-S}3n95<{kV)Uiq-yV;k&8q#kxWq zMD0S%W%##(dl$m)Ax7h(*u63xrJ)p?;Pzr2x(wdcpijyW%IUIPu_%5MsCD`u$V74_c z5HBLvI^^G9@9ze)46Frc8Z%-ceR0PrbC8L)2e zED}VFXpNcP4|BhVXe1nk5Vx^D{KUV--#x4tmw7EeiS^?U{`T@+d@J9CzjgRq&6nYC zF=@*eC>{7b(V0Jrmj;u0HLpeqH^OQjyAm;iS^}#LAU`MRbO}dF_z*$04?*Qe2@gsb zAYrA1WfJZnXlhJQ4U+Jpgrx)(S4j_-(2t;b6+u(A4A~^%90_Mh*ipi967D7_P7+jZ z5j45U@K%y;D(P~9$`Tp!mJE^Fs@o;qTgL8}&`ZKW5`Ik3WF@F}lh9E@XM)OU3Gd60 zHwX%uuOdr_wV1|<4~6sNlCzWK8A4FiYGw=3rp+?;9T_g`R`r%4U&@dOf?R6LFH2gc z;;&2k4+*~~sIHbUmZ0*jq-E~vXi29^_>+VU2|8XQXr3YAGXzb~6I5#@JS*Wwf?}7X zpOf&443RA&WQZbb1AQBuT-J%mmpo1qDl+`Mgc~IMPKGa*^aV*L5meq#4g)$7Jl1i-D}e@hu|O{zTyX+*XSn_SFT26c zf7uWAf}QX{Hi!*oLtyDU3O2m|v_pKK9b|{tVfG> zX_A;Mrogs?X6lr`aUK39T;u1~H>sVha_m74y)X%Yo%B?;5c69Z=DBj*YK;~Zc$I}8 z7U&;Ne6S7q&wqGphVID~rf`*;urGJuj@*LRKF+)WZ^#>Q7w*d4xI1smJ-8?L;!Ut~ zZ^pgxzRHKUz&oav+>iV703L|_d@xSfp?KL8&LiaBz73D$ZFv;lVa4!R-j2uN%~L$i z;)!z4-wC_^&ODi?@Km10({ZQOg?EMhbQbT1b32^|ddl-au6`mYkY|E^cBg_Ncs*6f zhv9TE9Or`)yz?5t%W(QH=cD*&%)VoIC9jg_hH74e`?Lu-KTN{>JO#IF5AlcjG|blZ z=ZQz24{%>CMlV0(V_xM@ulX(Amfau?hKW#V+z4eN6coUwZ1 zHCivM*1d5@l#laPAFSQ-%q0ejLFnmnZzG0@BCPAhqC}Kpt+ns{W3c8|;f8mds1`NY z1JsYcsp28rLroLY#Ut1u%*3tKZ1Jdg4Eu#S;t4Sq?-rlL?%^ri8$Tl!h-a~zcn~226 z-S!Er&7WaEa~gMRXGN_zhrQ1QaZy|nm&FzAgs$Nx{D!zGZed?^2lwKii+kb=@um0* zx8&c5Z^d_5TfWDg`H$FF{)~Opueh)KUHl;)U{{5UNQEmxQ501%;V#cXaa1f=L!5E5 z*HCGsxL^n7hI_uoiihHf{a6#+`ZZI$mFC!;wZI)r_I#wjlrGo-X5yBy zo6=qBf&E}l+&T7Aa+TiL9p>W(vX9bN>4&}I0Nh6oQU)tSuyZWL?PQTMTq(v*vJ`if zWy(mU9Q(@AxVapoR4P^2Wsbu=W{omlnSed#B;0CFQKl*nVNW^@cbtzXGnARiEM+$C zJRegYSLR@cI~O;gPb%}3r?BIF2KS-QDhu)3j>=3}7ajg#W&HEYKYHg!GqWG835Z2)`B-!N;H^|Y)}IY9R^OqlkPTx+%Jb|M_9%Od?O}^? z7xOrK8ZQuEX6xA+Wf7Z)HFq}N+S2{ZQ_5oY1l!Lpv+vk)+~fR+8=IeSr}G9of)#ob z-p3TXet2<;;rX%?g}MR&kDV<}1n?Juj~R|i(g__**SKFy@a#b@3=X5pwuZ=oYpu_sfwzqChXI;;ErtvJ0Ne{4&trr z2W$>|9lNRbV27|9XFCVn99h_W)k$?`OVtK=C;bBZMs27zVz1&2_cHbxZug$Y?rbO9 z%l4@*s;laTQ(_(Z4=|f~62`A>6K_d?enwTv;+1bR@MJAQ}y(HPk zi9$88MCv(!w?`@%dSp>HnM7u05zNV?fOI0$Wn6b6yK8X+h%P8dMTP|hGAJX1JQ*2U zd=8~8kW4ad29bzEsEo=bf3EbW5t$~*o)kZTKpuf?0(~huUrNo-rvM40KRY|s0g4wQ z9JqU7j?}8hWKyI@)?`YUDPeaRl#wx+_@JWn=4u>yld17~KyZ&N5Sbt{vjB23;Y$aR zPQl$lbeF*cKot}~G|CM!BLgHvg3QSQV*y1|iVTV*ftme&+jmlYAq#GFD)r9uP&}2wem{Gj->H3rL>}`W+aN82Q#D5+fma zh*gsU4r0_iT0ANQK~x`LMs>hLwE+(*0}xpOqI7_$2}Dyx5JCkYOoLhwRRUtD4yY=q zr0`M=08s@XRF7I2qY!Hgt*82G67uz^LKIbFD#V;lN)_g#n3z0>AcYMwTSjM5 zl~JZydTpS>wd%=2X|;%+8Yd~Q1!&a;PEFq|)Rx{|b)rx&0a!rkarvYw9*dF?AX&4S zg|dk<3$>=nEX>eivD%;*@MdYHmXs_jSV1AGK6Jk03j6y)|wBqgx0YnA$dT_#K3*2Q_&0pM{4 zP!9##d;z5E2SQsIK=dX3C`#LrfRgP%7)&y?oG(xnw$%DGfe_i53$(5Y1O}NvP80=l z+)=%Nkh>lbdICAL3JQDL5@^+C>plfwmvVIN^JVQ~Aj=_807B=_hxRBps#}&{*1zVL zDKjwWs9p>8RTPBGAFV>kfON0yN*U-%l3QQc;Mb$&fTDJTQq*jema?RV1xADxA}e1u zqUM)MC_TBX;T&5_<`l}71Og|@1VWc0Hvuw4n}2dpSvF-r>C$8~ zqf;VA7EMQbtem`aXrh)gHBrPVOHWNKlgLWSB^HDemTdw;_iKE)XbrIELSHBaq;tuZ z%eC>yUX`mUm#bAK%F&(bfRNnpV^_^j4WltABX);hLtE zHciVP$mW;*HjUJg;$>e#B3UF`&*o`}Wk7=&4l%5c&tC_SA+D z5QLyEiI5!!ge(SOM4`eZCA*)bWS8iv&Ek4@>8Z^EJyC4v(Nk9(Sj$NkV}Paytr!iA zJ@ubGk}q2ugg}UdG!S}tCP~ZI+5|{8Vz%Dh2+RJLO>-{FLs(BIdjuF{u?R!3lw@Pn zY9w3hkwAJn*=pHT9gywc6^d zb&|edK{2u2lsiSjvSc9Sl1Ess9U!#cPK2IB_6YdpbOtPI3|RIDV7W8_qbE@w`N#te zN*HBEErHTTv?P!mLqsFxHcTUB(IlBgTRn{eZ#`|3g|$r+U|ZI}o2%zY{Z7jf^{Xk< zQ;(uvq=ne9rguIqbf_>=o01w@gOEK9A+mn+wN4=mBl+c&11|*2g!;rxA$mfsHy}Xo z4f)z=p@mCIkkf{?A0^fFPLZ$eVQAAUhNY!W%8=t0!&Zu<;fqjeD~V)R zpq7$8sTB?uvQ}{q6Iqm9Raxeuok0t2C+|k}hw#XvG2KwtbVMbx@n1M832>ERv%!b)MAkLm@Y;b`W$?e7Y^?_WkjM-V^aUD z7`!&cbkg7^!MzM03GQVG)+i%V3hrZgsl=&$>IG}05lywAUtj$xOuxr6!q6M?QVYlQ zLHkSG2LV}nfW#D&fq;p5G}I_)VjhAFVhkELDjFe@h_Ml|Hlm%4h_eyxZA83{NU#x! zIuRXZBW#kRZIYvHlA~>sqivF-ZIYvHlA~>sqivF7Y?5Pal4ER=V{DRR+Br<9ERTvx zjnZ+3hSTC4QpXe(S65X!;4X-;IhAg1O7WI~kV9%!Syg4}Xon&VJEh|Wrl`2Mv~s*t zu|b+Mii;>|iH0&Dr)a!G7hQ0vF1U*(xKtviE=FpnQiF8pqGwmCVKdsB1eZ$WlxZ+J zl^LWgNOVk$j$_T;#+O%=l$y&Wa_FXOQLbaEhUl1dojb#!o1SC2j%9podo4aT-ke=j zJYjsPxk4g6G)>3p=4?&B3W?NgD5X{am~*sLm3FDx#c8S9wKwNzsVXIM=%s5`Wv^ko zE;@JDhP_5ks4Oe0o-n4OXu|l0RrWq}o|aFwT|RNT?s4(vJT0GU4drXRHTJxEE^%G8 z+}i84*gn==pd}iwp*~ujPSEPKk4;kzoBL=jJ3%5-pX&0;GSdWt4g1(@+i-%t&!La4 z#x?BRkFND5j2Tf;I@x)W9X-H~o>EVn2WsV+Dv{GbqeD1NHAt;g33}aE^Y>-;g% z2{Jw=I#I`|I@a1ZCQc7e)6&JHCz|`=@)Uz(l7{+e8cdSN(yyevw7RsWyv8!gMv=Ve zE?Rov4D$dj;S`Cq*sfBG=q_Co)h-jNt0*ug3OgGOOI2f{qhqB%I;Op)v}Qc|GHyX- zNKBM$?wFWp*}Z@hol7SdR}_tjtf`5Lb}FtKGp0zA&SOif%d1Lk!4*}Nl5A8{I;On1 z%I0l2ZUSYXN4jXDN~$Jl%#Ae}H2hIiO_rN2g~8=qQa-V~q*N0>ZbH@g(u&d%o|T=6%p;6#?w8yBpqwY zCriRoi5qN5kr@gs6k%VqSm1l7@{L)Ed}G$>FK^6Tq~)U{?2sD4{>TI0RrQv(F2VQ} zm3~1bi)wm{<^p*tew%fIwUR5Wl)UiuRUiEN>W^PtL-A{CJ)eA+2HU0vNaK!gwc-sO zey8=r@3SHJUA7J0s@3p?e}bb&R`Pj8_3%-=UK_!u+ri18Yk0Li99dK`f{(I;C7>($ zPe1CBc!mzgjvT=|SKC4AXs(b!UVC7sEy9Bw<2pR zX?tR%-~o5(RhTRT-Yo{4w|->!s3wGX4v@;_1qlY9(`~$SuJ_f#I;`Gz6z@3eeY?dJ zJKrWT+0M68OtSMW6cg=ykK#pYy_AV~!(Q(j2|KZR-#}4q=gY>6>-xCP0Hb^v-~1P+xhN^`Wok!i=x~v?qj^gHuAIV6=in5&3Ln_^)uA8 zKlEyWcSX8x_+m1?6`=oKjZjtE=By{%ZJYMYjQ8~%UHJtgOkj3#!f)Tr@auOI{Nmjd zzk7S*ckt%ma1y8fWW|yXYm|O=DTDC-*kt>~oqlhJZ8d&pum4RQye{aOD_|`|c0rrP z_pq~ZgRKi$3y`hA-TKnNF2tq9#uj5+jA${qMP7>t7Uc7M^R>-KH6PZzZ}aTtLEcLt zO+`-?cm)W#m<{V+=X8dp$P0F_akgTF(kOGpNTM$^bIg0%c#H+D;yVJiJ{*AAG7UprS ztFSEUj1`jF5jE{gD}uXBNj1*FC&OEOZG^|ja34MVj1i94X!vWchrefpN6Bz+scTcy z^QKBulu4+U)#ud`wG&=voPvFpH*D#0`E6KUj)aw|Bdm2c!&+%DT1@6{TJtAqj;szg zt?gmGSqF>8#(2@MaZNY4+JbV1?a}YBd~Lz~U`6^W>^3*?Z$vMhH_zaW1my%v*?3rw zz5wgbt+2lQ4i=G_I%k-{*#=ZY_9b4qdBY~P26m*YU<-PJe~Fg{Q6g63SAQ}1TZ3|B zH(+@?25Zw2z6=(U={na*gR2!N6Rd6@f~DzZZq?&A8}SjKJlQRFhkXN!t)JN+T(jXN z+ugC!zVxtWQ7SDuyXfhwjr8H5Twts9E57sJm=ED|V5NEtuTeDXPM_ z-mtTJAT5QP=r+CyujKpX1V(n|J8Vz7y#Q@d<9bEYB`C$MovML z6Kt}5c`&T5+hTq$z)Q(;Y57c+&QD{eUI=UDwYp96Td+Fb1AF6r*biNWt?-ZhH(32P zg)J}5;2DO^ZJwS}Un8eLP%W@ive|WafaUf8yvrN~o9gMh74&*-z*1YViAl^2Th~3KpF4(o!=S>ry&i#AZs%%q7@GE@vBI zHTfo9!M?+G@*S|2ZYe@FN!V}Na&7_20hXUhu*ciP?qXj1L+7bAczi%LkT#>SnCV`` zOWQTD+r!&hK35dz+#3vT+N;nTjZoc=GzGS!+KRpu_MRJH9rza8Ojhsm?W!Cdu*$UQ z;|8Q(e=maCRSmPZ|zJ3i_d;P4Z^)sbTQ$u!i|NnNJS!w!GC z;v*(wMxBazEgQRdS6HhaN68+A1?gDWq2fyjFp|816)s6qw3E=NXoCurl!|rI3+F{A z)Vg39_%;nVWeY5jJ_WX}Nzm9w=Q@h`9DG$vupazlz;u2HFcuE`7T!*VrvWBm6>E+D z;fG#=T@P=JuypPYm3)=-Vtwu#=^9b!fej@X;P&pbY<$Zg{_p6rw+1vgk+gm@|HI zWD5Xe(AEdoZrGS^M9*8!mSTr6A2!4@P~YRRV;Tvo;KA4*7_i$q7jG|>StMabG0@t`}2 z_JE0k`T*V(0>+58fNe!9z(^4e7=&;8$hMGsfT7SS3jRUBk-!5XkN&@ufoQ7+f2~hj zZxX(clO@6cQ!$&64k3WaA{a0U-#H>psBg!M0Kiz`4;U%@03$?8z;Mw5FbJ0HLFoHU zG5<9XJ_yMW%>h#c?ZJ~pGr%N#T?lfpQ#+57@louLcVo_Z3*+ox^#OdhRQs44 z628DhWp0cHH_aR8HeI1z&eYc{z>V zBz_;T6aN~pBfj#5@^Tu_3H&Z#Jih}N$8Q71^6#Kw8B%{EaT5O$cmy=ApOJ2XFNNO( zOy<`CllV2jc(g0&{|_USdK5no-i`Qb6wPN>0n_;vz*Kxsi=^?$@ zRDK*VnI8j8;zs}z`G7XfI!Z~7#_Y3xo zcX3}-i*a!rw)T7RB6}-V?{!!)mtm)|0O!a@@p@r0UN}^sy@p{-7hv6357`^=Z9wWL zs{vo*%K_K&rGRVrHoy%2Hefn`3owPh37CZM|B%)j06X$^fQk4n5b3@KFrKdjY|mc? zjKkOBFh=-dz*xQrFp5797|EXljNl6a!}$WhAbdwn!5fSuzFFc(z6ls}C*KH6{q1#$ zllZH^#Rz`|m|Ag_#7TSwa1s2=fQJFUBykdd0k{zQFOfKjKMR}-{}%MvD!B^T%{%-V z=#s*p22A2l0e0d~0><?Q@{xBEd^&t7d>UX9e;6-J^5VEI_Sq}YzOU5j<^Z(9~? zbQ)IL_Ph#d*Yh&K#k?4B5ibSo$|nP+^GSdyd?H{n9}k$ss{uRlae#@u5-@>R0LJ6{ z-qeyK0b}ukoMy5jz#x48joK}RPn9@{(@jGa`04-NqxKsMTmtE1fT`U^0b>p1bccZc z%u9f=2J+z&Ct;@ttyvV#EBb1{hasO7UI>`PhXQuuLjYs=V8Cd6hmd;JK)|+q03fYf zS`GGxFNOC5OyYe3qwVIXJ~FOA#?dYyn&$!1+NY)ME#q@#d@sPZc4>2DTu&KCyMwm8 z2VkTfM|b#Bc{jjTJPR;_X99*B(!0W!#Jd1?;u(PPIOR_K@4FUlPU3Ok%H-*Qc$o^A z#8Uuqh6C)tI|Ih^B)~Y{2{4v-1dQSx03&$ zxF57CgABR@qFzULJHsL0TjC^nzQK+PcWQDU&1uz75jLauoCgD0TFr3{0q#Ffl zZ4=5|g*gD9)Buj9ch$gA_`QU1B>Nq>0=d#kj**G-X(Q8&9$iIa7g8)3qxrZ==z}+N zDpt`6_$_M^R+AvS(R&WF)*k$YvVHgq!@le&G&qSr?Kdtuy>VqR%f{=)S$OGKiC2*W z@q)4|UR%cCWu`A)aXKjs??AuA?pUKVR&bojXQ?~ zeD^2__XDo@9pw+)-`vFs{S@9N@5R@ZHsa=DDef2^mFKV#xOvFKYS|gTsYGC{^up_L zfg1iAb#xx@0uN#LxEU)Xoy}FOodPXL)D?reY*3dB>Y_o>E<{Ul-k@ktqJ`BO)LDZ% zV^F6J>Xbpzjzvp*(x6Tl)TajZi9vmAP#+l-?O8M_#|-MIK^-xu4-M+DK^-!vg9dfL zp!ORS?RK<0_8HV(gL>bf-ZQ8@2DRIuXuqRL*=0~W4eA|(+F?-J4QiV~Z8fMZ2DRCs z-ZrSW4C+mT+GJ2~7}Q3CdflKl7}R=$T4zwN8Pr;XdexxT7}P5UMLR96Uo*zjg*;b#{Am=8KaHaCr%^QiG>XQbM$!1wC>nnnMdMGSX#8mujX#Z|@uyKV{xpilpGML6 z(N$fdH>i;YRc25l464+iN(`#lpoSY% zkwFbJs6vApYEVNAYOp~KGN^$DHNc?y8&p4o>T6Ja464AO@(n7_pn4lruA~HD5Jo@4 z*zbik+~^DP*J+G-ggh@f>tp64v_7V@T^ig&>U7W(L(IaScogozwE1Bdb|uqrlSi7+ zS=dI?{}F7Xci7R}?dWZGG@UbT{9Ej3I(OQ_-?pRQvZLR$qv?EVl)g|f$)^>s%97V`d@eodg? zwdi+xj=K$lG^cU&k9s));P#T1Eh<(o(u{ruRdJ(AbQ);t^R4Vsj6i=LjQ*AdIqk4} z^+S3}(F>f@C6!}PJq;?`pn4cocZ2F?P+2 z!PBcrteeum-_`iDZG`fYvg zUucvkavp3Z_dlwIuT*_wU61eg+{F2lF|#M?MXLc+Qz)t|)=R6Xz<^LxTf6qLv2p%! z{+@xJf!x%*nOCd+lZNyPPH6o4Y7y9?d5g?2?=Gby@;cTX7R3+k;m^CdySnuq*0ZRI z>nMCG&ez*BhO0R_xxG6qUW{c{%Nt*a#0ih__92020?$~I4dUM^LK?+*Ip8P8CZ5ea zXFjyY^PiOBoeHZ*j4~4ev9PNI~rcQSG2tQ0MrsJxH$> z{(alf=%j}#vTIUakMQ>k2@6RH320TfQRMXGH?o}+m!ZkSCnb#T=HDvJ&#(2%VG+Sg zmcVv_@=@r^dF{1)Y;6!~>z#p=@jvA3?@2jt7&EPSPz!(GCf+T5GL-nTu76cS8C|zn z>M?wH?-KKzrd~~&HTLW{w7tDXA&VEo^1^!Gxj>zdGedS>#Yix-n# zb$_Vsp;zW#^@>H;p^gJxp`W3k?6&_#&j8x4xyk0PRyrd+JRN|D{ebEzwX2 zr1?o33iUOP{@x@O^-iNuTJZneZD?SVh|tk9I!A~2hXpSR3JVU4ig0ssZT!fS zsiQkT9IdwK^5Bs2n#d{euI}3|%FnmCkNFvM@xb=^9xfq~3E}?!;R$WSV zWn6ixcdo6jl{L^d&rVx8GXJ5b<*fSe)%Qsa@kxpejOf*(W22^7TCFE0;A8OrP!h~- zT1mn^8~i;M`QqT(IE1Jaq_k8%;pf)kBnK;lf3x%$O6xkSiP&5G-*pbvl#cQ8YEn=ATmAE!wh9h!pBNVx9oe#F zT-&gug#P`9^#9jIY1GUW|JR2{)0j5SV}l>xV8#EfM?FAofIC(CiX{DiQa>;g?BLNl z%6ioe;j}kHxPt#XNDEh2NPgP?Q1~C%3DK&+cpvmr2bfM`mc_d3*1bP3?k92dF5qPhS4QH78)q3&(`auSZ+EmP!rBiBVNHpavl>$$&g^|aC@Q~7gA>Hd+S zEt=K6J#^r}5pO=)+M{cJA74y$Gf~!jzjL(4ZkY*f>B2l}+h|~R?U7VCXY%Ma z9?||mQ6b^2>(&*P_A3`t0(|^@8a|2iJL^1f&)b@240kGzT>G>Q5u{+zF&3YA{Aay# z8XGYpxu0uFYEn#4cuq{ax|Ytp^4q36D@})_cODiV{+PRWD;HQe*M-*kvNiZ0VzCEu zw_8{L=QRLLVZVSZbPx2&EshHEY3l1ezPXQ2%b=DG9h_Z;jf(CaH8elzc;E6Uj% z9vJLX_mrv1)U!)?awAKNpoo@Do3@My@(l?TQ+WA+&IMsPK@njEokN3~dNroU1a+Yg zma;?85NBf2u)g?OE&MMvHEL>kn0tKlu0;`nfe{h@|EzV>Cf+fvgMEBE)N$t#4h|iX zgJT_qW1EoRHWu?gm7t+pi?T)@upg@n6j!XO@pU4{8 z`n7&Cip`leefq;MwvCRCdQn+9X;N8uRCE|-whho?1^5G)Cr4FcX6ubQ5^^3of|)83 zXI7L`o}=_Ft6W-by8_H&ayrm9?%Fny*&?y_iX_i2ZITDJjT_P_$ltMnUl{sp=%%RR z^Sk~Bu?xv#EBC-#U(Ciul{q+x%ckfB7u|N^MCRr5`t)F z=FFKh^Pcz2?DP4Uy-uCZkp&rOln64~uSBTpb28MM5Q*_>AZg6RrE#k5*1MxT$gg2{ zfpoYO1hEVP5k>EGowZa&Cz&=iUVDe4rtBj1RE936tDwfjyx7rDQb1K3blMEFIRi(= zqb549Lr(wcZtO%cicr&9MveDwkW-DyvbW16C@wAnGd(v5xffx*_EgE$%+MVPte@EA^N?lleItdfy({H8!M()|8k3&d06=^eVjwvDX5>3#I35 z<$&^aNQXg3tpw5@DE0UVnD3@vS@N{HGp}e>q1S53>7;+jeEz)NV#?F%Ejo8CI@0fi zJaMr%zcE%EQ&|92f=Xw&Nu83eEQg{6JYf2-(E0QtL~A$Jfcw>4DPuBowImeXB$%UG zGK#IJkVDY#GSAADsY&+k?UNhEZjzj(?P|5&pwqSP8fY(KUZL;E&o>+M-6l}{nYe`b z_|D#rm1}!dsx(DPYF&R*Yq5{{ARjc$H<~~uVp9pog!Ycm4jz1#lGHjMDjP_qMUt*_ z%C7vvUbh)$d)YPiT(igP|5}uYG{0G=&+71&WF9?gg2kd1R=o@N2e4uZqIzs+j4$BY zkOW8G%yKQ*nKLu2A&Heq$$A_*X`i>E=aI=%&#tlLbcmKP4}4LU6lb*D^ZT^qD?5NCi@j$YWPvI21YKau zMX1`)Lc_s}lms=$yUr~u9ID^4`{@joN=-%kZxHQ4DpE~zs|Snr4&HsrWVM=34H8e9 zeo(Xneya&?R*4019SU0pGK0W!24Mq~J5a!jc66T^i(b-Ho%7IXO0P;&=?xr0@S5ma z=F8hiy^cQrr)pzWhhYeqyQ)-qN*ad~Fe3~u)4A2`0coHX$E!)e9D!Rw+M~yjCmEv@ zqMoj^jfp#Z)*O;PBr~Vz&1QXyS@w|h(3;LkMT`F)(K__O?<`t2vLZFrWj49eQu;?_9kM%9p!@Je$V4EQAT=QWYe`urjEB^HJ>yM>+S?B`ZRlbc z`UlLfz201BQIV5wEmQ1S-8xZPI?=jvuL6EM(_iFpc)gD7V&o678!O;btPq_;z?8tc z3AUjYLpsqjZ9XsaD!p*sGt}|OyN;kaFu$2bJ^Hh_&jhava(F%zkN_KilFC-LF3hV) zPKZ;8_KN!!cCR{mXvK*oO$R$-m=p99x9_6vY^yI{WHu!x%NNX*Cdw=8ds|kGRPF6q zyuHlh^PS;NpxfZn<54cm?*ULz81O(M(QRGlHfY+HRGpfpM1DZGemJnF zcwNPZKHryVT1`6ZanRBEV&FHDkb%OcKn41p?sHq6C2n_o_QqS9_qXj~EYRy2?Wwjr zdzSm?_MMA2xYvMJK|UNMasmbjU)j@#btn&;8l&G&f&-h~No5#-%Xi0%oZV+r$D5ZN zsF!qfE>BHTq=`?93s-te`|}U(pHo$y*XhLP!5Ld&&4C`fF59C}tI}eVlyfV4vt51V zt9FQudD+V=fk1=(<6Y>wjUyxR53md>F?a_jK%WeGc!tMj&}QC$#@bx4vZ#8pHH|q% z@1xc|M~ynHMq8$y`SCT@+<~U1;euM9?*sVlCsBb4uKn>>OKt2Q>#7_+)$L;-aGZ7;#)@ zm8ad--=auLl&7RC%(|P>0gmixMEooq8yAAEDO}`;7ocfK8XOsgyH2#Q>)fc^yQ-*U zsJv>tn#%A$E?VyYGo0xfi$#N%wmZ{Z)@{#QQ(eE>+3)lJ)s&%zzgC;b=i!MG^KlIo z&_8hQg0bmmy3V?mH4Nl6(?4Op_+hpq8@9Cn$sfC_w>F*g`OY~@inCbRKLpt=fRBUE zTt2TtAA(OE9Q5hMDGiR&WsbZR#hJQ-XVAwy zpL|_HQeN#7m5Rd&3b-WztwmeGlT1W^FlIafY%r_`PMU`iGO}k-e3852DGoG)&Azqg z+=ht_HG_p$4Y)Itl11ml<3kez8<>wAI*TqXLyaY%Doh)8<@J>f4A&H?l4IkO;=9JK z9y3sJ%yNxNnPJv~5ZH^*q!BsPf$RwsA_}+>q*X47;Nyq8&y8)_P_w@9&_F)(h-i}e zY;27AOODo}P0Pr@e#C$D4xewwE$qh;pPdVzmKexgaLmDhf^#G`IJiY~yU$i`-+xRp zx6S*%qGaat{dEgPwZ%2ipx^)G;mVT-l*Z}`NZ9IH24b>{JFD>i{}NujU<3@|+H8v8 zVv{ilnOw>M=K}Ss!TkzFQu3qJ#x?cp^42sKF>lgYjnv~uMO|>yk)n={UA4Jzb?F~U zyk?&d-im>(;zf7EZ^xM+n-`hg$>8>6$IAs3yhkoWF`8uDJhJ(zyR3A3hd$ksYXLYD zLz=mkbbZJ6QiN#ci45)jGomwe>uS~L!lsEz;78?UTXG7l>FJpshc!D7eo#5l1X$+! zX8A(EGOSpjt#21L*sfoJnoWu3h7HudT^$Ol1~RJ6tZC&F!{fr`f2| zl#SL@4VGl6cKQ5&@R%)bx5erPpDmjHMzk4x){IWVL<~rSJ(CHf2!`d2z-o<+PICTF zOVZU(P&2NSTB`O@QAKrK8E_$fzJS8uz*Q??a2R7{;eRVKRr&FmD5=vL* zZy%Z5Nxgwkn2YQ_eI33-9T`$V)6n>nEY0_r(Sp;jcb~~y)jaHJhP?aBU;eVu74uqN zE^?XYJaxMlLJ&Iih(@`)%3Xo12lJF$;J0dEC*t235491=D#|=-8JAj{}e4_K0h3PJ9d6mN2*4h5;HG$>5zAI>FcEhMLu6q0lcMz&$|Iw zZWn=Viu0FbbR5DaH}QK5@Fec+YrBqhYqgWYnq&1|)$CoLT;9ID$`l2m9Ytb?QiZq31u&7vQH z6k1rxLgY1kj&J5}5`+C#=s+6I+rdtv=)%gV93rk8tit1 z5&p5!4*uqzegSg$PvDjo6+IZU(@JsD#~td(Qn153+&%-3leyx>iexB$$c_~4>3)QH z(PT8M^`;Z|B$Znh57m`sdy9sudbgR6Gn0-?g~E`bM3oohHO&bomD1$MV19VBBCWr* zvQwMXT3p!c>RnRmpcH?zQVVqQG^3W}P*8QR1sig^E^zn;7ZGr7!GA<+yU%RN$!X8E zR;N7ifH(^T&(UU6>-{iJ34L;3R)f3Mnwq?Y(rK+0mBDnZ&j%ewz+du32!GJwn>tz4 z9_quWmFVY;AJ_akbY=mLx(D7bAspk=>60Q@OK$W3N(h#e4pq(ylHi^G zl?Y{q*qgYsfrCUi{||voAmflLIFAFFsp}CCQlrv=|5U9n0*FR$G)^=TxJ0y%N&CIo ztkc1NsgoE7vFBC+z~fwAR7st4IgqR$ha#GR?@8;?opZ7 zu)S`1PXG|X{_qw?L39Xvfpy{Uf*VzO#|^6*AlRREQ%b0M7Zb^{^c;N=Hzvw z2L(999RSZWvhViy3LpqD1L#B$2=GaC&hQv?q_T^|0D*qNSi{Ed6=MP{f^H3g8G4pY ztO>>;uvSZfp^UV`sFl`@R|bEQ0C%8Y_Gi;?Ju5&RAdiArwk`;9!1@3e0Zq-y2HTOU z6(TyxNrHn#5aNJ?K4v3Oo6gRFHqbBsf#oAy6B%fL5*F>kOqd9S^wFSQsC7e#1f$}U zCLCv=ANN;L`z95SJsc5aKsx@qqv>QYzQD!|ge~Z>p2$bOj*7#vAqpb{I(+J(pMMpV z&iWLp<+<3ioBG-GC-~>T35q?tf%x(T*5VL!#JLEVt|G8kNEHnA967b=XXz9GmO@OwlMb9hKEQ2)-S3w|vqeSeQ`rkFt0i)-Fyn4!}t}b=aH!QrVfBW&sMXA?T-+1RY6XnZ$XR1flX+=()Q{=H+hF4J95;Q&Ur~gL(4)U)D^eyp6W5cKWzt6v57FlL>A- zVD*l})Gk!7pxA&@H6FmiMdD{UIrg06MVs3?wiTm+$*s8NY@Dbh6)1Nh&^E zeF94gOUEBd5h~8U!S5SQfkN{K{?7u1=D~G_tnm6$4D#l{s|IA3M0nMz=k_1k{lq9} zeWaoFWwZZ2>hxq$@nl!WWO><+4x{D;X;s0lhP=#-7g2fX`$fe_Ma{;_ijB2ZBW07x zM-mjcy1Xtyj;l*2AmyLHZimyJJ5^Ao6tS=r6n6A0uZLHauQS)PRpkr?C0E|zJ?f-i z#H)iN4Fnl-q_H24PIy5XOa0@`Hv?rP{R`%5zJ%Oy3s<{B0m*#E)vIXz>);?^5lm!3 zcH5EVf=?sJlG{b!-FU;wo9@TOBmD&P8>k&yy%kOOQVaGpp14|2I_4JCd&tiEeNYaw zn|fsWYpheeXaKKZCW#jkl(j45GU6~Z7Jc(Y6U;#FzS6;p??){5P)vDZy?aBuC~}1d z9|qdy!6Z83J%IM3XcZ^$8zhDp?*Ssqe0oLc?(WVVWo0`$dv=vFM?G2ge0P?;0LQPJ zhbu^F2fky?FR)lW`KW^k)OEBDyu}P{L@ra!!D`|HnofyS%q2sW_os+u94_$4&bu0B z=v@T%BiunI$|c+;z^f-A``PmewV`B3XV=cMW_pmh84i7CG~G)5pLej5)Nfm>J!Jr7 zf-g*eNpFVVhH`Mo{2^N-0l^)ib_2lgeEiRu?V)uWz5j=FVu9_J2qhani?-r=O$RTC zN#673^i5G{SCa}#1ULr1bweu?71+>-%!HkUC}`H31gjLZVo)c2BPgB94wer>6@^Qx zud)q#TtZQcad`wa6kf-8u67#n4%Ojms>dE&KauK*z5uIgz?nUl#9}Oz?3$3WNv<^s z>Lw~Fa>?{tX0nc}nJDkf)zX1S1H}@YxYJ+3R6*p$Y7+k>f@2{#1Jct!_Zy+%(Yqgp zRZA%BeQ_+bP~xg2RAuPkO$(_$0#y>q`E@X>4*xt*CE=V~hZtbEy5XxNocHPA%_R9b zTP023E<)#pE^00N`=RQATjtM2rsl!wx(#_^{mFWiuCMWmbSO|?oZxYiclTv9mD-UemJZ#O+ zhm?bc%Do}#8|di}jdl{p-9VonCy?ZuVp}FF0{Kdv2Eov`%=w}sA{s;h7vzVr^j&Cm zJOs#rn|OR&u&Gh9nnrQl^|4)R%<|g$7yj+}xI~T7USwO-mU*i>UZ>P~+FbRmC+Ee* zYm{0~dtN3vo#dGiCo8MZ+|6^ydWdp;{W=2GRH6KW9LfybS#J_u@ZWAf9E> ze}lij5C0i%F=4VMyzYUC>FEF81AktP|Njr*KNn74g1Mg`!QVfK{|xqo{yy;Hhz3>w z{Cn5*XD~w-eg4Dv&sO;Nh4}YB0^T43&f`4MXE5&$t?U~32|nvU88DcXr(`4Mofu$T zgqE?)0fh0wpW(p5KZX40^7QRwoMFP1asoIBatZJeuQRvsrh}7I&*-s3&U{C5Q;{pr z+}A;E?W-U0KA=fgW>`!)IT|w%yw&%62C7$WcIU+8yQ~9SMF-4ErNyjLnx6#6a=Wd= zo6Wm-Y&m|%yc4qa)@y3(J61U;+5DwL?*6hAomQzbp46nLs#Pf^KmzZ~Uzi{g8}rA| z`<&9KyP-eXzk$~d6%%*&jSaygHmH6s?C)=Owb@s-s7&DJ217da@4lwSK3j{ksc*=j zRO*?R! z82>Wm?%Z1ZR<5_Yx5_hExAj=;1(98&Ov@{*?y2yMG)`Q*;DRJGBVFx(dS#o{ypp$zsq^2gs$r|*iE17Qk z-{8X+0HK3=jg)F!vWxbM+nt-A??J#4&Zz!W-x{}bV{*DuaZWNm^sm(`bLKGLP%+Hs zbTnO-y}5IxDnqX`3~c^vk1RQLbM}D)us1)NPK!zr*^q^0@vit}$A{whOaFk6o8AY1 zvrm+RIDUy{Fqh2iF?*6d$+G0WdPj|Rd7rkgU(?@D=QK@ySG2ML|DaFP--kN;<-&>F z1HD~PR6>|f5%8H8!<*w_cuRZ`rar;-$2hp}s2_9RF$3IpR6Fp4dR(keL(A1M8X5r{BVO=4JR) zGN{7f|BrE9v=_0Pi@78QA_)f#3iwn86aCoX3u7g90YX&^kf}_76NVG2To&f9`ybz@ z7;R!1Rqr7(6(UuE+92gljIO3*4<^{N8=TS%{8M0QBDpwLRRZL79Eu2HLL`^T#T@z! z*(hOEB`gqA)R`9tw;V*oDt}2qg@9T`{UDfF1tXFFGIwwEEqe&L>R**X?5b2Dw`%%h z(IQwa#EwDuIM@u)RL~iN%OaGmV}8}5t|!jDLG1&M)$kSp$LjRc)X2Y&tlhN%(X7hK zZo&6S({Eyym7Kc~;TM9(*w8fy2g>2J7ICcZeCc3)Pk>_8BxG3K_ETSMS8V`LOl{-{ zR>&hJFtUhZ1=4~CWAF(o1CkBsjE){pSzIs+ z;|ly1F|ITqBffc(vF;fHbRtJZl&d*&kG!na^iE3gBcP~b|O_E6*U0Pba}SDS}Nk@o9XtiKHZYW>X_M@C1lN?zAK8wm?y$*0q= z&wZJ=Ibv4oGj>4nH?7y zE)C*kP2Vj#2$CU$kCzK;El3yu&3J%COWdB`ilK7RLsE;7q1Cn}b(epq z=q7Yc7{7sXq;{^zSyq;smSfO65KXJ0@^xUSA&Z~JJS{ysF}ahUID}r$MaBqht~E7w_zmw>ngeP{OlJE=Tre{P9k2@CFazbLA~m+zeu*EDGA$ z9IIeKD( z=15*B2L4mI{ho^FSrm@2EPqV+sLcdAvBxX@Zr5X{KBguUT&n!)b9C{RHs>N0qox0hT=hFAWmIiK zQb}RU)(Um%LCpD@ehzcKz<%WHkwQqsN8@E-aF+EIEr0*_Pp%k_42JWxulS@l=AB5n zVR!~mT)_M~LvI8dLdMLmCqg@9$^3Q^EFZ`H646I4TwPShvcL8U$zRuts3&e$tZNtY zzoyS){uknZ;D`X(07+7Cc)lFcP8eV!`mvV|Eg6Xnw+A?2w~5}rbRRXYY0+Uo>@o?zh(B_;FfaprAH)kg+;jTb zA5jxGZW*dx@4afEAV;1edIGp%o7UXOyy3~P=+iYCEXs->Qax>|^?P%d6|Y%WTBKCO z#HY+(GII5piki!;%YZ81s>OCVErMH3KsHpt{uLw?1jTTM7#3vLmf>o|5-VgL1eVy; zu3gOk6=axo=~~P-L_&0G*Y9=p7O!15=JSo+2!*uT0&p&hi5EnODJI7?FfoQ8yl^hY z!TpFU_PgIcuyj>Kve=Q==3TEix?TYKBfc2Eo6HlTn^_(7$3ckSadFi22~wwovZ}a@ zj}MuAm_hXju&QJSUL2}v=2=w+U{u+FS%u9#DZ6XCV(UVdR>j7Bh1NZK`ZLjP zSa*aZvz`VyuiJ?Jhj%zOAB-1EWl70|-(nW+?mClu_H8O^)&8Hq>MijM)Yc6an6mF- z&KRglNxE96!k>Lz>f>?$=NwSnX6`F0?#;{XE_Aos+NmF2Z%8Z9i{!TSG!qqt*ZKqc zb+APo+~Bc%d$-gX*lMuEK_n~5ix(bS+=E$Gzxq{E9>=nJN%Fg=kAN1hKA0F^Z44ERaoM)|CRE3;ca#fOiGBIJqg~j{5ZU zctvck#Joz3p);EtT}#x(E{7*QY027>jZLNf z8cS1vdo}$e=3W_rSp$8ULNfg;;9nWId=T6Y@vm}hdr;yrX_3#$!O8~y6;P~L4p!N! zjJrlh?@(sW#KXE9k+2XMi+ILcVlAv4s@iLj%y&}x4F3n zL$1>pxtKp7eq^6wL*vlClKnm(U(El;Wz^^9>Wu&a!=26afS{_c*yumJ!6@Ww-*$yI>D z-AfoGp>J_G_!sRWc$X8o9`sjp9}c@WyfF0N$}3DF6ZBHJ2sZ&axTl63Wvvn1PtL^;%Ww^JPo^eEUXiG3f)MTfxKz(h(e zqeqVikgH!&_rcp0pAfe4&!LW;e-}0bX#FN;!vXs-5*v;`!vk=NkPnxke)7f1;jIxE zak)!%7mrAL7Y8sbxETT#<_OD*`wq??c2mEYzJ|>n2rCYqqi~KSa33537je9}+PhvF zTDeJp7GY*w?85)qDednRAVpY1f)hdNa9M5~Us4P4qf6lgxlqI?B1&>ZGHmN~~Fi{KTrMsz1(@*1{ zpJ2Ikcdn83jn5p z&t(iY@THpw?Y)O?AdEU{65|ZZsXP7$WDiCe7!7sqCxj15(UaI#z|UfthE#A99eUC~ zNxgoTl6j6t8)^;#C&cG_f4HCd2@5ndY_EY|5S26i7-rewE>1GZ6#@)E{&^wC#`ynm zZs+xp;f40W+bH{b zFHn4h)cG6}k1g*bGVwyIdXxdaz;f~U*ItMV3z-Bu1wEMaFf$p?LErtNbF-g==;`0D?JSM;aZdcKM}_bK(; zV-bt_W2BO2_E5glpObo?=jUN>iNw$o5CY-DDe7-;za1#!fu(mHTf#4)UT40dTgPq` zl<*9x;F(?2L*HY*#GY~i^Yt{adqN;WlB7Z42~hSN_W%3M?VAsTllC-2rZ?v8kGpA$ zpoT}pJskV8*c$$EvO`7f(=h!BuQuV%5exy&CcM^23T~}woF5Y0mu~Z)rtaBQnv#6a zbL(3-dVxdNi%R%hyUmTGHPGhF_3F2`ipz&8p^|6*ic5I6h1Bpc%jy&MEv9^i^4%mT z-s$Rd|4T{N1Xb=2qq;pUL#LuDPCXI*XH>IWmvc3HoBa={V5jAoxL`-Q(+8MKhu=eC zE*9bCdGULjb_Vn5%uN|z-yiK8hposm>d^0ejy{2-9b`~fz^Oyd z3B0<0Fs-50IequiEMpeIX6<)n1EW_?BSv|<1HsZ)e>SPhiBfzH# zco2If7FHbt8dN9$Xv!fvK0~F9DR=%ixW`I-p$sRI{~uv>GUD8|b8NfNDp~YL zupQw&fV^y#Oo+wbzBDdh>Np=>5{v!?l|ZDDm@f$~R|=z@F~HXbPzV1v)q$|s3x6In zOQqodge?Fgyp@@`WMEDP*M%SR)dN9kBi9cGK^+`cOE6z>m1v}*;wO9&j3Y`Q*M)L# z=4@AJl^HT$ArKIr0yD>g_547LZlBW$n-e?>T}}lE>yeJh(3-bz@VwcOY2!-WME_?I zO5KC&$Rp_)D_q2UjgpRlETzylsS74A1pFLdI0(@oRF0E7h=8cvodkF71S4;eGKe|> z+eLWID12uqet*XHIh09nGzE3ik?xo}p5v@RU3H=rRd(jP+)J^aa^K9{Unl$(S+zz3 zEqCB0IrAf~=MMKZN(wtEKgb$mQ9J*CvWUQ?HG=QIt))&_T#YkZ%AW(|Rm5ebf5Cn8 zt!!sB&SbmSitU*!$CG>o$`DxdD=9()tiVVmyfK0lV~CD;4*LX*_bkk8!u%j`B;dMW zFA62(0171RbR;|_q@&$WS*oKGj1!GLSJj34($1-;9cj#);78OX;_P^8P0R}&^|&39 zUZb{{Go~tew?cp(v_-1g)tMCLNPlcl6_sA2R5LeQ+;tI~CFyy;LcISdNdZ{G0CzzE zpA*grvH*Z;P-;j6TPt7yAXVe{Hhljdp`MZg+y`jsczRlQwk>GCNNSnSnRxqJDu!zh zPU@onL-8`Y^$wL5Uai-y^US@T&NS+>bIns!bFST< zcQkKxbxrokb*NHBwPU^ny`Z*ZYcAyMDfoE!^cii6_a+>3Kp_!2gj5i@CF6p2J2Yj4 zN8rKRbPw~H|2LVP_L}6H-aS(cYuzk9Fbf*<%vV^mb3%H?9dxVGb<7_*Bl7_m=?1`t z0(5gh&-7N9(gA4W%2`@);<1 zGi(tyT#?j8sGVeokVQk8;YKTX5wB&w^1m*xu+=#$mI1+L>K_7ac$Q7H%N?>we0!A{ zE}J@);iV@#{CSW*58fuVL05ahDS>x_&^2M*W>SSuzsR}?-P0f-vPz%l`i6*>aW7*f z^&!h9{h9yIo<`^@GIh1J#axomI6>XXHW!(iBhZvI8BxgD7qxRYg)H1R2IxMrFW01Z zG4FC6NapdXvn%&AsJGqFWdPpxkXtYe$Icwr$oayd4M0MQf}e1$B4l!{Tq;mk^0Th9 zY2z(hZjY52L*txiYlZ>(lN=)LsdD`{SJ_uMDr!@c<}F|z{T-*~#qapfLDQ=Jn-u9G zi#a!_Z51=Eu9i3)3bll~=9?fLr{9$%!umSl&Z{0(X&eub-+b=N972fjgrjHhDRjYO zH)yR7oXJFuufk6u?YieSu1IHU;TURg29BZ891H1+b!{ee#gc}fLm%8;3&)U^`IuJ% z`>5no&;fB;Dxy#$UI^KNRvE}ouV9k}j;7=9B@s&nWjZtapx86h(FzF~ zG|uWCOPrID9I~qxrz0^N(H!Xi2=U{Mg`eRrB;>6?-nJ-c;2M^*$&p+nG#^=`u zIHS}M{w4%>Bz?FMT=fPRi5-eVNJjmq zt(84JCI0_|5JcSx{oyh-{ueo8xJa)!|6RN-{7*v9xRTMDu+aJ&lQU-!EX90_f(6DQgKz|D`n^9K7$6W4$Zq((o(+6XX%g4` zjiyYx(3RIsE$LpK?I_7-TItuu#sa0-S^jB1gmrAtm}WEF!O0(RmoXH`Z3wDSF;|?o;C2sGQvI& z03tKx;*!%{=PI{tKRQpUQ->z1Px!YwRLr}`bKl-q*Dk7qzI#)zbIuEA&*930a;Z+4@`}#LI z560CaY|RGHoUr~Hf+Nz*=qL_J1RM?8jzKw415V6q*0`x~EL76vf67|W0U5dfQdSq$ z$|mFf-MoJOCm|Ux8LkdflV+9|aap~% zf-%@X&2Ba!fvQues4S`LY{lfJI(2U`G)0M^tW0<5lgz5&s2#W=24ZyDim8vu#?rxwM zfxS8XjdU*5BDr9RdYHKme$8T7d~?JZ&m8bteB$B)CSFXQcSF@F!+E=~786~o(xhiR zj{9ze`LF0Eopp$9r^q-Qbi;C0dhA^0Fzj9){)RS-8CHXm^jY+VE%#hOyTw0tI=tyx z5kf0}Ch%g^kx%jvXo~QpIy^lGXY+yRdjqH@Xczm4sGuQeQViV;xZrBZv)~&`_I{NMN1v>iW?>nwmDK%yt z%qIaYW$QspRCO(kS{5}B@NAQr=gH)G{u5;-xP6KqF%!94Z-MTz_1)(xw{O0F{@`XX zfH!U?17yRLxIajwUmxKOP;jT)&d@pg7S_{sB{j`{3!JvPG&SzUdVS@t5hHE{>#)pd zj%w$%0&^^K+HH09>tY=xomDj&rBY+jMgfZft$!h|y7^iT*E=Tj71)Ak?$(B^eZUTd zT~C*fFWOZnX5NXs?%5CJmE2DM=F&5~+J$=?T2V*XX2b!%w!D06>nsZ9+H3+9^KGqT z39c&W8jJN3zXy612B8UXxT5;>N>oGJ7+pdLbrWu0@q3+5=JnPLxM}9C$hw)IFIk(_ zkj5NhzQbuppUDN0`M#_r(7Pu#ZASe{9p!4(PJx2V!(80P)!&yA)VI-z=Kv$b1nt~N z?E4u*73c%CE5Q>K$tYyYg3sFzL)xN-MJdVWeqY7{<_tt7ccYv-1np9%t`QtWRB+$a zMVhRj5Tj`5nd^mmt zIvdbq$S}2E6=M3#_XYih!VDlQx$A`gfWQR*GuFUtihp@(1#5+1tbcw`Poi*h_}(ev z?cvT5l?RywolAd}{uwON3fSO4)F#d%?1>}ndV!u)oBwO$;KCu)Db7S{z3*O?&Rn08 zoSgb7HGvxFh8arw#kyzwPYVon@A7glvp4>sscoF4!dmugY?m|FGiu&k-rV9McXq&m zkhQ*)O@Ot^!CvHE8=q}L5EWtpf3mZ6GC0+hZW!!2A^5*+LV)>;m~*o_&w;5q0gH&@ z{U62uv1!+yZ@v-kAg(jNBJncD2-!;Bz{LQ*hy6f?vQ-bn!zRdR`q>kZphf?M5j<%3 zxOrZ_FkP25be#o2DYq_>`R=S{=$di`%;O1ZY-#qlGr_44$PC-z z%egm!9eSeHMUBFISa_y)Wi^W#qk!MaP^fE!Al48|;pzq_lOA+E8eHJac|UT2vtnOb zPSK)`>0rlMw%FY7e*L$A9WTY-Ac|}Eci3&|=DA6G+Movd`hMP^v(!L~>XRGFFJoxm z9sIs~0CwFesF1+cX^M_6L6Jmm|IrPb7V>CH4nu zHWYyIuBXhkgaU9-pHnL6=_}oHsgQL0U7e<9RH*we{jOG*v&2(tW}fe;FD;;|jCw7i z0r;nTX9aI7Ma*~rbKaJxwcy3TFEx1pIWo0K{ECY5nB+sIfl0jPN{ z(zP-}yJKy^QdQOP4yHq(9@XZ8zJf=+#fdU^Dc{wY%znzut?3`tYqJWE{iWk7 z-Hx@z%T%s5xBpJ0s_35aasPdsimMSGmkyI6kct(iv7MP_bwESxuKlBClV%62EA{M- zzi><1NiaFQvVNF`fnH|e4&<=1(9w-u*}LH9>2Rl98r2x6pk~$@=g7H?+_( z?r|Kl>{g6{gsN5z8$WNZwB{muMa@^`S16;{0#&=3{@3$LmonFLi+{Qf2# zq|mkxFRN%a8lu;flD~I7%{-FKPM&DnkYXzom_;(>KaxrG$APmJ zMuKY(5V-NJEyj|bY@O9oIh3Tkm5)a@Sl=@49gguSwm+h-`%f;ydRaUbdPKq^9D z;jYldKN1cF6g1cuzj>MQfI@kKCIu2(Yz5h1ItqU)frJZw9~()&t)au~#soGwgd=pw z7(1aD_#F-4%g5le@q7pV)3IeBsSIlf7U<3)ImV3*8y0-#sYnCFgr6yxB{u!8cnf?o zyn_l<+=AN(a-S3~0UE(2(uIxSIuMXTd@%Abt{^!+0ApjX_!xF5dee<=wS!y&IAIYC zKtd7}G^BhB@sD_|_+!DWE~+yi75#$@{S^)FnlBX!Iyd4FFZ5Ov%yu4R4^&x5dN$2v zz4|{ z3{JYV>j@ZqRJAI-;@GCcsQu36RJVIuqN$jPUNj}?e#+!>*)#LmDM_2u8n0_v?{c<1 z&tbLkFO?isV>m-Vod>EJ26Pyt_E%|N^pI=cJ}#srwn z>I`!f;fRS*FM1R7t;pvhL%_PZ=&CP;1pR{RTQRnXWs*cO7RZ$b$} z2EdVhFWCm(pNBfnkn0~dPNBmLurw5y;2J1gLL9n+=fO#~!JRx@nymL;J>XU(&zaBs zG$1B@QJXn2Fvfg@Gk&-ez!Qh~0c|zun&3zkJR**Gga#x<6%5ZZ#2!I}z?#7)?sB)kF9bf2x-K6!L*Yw#Qb(I%ljdh5i%A(J)XMtF?)`Tkp}+OnD! zf0^L^=SbC66Wsg&ZuVVLqHsaxf|m33dNe)mUb(Zhv&zl#3<&odo#Q6VS__=zpfam! zq*Z|^8+47em19Yu5qZ}Jq?a6;ZCIXA#E`jp64VU|cXQ{@IJEE3HjH$@38TJ5Fi7uT z0#RlfsTU*#KV1(Z_VmYC3O-`tlhzCm^Kl5ca#32g=zjVJHA10xo*)p{lvENXP@(%Z zs(W4%e)K8q_z*PnFDhPgAK0cA?IQ&Vp_gG4;7)DOq95b=@og#-J7>`G#Q_(71|3{^6lxd`GDTOEeRS7H1YKgf}C*|t-jfK=l1%&XjBKL||1 zxqd=91S9@%=ZY^S=*_GX5EWLR69$HFeFrP)Bi#oL#!WmiI@GN7_yoHOI_jwoyVIfenpgK_nvA!Ve zB?dn41LX^P_kzX6@QTP~#usHqPu{w1MEt3#Z3S^s#r8${Os?Ky$wyky z_e31c=};*J;xlt~_660oJ2)+9qT;YW!=OR+@3V`f< z1}eT04fU*AuW#JU&K?urIrWzkF$x9D!`yH(x+ZwmXQrhrNZi7#1vn-I1m?pOyRT4( zc+!OjR|H5_R^X5xEaZCGD5Pt@;*l{++#V1x66gJUYZPrtvr#ov+ zkO_A@;My!hA7{2uAtPZu;tD)tee8Rdij}2ni}=jee*_Rb={ zvy4Gqqn>#TJIbY)`>_@twoYOD#G+b@i&!3F-~U`C5&R~;KnL||D(_0J&Mfb9W~kfD z-$qNR(Qb3*n9U9{X1;B=nOQcdRJxbu+Z&Zi&y{P=#7JEx;9lz4d@UNUBkIo_l&y0S zNVt@_u#^${Zc3urxKprFt6uCJyoy~ohcVMVH~KmNp)Y+VNsW}Z+pKEMs-{N)*iyDeRkChi4=Z7|(Uw1t zir>8?f9kK2qR2Un-Rk8qwxx$nZHRP%={hhdKUHKmMrnx(vp+YV~)pe?9ORPQ!4y_C*7Fn z`}g;>B-9mGz`Qd5lLw2;#OaZfi|z;J^qJ?Uf)25W)|0j?h3>y(lsZ>+)g~i{zBHPY< zvA?-NTwPR)$BrMV+BQTj-#EIwcf;Pnom-K7Tgm?xxKJ@!w?57RtY;RJmCXZ*1vm<_ z6Fwk$o6Wk|yvqu6e%U-O=cl`{F~gmpw{Rg~R$u=^mJ*=^n4dyCB9dcRLqICD`=%e1 zd>6Dp+&E(Q8JnYYVqrLoe1WXX_P@0Gf2vP zzIVuO|EstQTv?_FNv!ZCN2BnP zL$V|w0JXWIJ8f#S_~Gz-j+FFhEXUm>VC!prKDgqeNXP7|~!gFgQUW;H;qFqM^L zP~wYNDkqnD@^t~m0>gs>LSLcok^yT6&JZbhHhNkmzQ}>C^umB-RCn3Zo|35q@uxH4 zt+9$A@p5toeW8deu45&qKuR<8U}N!ME!DDIi=-Y=Exju`2>1(iu}bB#$tk zVII2Hs!L;u74_DUoz7)NcGi5~IgZ@w_-3DPGa8zzF=w!A>IS)ju{|hO!;iEGCz-^( zWf1>ymZOT@1!1QX%6T7@ zpjVSQ0p>+uN02KE;EV<3D>`^xLJ)S8O7XR~ON;8Ypp7!j)@n^Vk{5*@S2b$~78NnC zNhSd?+D=X=DkkYrcVx7vwI<}`61TRtwR<75#V5qYx3miYBgBe&5Z~oy1KJYye(wr& zf@kdrJYtJ!m)01J97&Gh>aJ^RLfcGAotpan_J#S(2&-2jZI6T@wbw;fig~nZ2iA+> zK_pzAJSc&F^sx7W_(1Hv(yWUFiz3tqVN9S?;Cxo0^SNV(c3>ubZ2oJ!%-5_ov}7*z zTrj#+HADMX<^?Dgu__5lM^;7b7|FwF_PPmH0a z;=a^-l^dJa9FjgHGYh8$tvN7f|J>vq)C7w_!FiQ{&MSbOoLQw+BP&uqZ6D+8#va3#KZ+6$}hBFW4^Er!=FxL{OQE^ zqpKoLiSL|L?1@Xa7yhuv8P(x!^Nt$L7x%ImH(^J!wPl=@dqoP>7b(nn-1~0$r^(yr6 zYuiAm_$7mBI-N?Lkf2KS37>$WyoY%U&%g*`cEGOVCwlVDkl?N!$J9V#O4-W`a^2oX zZo0}@iodDay`<}^28Ye&sMy)bJWQW`>`rQj({9bp&)#y4n99z!x;)t}6J;eE8a&;q zjAey2gC$gn&-XU=Wae!w3C?-~IT(%r?DC_K9x6nFfKtZ^lx4H!G#_YdKhWgJ%(9p7 z>_DW$?`5!tGm68BZY+{jb4yvxrdX-|F1loJueSQmPjBlC*7DQbsxwD+JABF@`DxVO*W8IXsqR3rX_Hfa?DRuU;9C?%?w`8hJGUE343aID zfW`EX_oEy7khK+5kyuuo&EhrH;(d$ORLFjil<@1TNqJaRzpuUhP!pP+CTT(oyOCNv zHUTS}ZSr66dUKscMNYKDo62)X7A2YF@wpZC8%s+kTJbnF|JyZXR6==2qoX=HRXeZ9 z;qZDL*-*G4tG-D;2~r1JHGGl7tqPk3p@q1>p&suV&3YiYCbN9G)1b3vfmOetUu51X zEXZ|%Wm6n_n=LmRZa})7rLj=2?2#*t68>*!YC#+RoOF`EiNS z)k_w3E^SX!r6^SKWepiQ3la1YBeyer>3mt~Kh+w?CPv39+iM&0%H)Z0NumjHXXB#&1G_q|Sy+&3us$r#(q(|~ zgPYd0moYEU9m62J8p&SY8Y`C-WzzVh;)>4du9cn*t(ARgiABZ`6;MVn z{a5i@phIC0vj;~j94gs(#fvYB;#l)z z7|$nuAKaaZdwOC+sTZ6AIr+viaB?|3RZ+wx#K(8`cC1|6E1bm1x_f(*vwB_{8_gc4 z5mteBCR&Z;++>vA;Akd@9y2txJlgDQVNfJTucgYIAht=e8%ORG5;LDajcLWy^@a_;RT)+d;!fIJw4cyP*wA$*e>Hd$m78I*D4FBUD_a-lRU{|GDMWk4eG9u+9X+(- z1UqF>(uI#jiu$0ufOV(w(%jL-^JP>@iZZpWzI>6{l$b1EFjtx=udMHFSv69%w+ByN z^uJwIO38~)$%U`ZYfoQNdm?Z>g=a>ynd--2WevQyK{ zaqS6K(i_)3!$f0Q!-37Z{-)MqUeaftAyz{Yek%R|B=n%0joBgu8v{srFSKNklzV30 zF8f$1|8e^+|M!TLch0g!cv;V!39N9GoxAih7DeQU1bO83l?@E<2$3uZJb+0sA@T%p3Y^7?KLU9)0mL|v@3S~vM3IDh zQv4AI-LWh)FY8BNP8}d}RnI^)3zqCS_s)o`oKP(y789p?K+=V4~?&<{w!I1B{#asa;GiJeRTWI$w}x<8FHJ8 zy;7zIZSpX>wM4M;sFzJpehO+Dq6kXK?BBM1Q>cQoG;+e{|67tP zSUo)SfQ-nUMeU#ofe}`ZABGl5Q&_$h;bgR+3;Do=v{3Z|GXe=iPx=b19y<9$JE@w( zx)_COB6P$nY1kxv1#hR2hE1ZSTvyfR{cX?T_VrVLmj3cTXy25kVB4xL-rz>P>wU9! zazf|N3lb@yRxG~)!A+5Ro^V;I0%L-x8o=9+paucNO6H0ec0rLyyB}d*4C;AO>U0#6 zO<29Tre$1}WX<-9nI!sZouzl1`8YGlH$cHe_2%G~Ckf6{==Y0u;=-|lrm}cNQfqNa zyl-yrl2Qky2z2zp)iB%uuY`5A1T%XGvBzu**@&PHenSq|QkQu>E?L=i)?6K(WZcwv z)$Nj`Zcho(r{!RquP)Djvt-Qw3)C#WpxVs5*h!kj>$GaKiS*+!!sGB`S5>iUv~Tn@ zr!A`R`5!0m!Oa_&^=*!c$*Wv$QLC&*L?eVaKD`rbVgoFqDG*)E-1NTLlu^Ll8oOL@ z=?2kWhI$RKH3sC{SedwZ2~6}G+H@eYIw>Uu6#|W@9~gxCh-7HM-{CD`D*dZ6NT*a@ zBaGvU_R@>T~}`B0UCV+w!tWlkVD_lWFMbAgJ>;AiVkTmlg_gnz zaYzNnZFG!&U=9#~UgBrE&ZUhtkDpB3lHK8)dlX7lT5OU$E-ldq9g@pdPKqpUGTt3kI8oxC z3RgC8%ZDu|SYI5Nu75v@-JNMp4pL@VS*yi;>T>_hGZX6v2$~8LS}>YtAA$6ZzQ) zZpgB7N8;jOYe~mZ(@9~=m06#WK&O=ug9`ena2a(S=vRo}NL)6fo=GjfEEk=P-1E14 zG_EaJ6G^B4`?%FF-5R-{Z;0Ty`7y!Radlz<@8em9TsZVQ8>dVcDaJKdR6v;*cG(5TlcZsDh81wUN5YZN*f=Jl7WQXyhy9v$C2K7QE8yq}k2 zs;gf=-vMtQYcfC!Xkdu(peXT9&;oTE73}KZbC4u(sQ-OfJlY8*Xvm0$#@#LW418LA z9T45vSqx~K2aRA@H0s797a-cO;}%$HZUbp_2%X~ZQQ*}WKWKqVC556SBPYo7(>zz`B!D-%rmoVA^jYfL*wy3(e)QZ<_rPr zPIe{QX>+;87nMWi9lRs<1Edb0am)z-L?^Guxu{`XtQ|9{iB4Y731wR7?8bMo*ym^IS_lgo$<4^J z;imw?Eg|*dEm6JNEn=R%jB54%xcEm^edVYxKr;1oF!oinzVdP!zFla`&V!7c*}?;2 zG>VN9FXZDqJ1XFxq+VqqMAj?GMI-DVoW_t?8TrMLxBKj<+`F=BWvjj^cu;mRzW8;poGFi zRM1C!3G_jouLMyalMODfN}$18P@;SZCC5$U`pn6iTOuhkr>bo6y4bd&Tj;kSMXqZT z)s_&)J6s9Jt?T4<5fw1zb+%*#KMNxA-vsiL>|WTN0y*AgH9%`Y-kS)$Onejeva&vv zWw<1w26LP0c35LKFGId{j4HvyXW5<;@PgOvFq&snVpGRJNSTK?JRj4DT@J5I_?rdb zF2|$paGV}E^tlo3EBIz{)SYS2+3&bdowasN?*Mf&Np7`eS8i)jF%9(V{V!6RY-WSa zrt|-Tx<);(tZ!3aPtv>;xw2%9a%FM-I!~?7_d9(1c?L@W`JGS#m^?zczl9Wc9D9t) zyR0Prw^KPctLM#Iv1tV>j6)y{u01x09>Mm&b5Gf*&$7A6K0{_;$9SU^WXljlHGo&5 zXyHwQycF{m=yozt=Sgexyo9);1EmASRoTwUu~BQMv2Ihke^~U)_;bwf3g?x~(Whxl z7In-#mC>M~_=!5#Sn1^(tc$$G&GW=@jioKilamU-d>=5!i}Oo{w3=w3b){dgPF1R4 zD^34n`V_qgbb$L8%tSy@j_@b)-2z@ZuLOTJ`H?Qeo}*L(*V26A@yyPwMeYKpqi937 z4yZV*uRcYc%uG`3RV2yNjcVqfTeGz_c{#PwqUcIzV^x{Y_cZ$KPp66f;4MhdYJx9C zuwJsBO~crZQ78jo zE=bV1h~5vu{VqB~0uh$DKGYX8n38n@;Z~+#5V7QB;Jhd8SN1%YEoA$H&}qym$$k8T zPUf|1zkd*;SNznW`qj?<4;)r9Tj?4r%vQou2b!`l?|%3p(cph+bdza-doLiL1=}BO zX6(7>e**M?1Q|U3gS1+T*!6HCQuchiPG`I0&Xk7i%9SoxcHNEJl*|$O# zi3-!cH?JU@+GIEB?Xb6>*{jnR_7{43(+k!OY(!g{`JIfK*B2YN=VRqae3}&mLAHGu zOJ)S0go%B@lF4v&k2cj6iYAHK{)2&v`YVu4HviVm@{yX^q{E%;E=XR7NUlSDhM?Pb z5#5Qtg48EO`@o*6@ID{JhB(f%#)M;t+xF1lAh6*?`+CoA9UC3kcFm}^rf>Jw)duE8 z(GAQ$Z+IbHqe*{<+QwYW%E;8EtCV!>R2`*G*|>LX)#!@CwaeG81arQhnyg59?G~jb zMPoKVeEK&WoxcH@Qn=eyH;K}M%?!Y(Ko}ww%G2oIbe$=>dc_V;R<@_fA-Oq{Dy~(?a~hgabY%WYqaMikB|`8j z^6nM3h+OD#QyO=s9vv7tOG>)4GtGMQja!vKHaW2RLX6j7%`%$7uWV-QS3etb=l6PC z9qFlyJgi^6H%DyK>g?J2Es#9`uUax6){NXq1npHW8{$lY&RIxRBX;s4jUP~bE8M!0 z`CVr>pp>X|NUa^J8NCrTgUaplgtYbY+IPsQ`B(K(T1G6A!4|ft08`V@E&ivtnPE9r z8{YxT({2my@ug1d6?OOa-73tBL`XB~YoHmbLskhhqrj`Q;3c0;Kk~>NC+V|5im!FS zTgTDs5{Hq_RpYA4y)&!qt&U4LxRf$LU#4~9cc8j%LEV@Dj(~^od^e^eRctpVXc0S` z{w7mf2f-d|*M{|H!fWgROQ3j+UiRWuCTR)A-2&(EY$o8EWnleyELEii!1~#a>A?w4lY7Hk}SpozRg#JC2p0rcLcw3M|z20#(D+! z0{s@t%BGiGpCk@X62BbUy)BYTSJtpCf-d1r+Q?26uLEt!#0Oy>Ou{3ZD$TY;q@hWK zYJVD0Ntfs(OfwQdLDj%q6i3uKhhXKVhbW47z8(K z;;I>m2$D5|CTLr7$`KP`x#T^biQxZ&Z#gsLBl9$MrklLZgA_s;LQ0?l9cWM|;xA<% zgTB?!rIec>hj!b{kU*e`;>>#EpbCtZnMXnhjUoFuq$yCK>3;-cFsuFF$iA6*T!g?r z(7ssE%M?%`;h=<28||fhA)W8}82|!{k$Vw1LE*I$%P=C>V-ehdOAFW_EIen#7rM`> zmbh1JFr7%l?=8zANu*2ddW*wY2GxpvDJmJm;EMCZD_?rxT(`iN*b6heAxeKabNY4k9-4bk{O~=s_1ryF> z*q$;$vOnrA?|EeM+NTsLMYeceddK?PvgImx)^kEK3eS2}y2Lo6`JVUEk`-z5Ziy+) z_ro)Q417wqRx1XZmR;A_*-_BCz?#iFYI&(VMigD156MTi&Unm{u>|+F(3vuGD?1XH zmjZr^Rv|`w3#>vGdQ}?8M|cIpeUtFoAy*ULsfjX$1jo6n1zYcy;)U=I`Fp@~{9jh^ zV5Xy4C)i^u5qd2BV335ss77zh1)Ncwj-V9?W={v*3zGQ37ePV7N+YohYq!R%5{TW9 z+v=TqUEBz4!*ovWu!q!zEdtpM=o$5^yy(Qk-vi0{yYiq>+7TQ*G>a0yCzxFkKOT^d zeq>4~{@YX!2*%&2a&sx%HtuQ_VpfD3)dL_AVs#5R4yKU%`v{^1fyn$}DTu_<1K~Fs zaYB*J+u(x#(&N%&fy<3cFA5Y0y5-2t;tjjX8FJroKQ^&C17TqJ)*3|--o}7>u$LY( zZSY1794A4$@WPVEPmz0%%+i=?O72}*YK5-uI*@S++y}A8kT#?5lImJ@@P(P@3N%Z8n)*`Lna^z2!Ci zj)tVTJ;R=-eUO0$geWnNhga}2WMXaL3#E>Eabp7bVyZ(pe4Jo@^coSr*rYhHKhlXq z;;<8FWG-Q8DiqOp5q`HV-GPNlUuEsWY+tPZ&!*%=`0+%T07~dDbA#iGaQ(lEbpghOo=mOb3?bGG}r9#ceh{lK)Q79`YoKoiSrTqmp!63b1@pC}{y-|wJ z-l~u&zkE>GeX)D!gs8PHAjlphUVr^t28ZHYbdpVz=~N z^8AY@G*dKD07V%UK==24B+z}QFQ~%nBM#n;D2s;e6yvx?qo@-(Fu=lx&LjOID=gP` zq2dRf+oq+oMEGpRWhc^OQ*vq$6!-rkS=Zgm>_f3J%Gj#RqMWWQYi&CU8O;?C1rc$4 zW@Gj2ctfVwWGpF&3}quaDyGSY{l=*0Y7%GFqXA!}ltlI50lW@4;^@ktIKDz9!~cY< z5aJSw_$P?9yzcYRS00_JZT2UFIvJ*pQ!)ewn}W?*AK5G-3mv%L*w`6&9i-7D2AR43 zkiZp0H(q<1#k@d0U@Sm!Eh+Hy|Hcjii30hd{k)WU{KdVEi^G#=UN0?z@WdU`zZ_T8 zms}_ACN%s}=u{n{&I!5dTdIu>Y++|(9G)dS}pQMwTMjn*) zkGwBnViNuULO_VHE~+$(!yMw7mp*uD|3y5&i#^3EVbcQFjTSOP|s$RE!6^g71UUk1pL^)aVy=_#QaD_UYxw`IY|n6a*`{r(GbE@l=sFiQb zYlV>-IMYqSRf3PE^xuRaW_a1ISr-P^55g*Gg;4s918{C@v|4(Bm3mGw|I}L64-9gD z<5vfG-WA>~7OGG!x)Mq*OSEysS;3xWUv_yxqIzm%Ok@lcsqY`sqN!XD9^_@#&iB4m zDviv5R|QmH&64zstq?3|K-~ljD362P#0wL|_$thP%M<*Ow#0amo^X8vp#hEHd7kj? zQAj03;2l=qN(D@WpnDYNLAD5Ij35p|t7@+RJ@9t)1(M}{+Lut`dlN+nzKgwbgD)#9 zri%PZ#}jdNw(5Q->LN=eCZx-Wq8?ja9Cr&Uaf_xseTnBQ!6L}uuOr9 z3x3|zSepXt+)2y`Sww*8fCG4V^^I1RhPgV}zcb%QoJtDqolw1IurTN&*6%&XLdD{#i27$X{FjRd$N23E|3aAs+@GRbO6vua{yFU?z4v$`lMMI->yU4^75CqkXfL0!Dz}jhz2_MB<)NiqT~=0tX^QBPb~hzfZfLjwDMx!R zTMFHCu}TvAj%8!vvsF;fX2X^g-^T`VJSz3cd>6dXMEGFw(~(A#@hS^$PI6X}Pd9qz zT0>&`D!5y-ve2D@<5gPgQz!`BpHdP^J0md^+x@1ifO(ez&}f8SKEEuY2qL_an$UnO zonT?Z#0J_GGw*=PoZGa*-N?dH3C~*@840FPlze3F4pJpa^MW>k#Gy2eLQA76pF4Fw;#j+Fe4U1JLlDiq94bl*_F)Y-`9dfKyoX3Iox zi26V?(mDx2xSAsSdH86ggWn3Fe3{-Nwgha%R|jsM$gd^W%L@pe%LBoYz7*U$&+SZ% zpIe3@lr0)H69_L(*s*9eo2>%t3sBRxMSi0b-a?Dtpi$_t6YO;n$4PKr2@)+l#r(|m zm&o*)nXA>d@|s1CM)u0+d1c)CW*66Cu`olyhR;+NrBtl1|H&{{V=XS-@{_Crr1OrR zp&YfI+#Zz+-uEEBJ?~Z(;SRmY^7VM?OzXzff{x~)yhe7<=y#S77O!M_F5Su``;VO| zDX{VPnU*>|2^uHJoqEU4;JhnL698DUX(#G+ciQq&b4+6`J2QB59ciq^@XDrt-&R_B zw|*V8l!l=IcTCXDQ4~5NS+U-t*D4mSY$!3FYX{=(6@-dv&jM3unp8;g5&;@ya6AhOJn;n!@(tc8 z5p7@~KP5Jb`!QotQZPq(C3q05kUC*oFANY&pOPl0=;IJW=*%ePKF z2Np1WvvM;)g?A0}9tYul9*!I%_QSooNBmHIVuP<0Qz?lQ#^P9R?mRy?Z+UIga+gtW z09NX#UTANWyGH6V;DJhi?{UJ~h2pMsvY2Bkfs*V(cF%E1Q!Vy1?(Z*Wm#wM02+txn z?L~N^NC!bSS4UO|9<_cqooY_uMK6N3hAk)PUCAqWx;gs}OgHz*APZEU6phvAaP8Sa zaN^AnDh~D7WXGaQE&a@^;yd>>7!4LHkCAK<6dBFLI5BO@xMo#VdSkXo*~9Es){;|@ z!*M)1!*4fIeBNhEw`-E1k(WY>J86x?>!$p`2R-;!H^|>iPJP_dBD=$@fmh##kV)qQ z^r4Zr3F)gmuc#`l={0dR{bFUjX=`+t%`Sq}NBEubi8`%WLTG-c3`3fVUIvN+tqIL( zBq$2LZXjDZK#|j`Uteayna!73Ow2%lf}c8+NBL3=P_tzb*eGRW0m0>>r%6?AHJ8U0 zwFcLWP>I3FO<6(F+8Upjk|gf3BzVZ?0UkK=jdd5ngW4ZXqjQ2g(5r!CsM&$dA*XB} z)}L)FRZL_~nwM9WkH%oI(QWdZGG?M1M7p%AfnlY=sQ(+(y2su^6)UClL4eN%wN%yD zw>OD5oc!pHOIvvk4}hEfPjE%swme#q8t=tKe*EhHi7;6`q0XJttWFeNz%chG`T{6w zRQpoil4IOb(dz;4c?Y~}dN;W0iq5F>?ujS1q2DMjKhdNovw!%j5!9mWQuq0?EgOzZ ziFBLOgopgb$XSBYKeH3LE19#oaD*5W(=7!BmUKEn8ZHfY@{6`+^Omhi@Xe`>u2vHPhBJGh;c=H4Xi4uP7wF@k zvu^pUY{T-(_RXawTiRPURVWx~9_-Z$A5CKaHR?`zUS5&AtuDus{DPcU>q~c>ggFi^{Rv&YOvNy~m#+6ur56k)hC)`CXbn}zAi2uS2_%E;n<}eL2-5i{bOVYPaItW6 zxFJy1*ZJh&l+MQTtou$dsfij*^-!|W6uYg5UYXUHl$Mq9DpX4ij{aA+n)~+2ua%lO zqwNdDPntYHdoW-9#bWSF7*Mi}ysb zQ(^HFS0n~fTv3;pP)eb!PfW(ebXk79L8@EX^&nXrd@~V|joJa%xXO?UuUo4GoqAWujgCk^-TSQWKOiaRp3yvM!*Mi7(%o z+2ArHKTn?a4_gv6Mswa^W9?9}VuMU`V?kjAay%N zN+}}$SX|McO0rd@)FusxD$(90&^vsg2!2u!6acS5?8xc`2KWj8sgu&Oh`s`l<(5U!h_QGo0H!L|`A9+sEbf@t&pyPj+m%bBIE-9Zu9QLCMm z1M9>dWxM%xVq6({f+)7mX-&E$=T`V|SgJ|XYpW^z6)CBry<#%@8XqZF9g0#FP!y=` zDFJS^f#qFHbdac~VXRPtdIp6_3HlSz0iW0r87SgJsScS0B1UV6mX_75r-;m0t<7u6 zv4n(Icz(zXYAx&fhdg?*Fkw`g{3cptR%@~*F3Ftg7TpqyH<~935?+XP`iT=j2is}>#h!r@o;})izHIZ_ z>eLlA-djmfd+uXT!rsujrtmU%RkPmXzTK-#R*l*DFUtQQ*^cS6XL?xN{(XC?a{;nfc(n`K`1P(4vk6m2Tg%IER!b);1z<&M&|!*rGm} z0KwG&KY_jC?RZ)@09#lp7gI#KHYGdKJS*7uN$G*7HIR{n`UCasWw}|I6onGEx9lL= z@7YLk#zD3LZUJ{4VwnIYkx$S27gX^QS*V)h^^BnXMU@|7O|yZheVC81w3J;yYNqxL zIB5ads%7g2uH;w2ps0UHwceQsTohjda-!%tf;lT zvY}Wd5#Abi@?vmoCa#c^CHYmw`C+oxm=<-E`89ZL$5C|&OgShK;o&QO3xI!`PKO2d zX=QeCM}^Y||F!#M7=9;Ior?MwVbCFhWVW{^>VL;!QRTZYp_wXa>-uGtOY-*(*JK3y*5hVCR4p(IT9_410fts|>DePHPRgjP4|%fuz$z?8+rb43WQ$n`-@T z4x2r&pAMK+Y`A^pb+}jG7S>NDneH8MagWL*+}B*#*9G-EJiVgg8Q$IAv=w5@FnEoa`S|DJ!Yt2aVs$$@zrCwhpH% zp5gB1!4o^$Fmg#5B?9n+JFC5kRX(0P1hh*9J%Qi$r1I8FJHHf#SilbXvK8z?AE2`B zki)<6_j%Q#90fOBOi=ICD4%G>(?{ZcnS4Q>Qh)FrfIFUKDeM$(nxhzV*T~`2;SwSh z$w~O0CHoFePjn8&Z1O?Le(F&T4x;x-R>HGM1m3HTc{6=<{bunikzL`@XQs8uf|b{LB;au(ligPc8<1A+K;-QXIV3*)1X@xSb`dYa&C$ zV8i(RrQG?bn4D_$3F36d@pOfnJSajsM>rJkx-W+)JDv+cM3yK-5)=<&Ib)MXTtFrp zA1(PgvA-imP5%5y@gwzHz$*p+XS?)i!TaIt5a+d|*r~zEEfAr3xPrPt{)m?65SK`B zh_>S3FGd-nzh2K2$Ks!7@vY&080>AA@fZ_s3MS6Hm&Sr)f$cUUVRyGlEa2eM4m`KE ztzV27E55V;;48Z*|CU@D*D6A0`J=m|w$JiM1>f0M)#`&$F)Eb{E^Ru0WxP~51{x*} z?EWICjHfzAC?XlFWk9I###*o z1K<9zg{|OCy^$C%{$A@r-0+Z+4CsMp;ZaL4AZ9|l zKgOX3xm_GW5gA7!oMn&Ay6@Q+(YmASm%|Er`Et<(ha_9pEIR6`K?ky?g>uiM1FjU4 zR-;Yvydhx92TW$w5lgTrDb627a>oU7?mtPIxa71{9e>5-hUK3EMtE;zhoonc4vujU z!?%rn*uZNZ$4C<4EdMmXUK)GTg3;vJ;k#<-MZSe&0*lljt)pKuS& z*Tlzb(0N9_^DC~OM+9j~gaFXam2TLR;Or?GSaxzabp7(po6+kKC5Bm;zp~}UrKBdp zh~n_XxRbXhLrW7ZOTbutD_agXfjtnf6(NcN@tJvCmJoO;xHtxUB$~n(^VRZz4E|!D zl$LGAb$4$(3N?2TcZ_~2x(a0J70B722! z91f}~uBVO-d8;=_d<+IEKFo?06*BbRFu?qZyRdRaKu zHE=IW_YDs}wbQ*%Z}|(qc7xWnG2}I1`!&G7qA_`}=&);oOLlN6IbWdT2FU%KEE&Ul zR(XrGsr_ZUj^Z_ne~?9hU$wtxhP1N4Rx&m0;6jmqMI%6evv9cU(i zvhR%kxl)1u$bA9eHsvxc{-w8>>FHUOySm8Q$6?Raa#uL{BL>!y1_s~M=>UCOcG=td6 zA{+-Jgo1)5JRSNbX%l=VpEIXn>v8%!XrLGa1GNZnjox8sOw{=7hiovF_W#!9i2e&BX<-zEkvnzL?R2!d=jKW8vWd9{{z#vxo5315de;nv&QTEa`JQ9qg7S4u*5EQCK0cSlgDmNUyhs`L0%#AF zub0eteZqi3Dz-^k18Fduv8!1MkOtw6%+0NNS(T$ZWx3q%1KZ8=2kXRVOXUq7N1s*+{ixeW!~6kfKyE5i{CrzM*BR6VHObHclB z0j#|5+CTFUJk#$ddjJuNhpa`Ef?ybPiYbUP&E9NlO{`h5W8`rdl#9J$Vf<)#ticlW zaqA5kutJndpa;OmA$7{$oX_>hAD}cJm7{?=%!<6F7b$z7`$F8R#tnB)jm$Qi#>&g= zZCNb|bu(jQriPC0lQt*g$&qALX3J6%l!JkhyH}fo0&X-&GaafVsCaQKpo0_f+(>Hc zCEO^dKki0QP@(fwjfTNk6LGxBd` zu0YugE~hW3YQ{HrxWbv8W#73r?K+Vkv&e_Msdv~ffcqe>?|oC=Jt^1uiYW8p#FO-- zH_hZ;P{^1JK^bt1u_mE*Rs3iQ%R%l*oNUVKt2NnzVxx)2J99oD5T9c|2Z&)$i66xL zoW$=1Gj{U4Fq3hKc{P(m?GXb_W+o~ZHBACHsYsPY1Kiny7sp$fIOH;cB?Uqa2L{Pb zRPY8M863?w#V9j^sqX0JLbcj6N2c}LHrmyY9gM7*Zuv}pb`|ddlmUc|baFOGN4h`@ z7u-0>XH#h_6#7mongrNIla(G1-Wk)fJUT2nZXA4KV?DFvGbY)hIjcb(J3fkhcPjO! za{))13F19elFOQ04Pts=ok1@out-OiOLAHjgJleBNDhXIvb9)Ot|1Aok&CiwzQA%j zO>yA|4VkUN6_q+ua6DpTamHkryNFXJq~srpD}_nExbCQy?rsHfCK#^1_Phx=j9>+C zIG{FB6k?ZsJ?lIqO<<2`a5F1&OGb;P0Lm@H!bTTLdq^$?#^~^aB5*ia2)(kILHTfr zB~1$@mqNj%Hx@|m>ub2L0vgGo)jZUY`CiD;7bK44$i5b$$P*zo!!@dxBkt>9J;#s< zngAd1;tTrvw*ek_W~wMIGU*edEH@?^A=}3HUMckP!C1|{JEK{niW10*th+UpFVIx-A+Im`fIVK$7(rEnlhAQyX3cLa0I_~HDpgGPJDn^1| z;dP+R-|kgcNa&=uJ2C!aFP-WEnI33?r$v5m2`MVa^aiwHD7c=4;H&y`5Nk>a#<8l_ z;s#gYJP5~+{7z=~PEx{R5o$1tmsh43gK=$EZl>FRn39CVfB&us1q{+8^CU|JI|1$? zmTJrzPDb%o%AbneL@%C=0e4Ky~ z#%fLdrYx5;BR$uhG1gnE>1k-jF42~<6=kK%%O;?WCccP!GS{5uc3CVge6tYGe-`Lc zCDh;rjpa}3i1UijE0tjB*RugpeSwR@7JzJ$Y67^k6)5ba~F}3b2Q+jLZ z=nnSG_;J@5ZA@XtSSLO!H_k!=v3wN$1;7mNgod_5{|Z(UF;>Wy9c+!zk){w$Cw(f^ zb%YK|-Yr%+*cbSie`bfaWKqYKlA?`mh4Ygu`k+gtnEmzWL)kEl!jWcmI<06xG|-42 zF`JxJ0tIyyON*?=Y$!~9KO=Rz++cT_)13Y@%b+4~H9(Ae21NbdG+O9us|gZScbT00 zLxWg1yBd2*Yig3_7E(wn`je7kJuk33!SSh{p{Rm>0ZyKSq#;>43^8?r3XK*Dqa!0C z-)bEmZko9~!j#=n@ubU&;u7>2S|ZgViT%w_J>?(zgxV~C*4XkBw3c63XJK#+R=qs6 zWHv>_-JO!skx4YxXqikqI!oAH+B`v`)CP$cLVUe8DVeG&U+R(P6BSV1Zvr1?j{vx_ z0wVSCBECow{h3t};hf!)P_~eQo70h8xCmFrf5hrNojk1QPX7rVDM`f?JZ)mJzX%pe zS|FX6F4?YNMO%tA! z!tjsfyH0MC&V`v6C9^Y~^9uD^`Lq<1S!Xaku5PfG%*|faH$RiRM|y|nILt{lW@eb6 z=D$|x;C^Lkd}?Z9QdCrNuWQqa&0A64&V=NmrKQ!2T_H!LX?mRvPYKzOtSwwtxolVA zE{G%U%uY?s%rF=-Ad(9-a1k1$GO%8i%mtYSHP4J>%C(Eq0ci-?M+3H@HyQ*YBHS+ z_wlw@o-ZnO^;c94xD2+3xw8hOHzuSQlSt$z!kAu?8KG#I{)H=)4OK^~lWMaMEL0yg z%`0?vWM_4_bDAtO(QONj@hMr+DqEt)L@}b7`c&L83Ab!vVA2L)1h-8#)0wc)1 z=W%p8gt>;$3E>S>c^ZTre4_Q4CrY z%irvNcSmN0yJE*HFBFwgiEFf-@kv}1p21k-G+J0{PK58&s?3(`qB$z<(%56Bc|}y< z+8bda4=-@l86a>yZxv@KLk&q<1JNZ{p%M`98m5xBj7b8?OX|I36<{M|fbDp_GwJEw zIDzGqG7?X~CQcMA(==hFBkll{J}s&?2nqLA8&&P+- z!_XyX4%%nSFd0Cfj#p$*mS?HiJ_Du&qT5XtC@bLJOp0T-m%B?^yxNo0PyOb4F;hTP z6_;o8X3+nLncm1ee(2IrjlOW^|A3mq%>8}$k9WmaPL3On%!RWdaBE3qPK78IA9T_u z9o(yy1J~gTVorIJw|%!JyX(o+HPt=Gelt|VxxO682zwFkU?Wy}1=*nTIvR|W+Hdz~ zN=wn5x2I?@tts!w&j1wZV2M-+UM-PI5FW$^nodi#97N7}9WA0Tu0ql()u2qk5vK70 zoR)&Iqy$R&neMaBf#Su*#d-PMnw+Zq>`eC~5Xek1WdT^2qN5fRi!AouCvirIYpyg$D>6e821tC z;+`bv1@UD%AaMrE)pfc+UV-4ncr-2^e7XU#jTcsQ>n5S}2JMZ@mL0Noj7x3qWftc! z@MLq66&JyU8CWieOn*Kmuz^9ZRLg}2>MJyLGIx{}IP*##DL5TllU_0}3&OE+1v3ao zXdk%u&2^1j_CM<4q!)oBZnb1&!xGI*v?V(|&F;=vT*lQbPe{t`$+LGPB&4TPCi(4> z%px>=B0X{|@W^+WdVOY=zMJq$EUN?PRb+-|Hh9*84)D56!m|Um0Ab=BD@>9|27lhs zRHEFz@I8h#3%DtH!&tT47<;&I63i1m8mjUj& z0P&&NI6-Y$RSAkJZLiO)oD!!U z7>g&aCcT@`KOQ{RG>C)?^v4Vx$j%hCaqpn1eACm-%@@|qFh>`D0g`1xT4!g{sDpkG(J-D(8)_ zprC&%R62GGI8a)q0}jzZ%@mLsUJQh|(D-yr$2rawMJe<0F%{YT(MvC()ugA6>-0kO zs-qz-%S%DhPPaky>CjJyKRreg3swAS{HIes^H~qUuMs{Ty68&MlIIsr@cDS(j?J1q zJ_K-)-2j0Nx|j;c9Oj8510-_e15F9?ax9BUUk;u@&1p?YnVUy=ZeZltOQ?rT6XX{2 z)C#^^$DlLYyx@}@=^#%)!h!6E0KE#LdRlR3tiW}|)Ff9(!!@{J1K7+(g^$4};n@#K zrmb-(&Q(pw`NilIu6VwS%VPd-XvlNQ8pgo8Kud&#Av_S0FD%K^5#WxWPT#WSsYEp^ z#jiu?yrG?ac#fuq?>;59-riRtG);=-rHsUtWF(A3TBy9w13zN|x~SG$euuAjW5yb_ zqZk7(f9Pr(QslR~I5)G#e@Onw0*5mhBZFQSp~AOwR23#rWFATNn}Hu+Oc4`C;8UB1 z-3@p}Lmf4qX6k)6V&hPzl#wcB|2NJH{@wh*;CjvwNo1;vHB_^gWG}D`hbJkQ@PGKpgL2%Yu6} z5DP?p+b^o>3%D<2?~eRE@(InX0`PA*J$if+$EILuh2J8BU%-T8vfjg*iQODua1i7B zo9n|@@NNG8!eW znuRW>?OrAz+0~-um3$nyH0bqT$+eQ(Z%VqVWF0{Jq_8Wp4s?ED-I-+pN6r zkm`G||Ho%`Ob#NJwUZT$%iipM(p(u9V^~{%@Gif_9hBYwJo0JOQB`#b_kZY9D46MT zR~xzKJ8DR+xK5j7GWu%8@3^r;+*R~iabD5zTe+Fp&SI|0?5xS3?}Re(w&me^ahW*H zqOJuz(}YScUoG~8D8gSVpgd5Zf>yQ`=72&O_Oh*0xSxs^kWf5!LtD(v|Na~*LWF%eq+$tXx4#PzX8J1a{bJGXi9p0HP9PW^4)$G9xvP}B5J*DyZ?H7u zZ;>B0Z1W${t@2-1RqAdE?OG zsHy3OOt;e+Xpna|^xZ_r79dj#^GDrHW3h7%GR!MNzE9^@mSmCwB+ zNJvU|8J_a&ru#O%xv~khKgPtbOd2y2xSCYO@M|7r<}O@2J#;*VyBK&C%$vyuD3#v3 zJG8vCWvS=RX>WJTk5j5N?0r&beS?}jD4br?KSwM8$xFbs(*4_5Lnf}39xljA&&s1K z=#>%i(fnO~1=v&s)=ClQ`1|1GtCS9g8+NV*^IQ(Ib;>t2tkPLFSM53-9Sm8mz8Ei- z52+|=TRe4U!EMZMuD(3|55DE|(#J`bp{SDY)N^KMI@T}m6QloTah}sxDlSw@JMHN< zH>E&AXneF_9+P{0hur{N8?YHcQ2#^#sEAS%)=`M8J2Iz-xFZ;Osm@zC4fA<|NZP$n zDgFAY>UeHJqqw26lmiu`5jd{^*JQkZ=J9VEx=pR|gR8r(1oEKu;XOqEZyk=$TN0js*(h z3-+35?$qQ^L6~7`v29YgzLotQZW&KrC*9|h`5qI(OI!~z6}y559qI;Rx#2(zWZ#Ya zD)O$w=pQ5k!88XCJp`jP)(CggQf(Y9{Fc207~!p-xLTXinnvIz1YWSL!D|W}LBwA2 z)@TQLV{eT9C-Q=JS=p>2&s8Q&JbwslGFqG+^cu390n>;0`H3=I6NPyf@9^bc9*v&h zoatl?Lxckks)#}oveiP-G8!ucWjjZ!BR?o;cX7*^$HpmGjtU8if!;d>1IHf0%W(kY zSx^Crec3L7_SoIWQkg`4CPjemqze*k5#gh7_(Cj@)|PV51agz2?CRb~B!!iP+!ChD zKj7jqkBzhB^pplHBP3c49djKph9nhGK&)6r}ci z6kQ<5eaVywD+DoHjoBP1fGb)Q$lDNjet#9M@xPwxHBdGaAwcJTfMCLsLhWF`30}ko zP1r$X{F8X<$GXU$Y8U20QQL$C*f3f!n7D_jAMo0(R@j3j7XAR{$;ig>r}bW|j=(Id1DG8U zofq_~kKV#7neYn0K&4IsKP98C>pXV`@92Dttmq8l+;-ss8P7z%g{=-Eu|F?j9 zq%w5+w5iiWqoDpSN)sOT*v+d}RnJu4Tv*qTe~Yrdu(-{LHc9J__BL-Y#FUzIEAxkk zpSpl9L`KI%TtI|7Zj#}B$~KrCgnJKxJA4+5$s1?(?ZzhS}4XF#bN!9}xr33GH=b;KsJCkB0A&B67Dn$&q z$4^J}5FOFAA?jbL6SxkrY*4ZbsX7wyaa;wo|C~3@Uv~=Fu?X(+A?TyE| z)zW*ow=*_hjfsa@IV-kg8dQ1k7@`MUt2!e?<6>jun=4&)I%IxAfHWRB{URA;wTxfV@TM^riI z^yPJDb|0Ue>oQy08$RZslW1qkh58qTSOolZxw`isP-*Ldu=ZvmG<642XjQ*xuFN@GMu)JUWN_ z=$u9qt4>T*V|3!eLuxiRy|+vi+mu^a6BDU7&uQ_>gQkr>(7C=OC8JD4iE1?zqLPe+ z>;b?d4Xi6#GemTTFwv1NwGnDgp=ui=MPf3vlTsKn zgH^(08d_Bg&Lni^8S(SL{D<*SDp5z*`R;l14j-KN*o#-*hE@SQ#i@BXq@=B_B(reu z4^Qk-;wW1fb4BtI8xMJ;WKgp1Vg`N~LJA6g=#0|kWnq=_KM0i!)m03*(Lu&)FlQZ3 zRw%KX~px!G-w=^+}k(>lL1Ia#SrN>W2TmsV<&d@lVODhM~D4B#gGn)bk* ze8WzWOovaT;3{-`B(@QriJi_$lP@Lh36N4hrh_ zyn*tf1rFwbG|gzv+#equrHPM@j%Pk@s9lzq-DVGoNH96A4dogQJgvAGOo`90JuIEZ zYWVHSD(|rn%cGJ<1;J;bI|vHt9Pp5FtOeMK@DNpg1THzb0;(vP;Z4lVOoq{H+r9NU z*#4ukc5j?F!;l;O$bF0smbKKFSZ24F<^j6&nS)PBl@47r9HDF zLv^Xet(2einH6gqDt6sEE7c4%gwJ6zfitm<2A?Emr13vX&Jz{00(!hX1KrG|>5S>( zPcBxq6-N=WB&t}Yt;G=;sxjCtb^b7Pr`aE&v`{AjHOM>p3ZO}4U@wA?8szI9__}c- zY6x#BWh^=PMTVsWe68u?&B4!+&n1~|6=aJPc6On}fbWd;8tm^S; z;ss-McBz*r*RF9o=6%T;>A!$Oa9t&Eh~(_Ge@hVg`km6xA&)PK@^T1n#Zc>Pj1B}$ z5`zg*-GNRp>bN*f4D+zTX3uat%RA~!q4hP=&lfa;TGeS2v<5cM5p@fSa=YC15{8`o ztkgsLekMFyjCA)Rv>Bya47OM)|2ZXXHHN93jV#XvQcrJdM2Oy*WiVRh_b0%+s0ke)ct^-1)PbZH%wow#-zQN%!^}r9 zf$g3ikaJME=aY1pkA1>U%+F%#qI^dF>+S^t_s0gZ8TuDbYc|iY{|x=?X(Bdj7tjohe~{U840P1v9J)9Czrxgf+Mit?Z9H`B4V}iKoaXxbeHe|rc4bE9RCPr z2wK$l3SyEqW5FbE;m5oJ1?ku)O_Ox9xOZtw7}lp}fO@Ckzf&b(EP)NP1>sIo+*kUo z6#Mmv_%B8IU?B2P;9bBL9tvWigB=Lr zH)5IuEf~QcpSyAELs_s<=;};JtD#ObxfkwX0$r&HIKD-uBh;#>y{c$+tlc`au61T+=@jXd zs;t_YJcu>mzC7+B>2}D@;XR)cmVThuS9Lpsw&Fn?0ej#QQF|5hmOjgvmhLKA@Poo! z?&IB}rYhTyP)HZb=InY@F4I6m)r{1Hl!U2=BNy}+%~q{CG9YfGYO%JUXW?zmU>?-R z=jxJ?Wm&h@@5DoxA_>dx!ah zz8qoI7fwcm_w~-;y_s9@6;9f~pTq_|Nh@84n6p2=bnc!I0#nEcn#!urpNb40=xJ`F zP~Cn?IO{AMOQ4D*JOMz7(bH?$vuA($+r9TR%IHyuMJa47cP1iyaj&i>mmYTfB)viQ zZ)_alFo4ShK0jtK(P_Y8(%&HU6YW2{>*%91=z+5J+#77%`3I(>u$o!vIuHUR5U}V# z9S@&O2VOPiS{~PcGhHsdgOwoN6Wy;reAm;h{Gppr*t=}}g$JjH)y~e))j;43M;H3x zP{OyedEiNF@R_2QAOaL0Dt!*=x1F2!`==gyv6J$fd>c}I!fM*@Ts1wceols7ICkJ5 zUhjb4gX}n)FzLCUpsd~JdOyDWv%dWJy=8Gm4~rO-gARo7|=n> z=A!xoPb?e#^Dq9|%b)uLl!wCEq>j5cgrktA1vY(cA%%GP0lYE}Q$k+JCVNlDDoyXt z3gqNo)OF(%gWR|OeEW-j{^-M~62-B}9d~b>8Zx8DW)MzZaS&RZ>B&3Tlu1uMgcjX= zel_>^|9&*Gggz(vO=u=EuqhpVX6LZE7?32i(6#1`&N?z0i@ zvmss#45I;5%%*nSyFEOlZDE$74ko~2W?pp=kG8?IR#;e__iTKNdTmM|+%g$Dbmx;h zxtF-Va96nx*Yby-Kx5%iM?D zFSqb#--8aKMXaIoM>mAYx~R+gMZQ z1N*~}Z1$3DLqjPg%7#NY!H(}Uq@FcTdirnCYmcA5joS;bU*yj0<4=DSJ%SFg=FSHX zgd%qC61!12eIq`dk@Q~s4plRM1z!Q8n@FmYMiI-G+Qq0?{h-=iQj+5+DRD4=<#gyz zp6I;v^!)sED;U%a%o!*~Ka}FR5(?;2R_IJx`1M-&-f3uX>Yi!R)Q{mG{CzlbimU(e z9w-UI4+wfz$SLqUGQP(7Tbk6U*~;?s#I5}!)E`Kh=gPbNH-a3bO9gpJ&z zC*n?^$Jab@2>y9u%@cd!pC{H}KgV$GVP>&30X%lR*-@eg9Rs=xk3Ltaoi+xnQZP#$ z&>07*6%&Md888H#awP=(b4*HRanbtLlEK6571rF|(@?Rlwq$6J;w?5cu698schqLv zmymO8LB4cmYuK8Fj)+}qQ+H#@JO|s-60&NcZTilT7;8rrnywxUv2w=}RXWvbiA)lI z?cdTt=GQP8U^3AjL@O&AR7Md05t0N{AgpgbN(;D#%Ku1vif>YTBA#H{d`Q;-h0U_S2zZF)t?Stq*Z^X@}$Eb240Iu7#zgOSLKa+MG^@v&#X= z-x!_!-l#ZzZfC)dZdLD#u&7efB?xnm~Nk6;;X%|P$<$m|rBitY60$WOEpe5*C<`YRI{D&Gw zZ<^FPx5DH$xz#3z0-Y>gzrK9FW>@^&s`YD&7bfmWU@i`sjqAF$ZJV{xtRHIMz8%gm zNoF%frW;R$K;VBkajL_ibTGzypS|zCXYWOl2Oc>0;Dh+n^w;*HDUyePdnE>`E*ec) zzAfh=?meW3EQB6~qQ9X>C5-etuu1UueuqLOFX2;FqW9UyKg|%|n?%>XzE*;MCjALM z7Xg={pK8P&|Y!0(c1rxs%KQ7GqEjP55M1Ea%m zCriSZWcaLDiKH0r5r2SMM{+h0fdDa}b>6V8Jux9M1znWZuB+L)>F|=P9P_uq_0AN1 zcIK@0?k&Abo~k`{8$Qc??JASO`~yc12-MhfS19rCn3YX}{|?~GO=yn5fN$`dgzjDLzrdJkPAz?3|NV*)omI*jdu!+PvMIu1_-RPa#cO za&j63of(`PU=A^FO2Q;lB@&1sIwC=U!QDnfc|UTz-PH8T^h1X>-G`pyTF-3SgtlG* zXlKFC^Z{j30CcUdMGikY(XeW89CVRdrhxlxbh){<*S3FS8w^o5Y2WXZt+* zGh-Wyi7j7Iy5R?qBT}bknN4Y$81z$sEAQF})4=?V$QOwO6IVeVGEWj5!GH`Q9{5k= zD?op=H6=OIfMObLz3YqCHs85<*G+3TDxT`eu$c5|X$Hoc(mg*}ziCzdP~oL>mw&Q* z!Ruy&$&zL?SO6#B7c|2BQ6h(b1INPj5;XF~>tAsnp^uq5&(n*S=crKY*K4x7u79wxt7)y&DNYWnNxwrslU!JLLyRc%m6y20iE)I zbI4{4pb7po%m7sE0YvmxAeG9?Kb3oHd(CNjppx-K z$Na?9O{;-M&zybv#gfH^uchhC<}{YCo#cS zv}nJCVNPL!0+n{6_m~{~hCtLf6zWf2c;P=Uys-0+@4ov-%zf#St;|x!4U`2Pi{Q!N zU(8a^OH2{`a-TcLeRK9KoMVA=-lyk8JJg_GE&qPug@3=mT0A)>5f|zx1iv;+%= zW=*m-p{T#WBlQX)M$&Li$;z42blM{Jw}tr$BD$-wh7ptK*!NR#T*ZDm{9hAu2Vu%&-y%Ay_X&-UEPovhDEiq~f+ z#xtkqoL=62OJ|zVWa(_G-PNQ`%>C!|scA4#YeoL@r&g}tuiKVB=b@oHzrE4(=K@Qj zuE?681*(St>Hoo80-A?`d)rIP$o?g+eJ^_bl0a zKK`xfiuB5smdf;s=(pm}?_F|F7y9}AbB=5_TY6hsdoAY8N9NqW6!63_KMyd6K{f>- zrZ)vJW77!WjC7!j56+(R;2`%mq^?=Gu(Ps~xissZ#RK=u0nGn7zq4xrhc`Lkb3is+ z!Wt?Xr!JIQC7hxh{on)1HLeJ~#OT)^+j)|?1aSfKnJW0+P{PlAqJvR!pS=0zW#-ad z+m6BHs7pM?zXOax2-A)ZBFDg9)GDVj_|5V!SdFem7MSZh=5#Gie;Ey`XC3HTcK@td z_buD^xDvgSkkr#MXTiK97jqYu0M1M9pR;R-hnV>>g&5(iGW-t&dnEJY%b#Dq{5iQ- z4fj{(689~rUJA8j6uuwyYBYTBD1hoIA#g@r`!6#E{sh_qMba#~Lj|`T$xPY3dehMt zQK1Wt$=JAK|Bkjw^cGKnSKudrx3p67!O;$c&^v#+eEHoEIS-0JPVN`*GjF0Sa2Afy zpFnTJPhcqldNa~7`YzXdd3YGUME_Pg1b+<25a=SojK_yYM@xq;@B7jI%b%TljNr46 z+lmfwo8Vxm8RCDAc^Q5V5Y$558@}#H2lMh}ZshW1B)g0baU0;9SEHlADJg*E*UT@$ zCIb#+y~L*+BbJ@W^gwU#1AU85_w+o_*U;6~(Ae48sF-(p$&%A^=i=YzJ+-j4y|=f$ ztryET%z^y`cFchwnL)MUH=|O@@q2-n(qFK#v-dJGbZjhqt*yBk4KFSE7jvm_Syf|W z(+L9EA*l=?Bl$p?*RmxxEf#ZX3EYMtN*GPEHnmTHu)64&=cCR>3gw3Naxau!w`E^M z`+F&%Jd{87Tx0>~=~Z0&vDxMYQh&{yx4Uy&M*Mwwv39dl9G)riuEfEsTvrotyEjvDk^*JYnP;?#K*=YDkIbxEyX2^ z^5L_=!Uf9#OE+&t4%6`L<)6aq^SsL#?!xdn0lwSed*D{0BdGxa&qGk(k>5GNr@GvF zq_gt}O~50I^NLGy(FtyG@4>370}Ig!IDv&v`2`nebsr=tC|Q{Tcr({0#F4 z_*sxUS{S$yEp>oikw&9053Yazub+LoZ_WE3e);OFXesJ`@kQ<=ha;~9u4mw9K*l2} z*l`51XTE#+yT5GP2B#KMA|?qm3SSAg&F0{9+0Rq-=LFWhw(Y_vOY_vjx_v3>A8FI+2OwovO_2A_*Aa?f&? z*v%ubNk&o!KYx<`yiDuF8w<4PB=_iDccJ!oPf3k;{aHy zeG6{~{*Hy)Ud7~sMGw-J*DnMF-dqzq2eBn9EArdbmoKY3@+wxApxXRNn*OuP23uE)BUm)Yte%!F$GfrG%@CiBrK&Q zDm8F~;BH}noxb5nE{ER@mUgHw7w+u6;jSr{6u4V3@8Os{iKY8EPkN0iGe233Q-GQu7?EsYqrI5$iGVtO z=jF?H{^L&{eDVnZyZSxu6Yg)AkKwz)%J^7hWqj;Ofd3|cBmItXL2e&gmSSr7$U+@W zTp1zVx%sl)YPDa^wh{`pxr%!ek`@*)u3bZzP8oK42KScmZzj85Z*^tc@_2Z+z~=;^ zIzFBWStC%rJ1>Ch*)xIYl(!cF*APoVHG!q@w|$LG``X+0H8t&TPjkD?W>-#{0@xV% zfIjpyMR|FJg?agfaB4314M-4PLitM&%n?dI{_{zYwpg(Q3A53IZ6@vkX;HIJf?!_% z26){ii2xZ(We8?>T_kl!{N8)j+RBBl%a@DiRIaT=x0jeqCB zVIbHA?{2JOFS3^8*aVxiaAtvPY5m}iuyZm)a%`Nrk6_Ee$!cu&qwXtqf9n;BU;BDM(Z(z@UzSs_}M@^VYq+h+dq5hz5bTB zpMT}Z5r~&fJ8}fF3ZKExTpQv34Hi%~(dP)87GS{K&fWF9{h$1C1DrK_8R?if?nP7# z=R-aceE{DJcwqb7NxYP=KIih@{}X!d{`>Fz`u;oNyBe?Q&|}hr(1j+6#wN2+iA(D! z)L11#NDKajJ!7cfg|A~L2Zs3Mm>TWYFj>gzo_c*sLP#iBU(V2wgcN;!&*~6a*gW(A zN==QeO|FQaJ8&u?A-a0DCa*q>39HZ3%&z|b8v7E!s)}>}Gjl>NOBS-;tRy#gB`ewP z%^pG$vXMX_1QOPSuoYxS1PX`|D%P!vD0KmPd^7W{znK#mpRjA*^tj5TT5A=le#Fw&C|6W3Nf|3v z;+2ypx2Z=_UXK3lmiWKh%P=8?VLI{c;Q(vu7tn!;8(tm|=kZGpv}zHD-e7eTVH_z{C1j#$}} z;7PVQezU)z6)SrU=)6T!bomAL& zHa9G5FxT(i+V#4vSPy8LxA$I&82lMz*h#1PDvRWw11~MB5C{1neMjH z-4!L(UHO|A)TNG$O!su#YhYq?oXdHLhx7Tcx8Z=`RX-MTmE4GMqa})RlWE|yTHtsY z&JxxjR~@-^6>0gonPcj_c89O7IwL1Dv#Ku7dDQJnNN_n5SaC*PeMRW-G4=WBqs!BM z_0=K4RrPrp6*cx0yTbth3`R)40NLEor3}NM6c8+LjM9yNw6k*gsHsoHzI^)RTZdww zYTpJ^{6lv5uI$a--J7%TVnemd3<8lW3;WivOtErdWk*0hM_~OfJV{@wSDW7Z3EK;* zxV|{F3ok`ohCQWBia-j-2I+RGxsBa`eSYL<;^j4m-3B|6%RM%Bhoa3v-p4xQ+t z5e?;w*+w-8>k^)&+0MwJ4$3WN_hn?H*l{4^CHzdu%uL~n<=-iKc}fQMatbuZC&EKd z5_mT;8mYc0)ENRFQtTrdp3Cn4(`P3d*_JgIpRm8}Zfo1UV8NcYwml1`c8?v~Jym`$ zpI2BoucCQ%@ZL~F(QS!Qae;e-S2y!>)1F7noRT!c?!dO>K!@GIZR|24B#`kklA0^xsT-S{ zUz#+jRD8c^OFnl-mOMqf$(Fn)? zM)aHB9`28q8KEc{G?QM3SKeugMNU%)%q0agSVdQ1Vb|!g~-1zqK%y9x@rMwfRLXj|H9YNt%8t!aBHdGN%#x_6vOQ6VAd z{ZPJ~y?}VG@a5o`zM#$K|GfKda3TiagC4}qf++7IawS;RB3?GYidoayar^4oqq}@8 z)*Tz?85tkzPGJj#6Jv{sP?%@D1FYwEWP*p@vS-?L{AGF!81 z4j!yIFn2D+qMd9uTZfeh6l#RfhFEeyTiLM+rOG({qW0>YdErs~;ea_Ujg2MM?Bep< zY7=c?_Oiw?>2@!iP^N@noh(Hy5W)H=q;jOO7@JvWAz68J>$LjTnvt&dakE=gGYy8#DEz9XM9FpYs zL#LC8qgyp@GBy2X&HX20Cl?G3Iw1^VvOAhRnOyryE!E!5$j!}Q=~N3mQvM_)AHoSX z;e~~Xsh}Nc<4^7?c{;v%aZb+SX11MY^uEJ_OFN5-x=LyNjZ)6BDE64hAp|M!V!ffi z+Ly35EL2;+cBZ9;EaR2t*5YUGv)P(fB^Q;H7R`@}>K5}C$!05`@Hc3kM+l!j^5VmM z{Bmvg-)Y}iv07f`Cym`mGelDG<^^NTomE~wD;IAFE1#Lmf>Yw+Qc_~$?7VtnX6D4a zyh&MElk#kKyUpfsPy{^(`_X0W#|Ss2B%I>=)|QtiOn8}9$scZGLk5t=tGdA{6;@QF z$Tq<+_0ocvjnZlyz%W7{{+&kDPw+tm~H)n5KB_3L01Mm6DQi@4dZx z1?o!e>r+z^F`-%seL!`BTVeJ=w_KV0=i1t%h>~tBN97?mE>nJ-lI*L{#uqoP*8q~a z>WgB%()|wk-*43t5@6uy#(eWS{#g6bQ5>mga6Zzr`F-bs>gsP;+3Tp6y=w&%wrrtU zj_s@BDzAWS#BMTMKb#~#vi(*gT7o;JqcQueTlZ~$d2<$sR~WgTUiHR25Z0~8ov0rp z1NJi7vha75FO)}aE>{Bwl>f@0S5GS!O!PnTm!DUjHkI!(%K0_rkg1&B&@9?j&nf>< z9>LflA=N!tSE0hc5!nfvdP?dbmKUb-7k>Zyue9p-^DeO&yh5vfn7dYP?|yReVt(ui z?R}Q6Ve29PqW!nXzohlsfI^lT63DItO|XAVnHjbZ2^i~77H1oKvwdsbzzog)RL>9Y z8Sc<`?51I}cg{wR!pPK+96(HfeJ%KTMCa#^#dvQh2S3f_#7{vFel9Z66W?S#*YKVx znim*{EK1b>nqGg{t;$iqDDS%l`XZI;7xe1sJ~6+2AEUfQrTS$(*ARmw{*&+ZCiovh zE%oP^XcHQFCOIkWn9MbOR#3oV#vZid*j`k?%c3pQvM*u zctbhn-ds++67=BJuT1pB6IstSWw$5~z}&wo>OUvuC{Vd1)&$nB$od2e9JQYHfpo`~ zlHNyu;^%nhrfpw%JZZ@MIOdfi!Mb6?yvC6Z=ScFXGyDDpo3|JDkm+$>VZjUAR$BAA zu^_mH!`%||FlSQ)?3wqN6e# z8QI7Aq$MRelXFu`Q`G3tz+jwtZ7lIl%IumMn-mci9v7ZmlAf5A9G4sxpOllPaZV?4 zWLzB)_Y_Y0TjlRSw%wu}{56-m4SMi*e?L9f^m4AA-+=1;^#>XBkcCJ^_{*D(a>&Aq z)IRkmAQ;gly6wK0W<-xX3w@99q_o2Ig%=IOJW3h_y3=ib2}M9~fOcD;*IgNTF>?LX zlD3#PVnjXwFP|!CiFqS$ZOzis)2t}nQ#e@rx>yE&Szu&#MrPYGMDUwD88YOX?rCgn zsopp_)syB)d#=nU(*~H^7)V@->3bk?rPF-PUclW!au!YHm@RX8xrk4lu zYs+AJp`J|aa1X5pbv^3mIFW)MHayfotk(#7g>!@`B-Z1qK120$xP%bT_|PrSFeZc|fMZbW2LF75YcC ztwI{_^smG&bv$_SCzKOUPb0c6d1@*LPtD~c4SMkOc@w>&mj|lnZ|A1^LkxQCfcu5c zcPhiUoj(t0EaK2+&)N#@Z~ptLZt8rk@eBH|>;uEZNd>~D&G-X5$O0b!0IM<@SrIt! z10^)6s0aLHSSA7f6IwpE1pHVeCJC?~ek?Pm zpk`8ZoYR2+WO$OIBR?3|up)Hf@bcos9P3hn1&Rz$3Jn>~))OL#_M?NZ#9DDsw7^vV zO;R?@uD3N{Ush-4_-a}bZ2t5aWnEc1?(hmfs0&nTzRZ`DAM4Mci3DtPWa99kP!?@S zQ>-0393-&$1K~J3fv7P4u(|C4G;wSmGq}anPp_u> z>Cdb&)BF7Z^(=ATs9!a-mIdYSBW8fiW1j=a!DEDJGp%6&U;y%>IIb;9U%c$1Sg6L=YY7*Bg;H8sIMqCF@^uok+L-e{;O6daC{7qH+A1^l+} zhXM#}tk17}(D9vEfbA8s<)rVx1VB?911FXWpHKRp=lhNl5BtbPzl*F7-BLRLHoA@S zvnXFA_L8J$sDbD|Lir}rAUZv}BYLF;(7=VCeOQN~M5iGJ4NbGrCk!uJ?QA*xjQcZxQ9hFoq+_3DXi$&M-FoBtn z`JoVYWSso9T|XgE5r3C;nZOY)e@*&MeNUwb(^1R<>9T2JCqav|r~tANF~6cbOnFJR ztfMExWPUa*7e_*j5lAfMTG|^A5~A|@A4cmtL2y9FV}v4lit!J4?!@s%j2O5k!f0GS z40YlkE7%u^buoyrb`r6P^F9MxWJ4PpupOz%k}>tu>c)lu6)vRzhtN0TL>9F;;JFiQ zuXso{Su#c{Ffmsc`^QF$$c!PxrI^-I!3h9HnKv`jX3xw*#H9Dq4px59J2JYU>)26O9u7GXc%cJNq+{u0o5<)$+wh#8MG8| zfPVT5e)h#XGlgZHgg@MIo2e#k&q&F#<&vWO(dOQH6XJI)SEeip?)w3z`AsY4y;?*;OZ)B5tyXHE|;UT z5ZJ&THp=153hYySUI9;H!(vC_03^_MDUPuMspLSyqiPdHFH%SDgHKahT3A%7&)*$l z#hw)N6sWvv%qu%6R_rGzrxm-IehOJ@AdKzU6_hLTLyUokfq_e)3-fAYVf}F9KkSik zl6WRlZ8 z$PkdvCpk?q7UFcE+OrK*}I4?6~@|d2;cy_lJhtn%Z@IS>fcNGKV>AXw;7Edkw7F z^T{+SXjI-HJjc^wo%AT1V99Wi-T7SYK;BzQ>V9<#LkcYoz_YQBhY9!aNK|a04r^1( z^ApE3)jGqr_O?eF05`NJW8sts=n?ImSGI}uEm3b2lcgvMVzNKP4?jKmZ<3zrc^OGh zQ42}WHk#>4LQDEHhOvi4|5pbSfm!X|`1P3Cghx)YU>K{#9`NG{ag$c>t#O zRk7k^7UQ(?3UN@6Takp5@v_s(Qzm-y^aMS8_9q0##c2Ye6A+&hlJDoDJPvI5qtFRg zP|nrBwfKQ{B|X(6>CY;^GtraBNc1Xf`F$pOlEjj}N4dvDPyLkj_e{lO7_F=CEB6w4zXwbz$*Kvy7&hbn*8J8X z+I#B668?7k-X%+(Yj54NI61zuKFwLbYE19@CElFT@RMHGK4yzmdT*t|axHch?bva8Zi`d%GKY_1LEE;3*=#D$enyK~GWGc+_SrMROXoiy z6-V5G$D;00{}VnLY9(&6`C=Af8w3OsH`M}^L&Gxc8;sTtOHQ7+flvFr&)k^QVea=h zf3rZi*x!8$XQp9da%hkvI^tLKi?A)a zln~*1A^J%Ln1gTP%n(~kUf+Yp(V^=fm^{94?TC&i2B7B_h+?znXF?aJ!G`fxnJ~t` zDevbN*`X9Ok|!r_Ub7Z`$=VSVWLu515-MBSe}cl9Y5BKN4qgBQPDX%YqU8|^ZMxg# z7)fiZ07oD)p$R#5D+Vu4&eTIP41yO32ge%qi#>aG@#iOWH#QYX@apzlotbP|! zJd4k#OraVLycS2a+IWJZMDQyWAy)A&Z!zrvhA*2lVZxl5uB5P^VT)TMMlQQ zM@Gi+oz>NaMb*_s(ed$7QTT^;ha=7rsk9Qp+jg@$@Uh_{z9HjpO>fCvqI|8T-c&>A-*dM)-5>#WY0u$UmHWll(AakL{2zdMF>axEly$k5EmjluK- z;~L7_*xPCe_P+(Q0Re)08ge(UX?(nMO~+%r?azPyGqnf4^25+7tME@?{iH_t5E4>o1pW@YS9u7tCN%>2mqH_;+#@8dq=)R0^pG*TOd7;b zkMar={Zj@#zs4q;=t+{x`mZTp33^B_#DK}>ID)w&Y(tTdSHI zVJm!!Pg44JFspKap20C0`$Rl*03To;P#cdEwTW4$vv0D_xAc0oPf<5K8_-D<8PTB* zrnkUG>dmk?S)-$G2M-l(fs$Gy$`-24C7Tt5z=;9}xL&o2mE=aNmVCMp#K+fPjyxIh z?z<5uBQLY3LVD}?;gIbiSFeT;zjE|v#EA%Bl(37_u#t)Xs~|;9EOcx+)k4XEI>8oS_ppuvl&L-H{Vd>Fj2XT z1N`=6|8KFlpGMwWvtPTL?yY%P-di)mxVMJgVNm>2++f4T3j)5fy}hNSecB}bBAen7 ziFA<-72-0R7X4>&F)p}C93j6Gr-A!r*#c*%qkbjcS0H`GOyF~`{9K|Cb^IX#5Ak^) z_8ZR<_&^0fJjS!MEw8g5N}wM-AC4&hby&{n2JQ>oA<#N7^Y|`;3p(D5Kd)xyEpwZsiuGx)+Qg^c=s!D?}k^UyNV+pKEM#+h%9v-NOiBh|L)~8BSS5- zmfm&$T6bzv;w(#Ouw`bFjanbt_q7@gzZxD56ULc4AL>W^lQA}mvys~H=Bv@;_T9g9 z-^!J%R-InAZvA>&#>D0rcIoFAI+H#KzdbxNVnyVU$D&q8W=7r~Io;B@b~^1UELMR| zrT2+rXQS)DfY9jh&j>#R`mc$wv%IZaPj=voxp2z4`1aP0R;SDDXk|e;+sBUGp0k4` z70el3Hm7ihGdamkdKBx8&a-h5k>yGvn~Qsqj$;iXVjcm1G71+#Im7J0JBh<_R$n5^ zY56g5WX+ob8fMh5eXXR9A76gu%5v>zhYue=&St*!67eMk{k{s>ge%EN4a9qdPNa7EhfuYijX~teuah zt*BkFv$=Wa0^$zE&fda4q4$L=0ho9L7=v2^fh-2weOA>4WOI~_k9=|N)9n*>E?W3R zv*xO77`rNO^ugRo4Ml92W#W^I7QZ-W`r}hZzv9TtYhb?~VSh@meKL3xL!Pq8bBc>W zE&2Kelcu;Cvz=VGp`pqhS~Dg&zPh0MzQzYTtCx*oUC#K7QLelbdUw8WP)GR7 zPi=a&vv|#v+3AgC*;x~-&>Hy7KLqCoiF3~+#F=VSSr3cq^|7dWmb(*c{_RH}<(a*2 zvkAmw(x4yVi5oTOM^z`@fCfGONbhg?DEjvZQG5D+%ZGqE2!GhDQ5J;!@_p`n8y}*5 z{Lx=onwIpZKjDZ})_vQ5zT?xUfBgUG8RMQK$R^RDzi7pzJD|6WTZ}mWnb21T7MiO# zVTC6n`rcEIsN3aO?5f4>v@-Qb?6K4?bj<=Y;OBcd-=!ECdtY^H3-t4 zc#T}VfsK)&LW$ZCH%jAW?|$pZczXuDSc5+|FQ+wkSxZuTe%m};h+5I^8ZpDC9m))g z^+Z|YeV|FDN@=i(xnX$R)aIWX;DC)SF+?@#QqxJw4yX1MI#m&;HKvmX8OjW@p3y4Vxi zT(;rxp(9%LW3*2O(EEG@^QKnqM~VJ_i2Bsw!$%G^J_g!QWin6YOE4$UxT~l{ z?MrkcWFo#;C!$BeEJ(YGKdA0td|LqzFIt>@r4TMo3CRCQ2xG5UarRUEB6JsP88#x0 zvq>i(z~ScgE2D!}=#U=1B*BKGfu=*wF}}1kuP-&tN8F@#mgBT^3jaO$sPd2K;2_$c z4Gwt44SDD!AUxBITvV=|6>m;mH-QSei7}%|LrRUHa!PVqCYsHfHz%G zj0wNofJwh{TKmh5Jz~p`9qT=JW1mo$Q;7inYnSMclwkRE8^RzAm2Ex6=4hOCoZ`EV z9lLVy;D>L%i5ba&SNX2mPVx@7^!PL08N#FIYYZ1ur+i1JG-Z_D5k9s$VoZH|EhY0X zHq^pLDUxWb2=b-unAcS*-U3yw5;Y|H6t( z39w*@_5cfmW2UG977i-_eU0h+Cm+KLF$;*qIfNC6KIV$ESi-BOlOYHJ;Cx)Z0k>Q@ zx3F>Ex*sm}q>S)bP6m%#RWp8F)rqpw$qwg;c;~384NbE=8A-8aoxbA5wc4RZuh%mq z5ihe6@{8I-oCeV#ic~5*06L1~nkaXoT*qk*D0ib=pki;J4}z5|(62X?qkecjH`R~a zzg^7pNoYHpRC6+Ni*-l#1syiVfh;;Y zCC=|MhsZCf0wcfyE_jMf#tqS=L&OPXixdVr+u zNZbdQgIg(2h}%tL$WhJbM~q~u(zIKPcND}W`4oi z4K41J)Xa^y?b}W_9J#?WA8Hi$2n~pa(g7J2cORHp^s`ys>O1P1fE-VK{=Jv*O1!i* z2fg=-UCf_X)3B_#e0hETlJc)LP1Vk&I~?Luxy!!h>HLzp6$>t|k;Wd)4WT}ahS<_| zRR8Z^36Ct9T~M>OZoF*7k;X5Tuc-IlHu^d)bjh1Hwqbdx_9-qkai*s`!I1wCa2b)5 literal 0 HcmV?d00001 diff --git a/composeApp/src/commonMain/composeResources/font/poppins_italic.ttf b/composeApp/src/commonMain/composeResources/font/poppins_italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..12b7b3c40b5c8dd7d90968d43bac7bc673a6c221 GIT binary patch literal 182012 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
    ?;_d7QR+e3!@*M~gh!9Dwgr*NHqmUgQ}MAnciU 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 Unit, modifier: Modifier = Modifier ) { val navController = rememberNavController() @@ -26,6 +29,7 @@ fun MainNavigationWrapper( composable { SplashScreen( navigateTo = { destination -> + onAppReady() navController.navigate(MainScreens.Home) { popUpTo(MainScreens.Splash) { inclusive = true } } @@ -56,10 +60,20 @@ fun MainNavigationWrapper( ProjectEditorScreen( projectPath = path, - onExport = { + onExportFinish = { navController.navigate(MainScreens.Export(path)) + }, + onBack = { + navController.navigate(MainScreens.Home) } ) } + composable { backStackEntry -> + val path = backStackEntry.toRoute().path + ExportScreen( + projectPath = path, + onDone = { navController.popBackStack() } + ) + } } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt index 967d0e3..f7ae246 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/CreateProjectScreen.kt @@ -17,6 +17,7 @@ fun CreateProjectScreen( viewModel: CreateProjectViewModel = koinViewModel() ) { val state by viewModel.uiState.collectAsStateWithLifecycle() + var domain by remember { mutableStateOf("com.mycompany.") } if (state.isCreated) { onProjectCreate(state.path) @@ -39,7 +40,7 @@ fun CreateProjectScreen( OutlinedTextField( value = state.packageName, - onValueChange = viewModel::onPackageChange, + onValueChange = viewModel::onPackageChange, label = { Text("Package base") }, modifier = Modifier.fillMaxWidth() ) diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt index 2177686..45e16ac 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt @@ -1,114 +1,63 @@ package com.elitec.appmakeup.presentation.screens -import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.padding -import androidx.compose.material3.Button -import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Text +import androidx.compose.material3.CircularProgressIndicator import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier -import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.elitec.appmakeup.presentation.screens.components.ErrorView +import com.elitec.appmakeup.presentation.screens.components.ProjectEditorContent import com.elitec.appmakeup.presentation.viewmodels.ProjectEditorViewModel import org.koin.compose.viewmodel.koinViewModel @Composable fun ProjectEditorScreen( projectPath: String, - onExport: () -> Unit, + onBack: () -> Unit, + onExportFinish: () -> Unit, modifier: Modifier = Modifier, viewModel: ProjectEditorViewModel = koinViewModel() ) { val state by viewModel.uiState.collectAsStateWithLifecycle() - Column( - modifier = modifier - .fillMaxSize() - .padding(24.dp), - horizontalAlignment = Alignment.Start - ) { - - Text( - text = state.project?.name ?: "Proyecto", - style = MaterialTheme.typography.headlineSmall - ) - - Spacer(Modifier.height(16.dp)) - - Row( - modifier = Modifier.fillMaxSize(), - horizontalArrangement = Arrangement.spacedBy(16.dp) - ) { - - // Features - Column(modifier = Modifier.weight(1f)) { - Text("Features", style = MaterialTheme.typography.titleMedium) - - state.features.forEach { - Text( - text = it.name, - modifier = Modifier - .fillMaxWidth() - .clickable { viewModel.selectFeature(it.name) } - .padding(8.dp) - ) - } - - Button( - onClick = { viewModel.addFeature("NewFeature") }, - modifier = Modifier.padding(top = 8.dp) - ) { - Text("Agregar feature") - } - } - - // Properties - Column(modifier = Modifier.weight(1f)) { - Text("Propiedades", style = MaterialTheme.typography.titleMedium) - - state.properties.forEach { - Text( - text = "${it.name}: ${it.type}", - modifier = Modifier.padding(8.dp) - ) - } + LaunchedEffect(projectPath) { + viewModel.loadProject(projectPath) + } - state.selectedFeature?.let { - Button( - onClick = { - viewModel.addProperty( - featureName = it.name, - propertyName = "newProperty", - type = "String" - ) - } - ) { - Text("Agregar propiedad") - } - } + when { + state.isLoading -> { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center + ) { + CircularProgressIndicator() } } - Spacer(Modifier.height(16.dp)) - - Button( - onClick = viewModel::generateCode, - modifier = Modifier.fillMaxWidth() - ) { - Text("Generar código") + state.error != null -> { + ErrorView( + message = state.error!!, + onBack = onBack + ) } - state.error?.let { - Text(it, color = MaterialTheme.colorScheme.error) + state.project != null -> { + ProjectEditorContent( + state = state, + onAddFeature = viewModel::addFeature, + onRemoveFeature = viewModel::removeFeature, + onSelectFeature = viewModel::selectFeature, + onAddProperty = viewModel::addProperty, + onRemoveProperty = viewModel::removeProperty, + onExport = { + viewModel.exportProject() + onExportFinish() + } + ) } } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt index 8e932d0..4f66d7b 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/SplashScreen.kt @@ -21,7 +21,7 @@ fun SplashScreen( modifier: Modifier = Modifier ) { LaunchedEffect(null) { - delay(1000) + delay(2000) navigateTo(MainScreens.Home) } Box( diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt new file mode 100644 index 0000000..ea3a1a8 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt @@ -0,0 +1,39 @@ +package com.elitec.appmakeup.presentation.screens.components + +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.width +import androidx.compose.material3.Button +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp + +@Composable +fun AddFeatureInput( + onAddFeature: (String) -> Unit +) { + var name by remember { mutableStateOf("") } + + Row { + OutlinedTextField( + value = name, + onValueChange = { name = it }, + label = { Text("New feature") } + ) + Spacer(Modifier.width(8.dp)) + Button(onClick = { + if (name.isNotBlank()) { + onAddFeature(name) + name = "" + } + }) { + Text("Add") + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt new file mode 100644 index 0000000..d0978bb --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt @@ -0,0 +1,50 @@ +package com.elitec.appmakeup.presentation.screens.components + +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.material3.Button +import androidx.compose.material3.Checkbox +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment + +@Composable +fun AddPropertyInput( + featureName: String, + onAddProperty: (String, String, String, Boolean) -> Unit +) { + var name by remember { mutableStateOf("") } + var type by remember { mutableStateOf("String") } + var isId by remember { mutableStateOf(false) } + + Column { + OutlinedTextField( + value = name, + onValueChange = { name = it }, + label = { Text("Property name") } + ) + OutlinedTextField( + value = type, + onValueChange = { type = it }, + label = { Text("Type") } + ) + Row(verticalAlignment = Alignment.CenterVertically) { + Checkbox(checked = isId, onCheckedChange = { isId = it }) + Text("Identifier") + } + Button(onClick = { + if (name.isNotBlank()) { + onAddProperty(featureName, name, type, isId) + name = "" + isId = false + } + }) { + Text("Add Property") + } + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ErrorView.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ErrorView.kt new file mode 100644 index 0000000..061c6b8 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ErrorView.kt @@ -0,0 +1,32 @@ +package com.elitec.appmakeup.presentation.screens.components + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.height +import androidx.compose.material3.Button +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp + +@Composable +fun ErrorView( + message: String, + onBack: () -> Unit +) { + Column( + modifier = Modifier.fillMaxSize(), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center + ) { + Text(message, color = MaterialTheme.colorScheme.error) + Spacer(Modifier.height(16.dp)) + Button(onClick = onBack) { + Text("Back") + } + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ProjectEditorContent.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ProjectEditorContent.kt new file mode 100644 index 0000000..226c777 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ProjectEditorContent.kt @@ -0,0 +1,122 @@ +package com.elitec.appmakeup.presentation.screens.components + +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Delete +import androidx.compose.material3.Button +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import com.elitec.appmakeup.presentation.states.ProjectEditorUiState + +@Composable +fun ProjectEditorContent( + state: ProjectEditorUiState, + onAddFeature: (String) -> Unit, + onRemoveFeature: (String) -> Unit, + onSelectFeature: (String) -> Unit, + onAddProperty: (String, String, String, Boolean) -> Unit, + onRemoveProperty: (String, String) -> Unit, + onExport: () -> Unit +) { + Row(modifier = Modifier.fillMaxSize().padding(16.dp)) { + + /* ---------- Feature list ---------- */ + Column( + modifier = Modifier.weight(0.3f) + ) { + Text("Features", style = MaterialTheme.typography.titleMedium) + + Spacer(Modifier.height(8.dp)) + + state.features.forEach { feature -> + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { onSelectFeature(feature.name) } + .padding(8.dp), + horizontalArrangement = Arrangement.SpaceBetween + ) { + Text(feature.name) + IconButton(onClick = { onRemoveFeature(feature.name) }) { + Icon(Icons.Default.Delete, contentDescription = null) + } + } + } + + Spacer(Modifier.height(8.dp)) + + AddFeatureInput(onAddFeature) + } + + Spacer(Modifier.width(16.dp)) + + /* ---------- Feature editor ---------- */ + Column( + modifier = Modifier.weight(0.7f) + ) { + val feature = state.selectedFeature + + if (feature == null) { + Text("Select a feature to edit") + return@Column + } + + Text( + "Feature: ${feature.name}", + style = MaterialTheme.typography.titleMedium + ) + + Spacer(Modifier.height(8.dp)) + + Text("Properties") + + Spacer(Modifier.height(4.dp)) + + state.properties.forEach { prop -> + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween + ) { + Text("${prop.name}: ${prop.type}") + IconButton( + onClick = { + onRemoveProperty(feature.name, prop.name) + } + ) { + Icon(Icons.Default.Delete, contentDescription = null) + } + } + } + + Spacer(Modifier.height(8.dp)) + + AddPropertyInput( + featureName = feature.name, + onAddProperty = onAddProperty + ) + + Spacer(Modifier.height(24.dp)) + + Button( + onClick = onExport, + enabled = !state.isExporting + ) { + Text(if (state.isExporting) "Exporting..." else "Export Project") + } + } + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt index 25c4c06..c120f93 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/CreateProjectUiState.kt @@ -2,7 +2,7 @@ package com.elitec.appmakeup.presentation.states data class CreateProjectUiState( val name: String = "", - val packageName: String = "", + val packageName: String = "com.company.$name", val path: String = "", val error: String? = null, val isCreated: Boolean = false diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ExportUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ExportUiState.kt new file mode 100644 index 0000000..f786bfb --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ExportUiState.kt @@ -0,0 +1,11 @@ +package com.elitec.appmakeup.presentation.states + +import com.elitec.appmakeup.projects.model.AppMakeupProject + +data class ExportUiState( + val project: AppMakeupProject? = null, + val dryRun: Boolean = true, + val isRunning: Boolean = false, + val result: String? = null, + val error: String? = null +) \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorState.kt new file mode 100644 index 0000000..e289a82 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorState.kt @@ -0,0 +1,11 @@ +package com.elitec.appmakeup.presentation.states + +import com.elitec.appmakeup.projects.model.AppFeature +import com.elitec.appmakeup.projects.model.AppMakeupProject + +data class ProjectEditorState( + val project: AppMakeupProject, + val selectedFeature: AppFeature? = null, + val isExporting: Boolean = false, + val error: String? = null +) \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt index 1727491..5c50e2f 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt @@ -1,5 +1,6 @@ package com.elitec.appmakeup.presentation.states +import com.elitec.appmakeup.core.v4.definition.CoreEntity import com.elitec.appmakeup.projects.model.AppFeature import com.elitec.appmakeup.projects.model.AppMakeupProject import com.elitec.appmakeup.projects.model.AppProperty @@ -10,5 +11,6 @@ data class ProjectEditorUiState( val selectedFeature: AppFeature? = null, val properties: List = emptyList(), val isLoading: Boolean = false, + val isExporting: Boolean = false, // ✅ NUEVO val error: String? = null ) \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Color.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Color.kt new file mode 100644 index 0000000..5011e11 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Color.kt @@ -0,0 +1,226 @@ +package com.elitec.appmakeup.presentation.theme + +import androidx.compose.ui.graphics.Color + +val primaryLight = Color(0xFF636117) +val onPrimaryLight = Color(0xFFFFFFFF) +val primaryContainerLight = Color(0xFFEAE68E) +val onPrimaryContainerLight = Color(0xFF4B4900) +val secondaryLight = Color(0xFF616042) +val onSecondaryLight = Color(0xFFFFFFFF) +val secondaryContainerLight = Color(0xFFE8E4BF) +val onSecondaryContainerLight = Color(0xFF49482C) +val tertiaryLight = Color(0xFF3E6655) +val onTertiaryLight = Color(0xFFFFFFFF) +val tertiaryContainerLight = Color(0xFFC0ECD7) +val onTertiaryContainerLight = Color(0xFF264E3F) +val errorLight = Color(0xFFBA1A1A) +val onErrorLight = Color(0xFFFFFFFF) +val errorContainerLight = Color(0xFFFFDAD6) +val onErrorContainerLight = Color(0xFF93000A) +val backgroundLight = Color(0xFFFDF9EC) +val onBackgroundLight = Color(0xFF1C1C14) +val surfaceLight = Color(0xFFFDF9EC) +val onSurfaceLight = Color(0xFF1C1C14) +val surfaceVariantLight = Color(0xFFE6E3D1) +val onSurfaceVariantLight = Color(0xFF48473A) +val outlineLight = Color(0xFF797769) +val outlineVariantLight = Color(0xFFCAC7B6) +val scrimLight = Color(0xFF000000) +val inverseSurfaceLight = Color(0xFF323128) +val inverseOnSurfaceLight = Color(0xFFF5F1E3) +val inversePrimaryLight = Color(0xFFCECA75) +val surfaceDimLight = Color(0xFFDEDACD) +val surfaceBrightLight = Color(0xFFFDF9EC) +val surfaceContainerLowestLight = Color(0xFFFFFFFF) +val surfaceContainerLowLight = Color(0xFFF8F4E6) +val surfaceContainerLight = Color(0xFFF2EEE0) +val surfaceContainerHighLight = Color(0xFFECE8DB) +val surfaceContainerHighestLight = Color(0xFFE6E2D5) + +val primaryLightMediumContrast = Color(0xFF393800) +val onPrimaryLightMediumContrast = Color(0xFFFFFFFF) +val primaryContainerLightMediumContrast = Color(0xFF727025) +val onPrimaryContainerLightMediumContrast = Color(0xFFFFFFFF) +val secondaryLightMediumContrast = Color(0xFF38371D) +val onSecondaryLightMediumContrast = Color(0xFFFFFFFF) +val secondaryContainerLightMediumContrast = Color(0xFF706E50) +val onSecondaryContainerLightMediumContrast = Color(0xFFFFFFFF) +val tertiaryLightMediumContrast = Color(0xFF143D2E) +val onTertiaryLightMediumContrast = Color(0xFFFFFFFF) +val tertiaryContainerLightMediumContrast = Color(0xFF4D7564) +val onTertiaryContainerLightMediumContrast = Color(0xFFFFFFFF) +val errorLightMediumContrast = Color(0xFF740006) +val onErrorLightMediumContrast = Color(0xFFFFFFFF) +val errorContainerLightMediumContrast = Color(0xFFCF2C27) +val onErrorContainerLightMediumContrast = Color(0xFFFFFFFF) +val backgroundLightMediumContrast = Color(0xFFFDF9EC) +val onBackgroundLightMediumContrast = Color(0xFF1C1C14) +val surfaceLightMediumContrast = Color(0xFFFDF9EC) +val onSurfaceLightMediumContrast = Color(0xFF12110A) +val surfaceVariantLightMediumContrast = Color(0xFFE6E3D1) +val onSurfaceVariantLightMediumContrast = Color(0xFF38372A) +val outlineLightMediumContrast = Color(0xFF545345) +val outlineVariantLightMediumContrast = Color(0xFF6F6D5F) +val scrimLightMediumContrast = Color(0xFF000000) +val inverseSurfaceLightMediumContrast = Color(0xFF323128) +val inverseOnSurfaceLightMediumContrast = Color(0xFFF5F1E3) +val inversePrimaryLightMediumContrast = Color(0xFFCECA75) +val surfaceDimLightMediumContrast = Color(0xFFCAC7BA) +val surfaceBrightLightMediumContrast = Color(0xFFFDF9EC) +val surfaceContainerLowestLightMediumContrast = Color(0xFFFFFFFF) +val surfaceContainerLowLightMediumContrast = Color(0xFFF8F4E6) +val surfaceContainerLightMediumContrast = Color(0xFFECE8DB) +val surfaceContainerHighLightMediumContrast = Color(0xFFE0DDD0) +val surfaceContainerHighestLightMediumContrast = Color(0xFFD5D2C5) + +val primaryLightHighContrast = Color(0xFF2F2E00) +val onPrimaryLightHighContrast = Color(0xFFFFFFFF) +val primaryContainerLightHighContrast = Color(0xFF4D4B00) +val onPrimaryContainerLightHighContrast = Color(0xFFFFFFFF) +val secondaryLightHighContrast = Color(0xFF2E2D14) +val onSecondaryLightHighContrast = Color(0xFFFFFFFF) +val secondaryContainerLightHighContrast = Color(0xFF4C4A2F) +val onSecondaryContainerLightHighContrast = Color(0xFFFFFFFF) +val tertiaryLightHighContrast = Color(0xFF063325) +val onTertiaryLightHighContrast = Color(0xFFFFFFFF) +val tertiaryContainerLightHighContrast = Color(0xFF285141) +val onTertiaryContainerLightHighContrast = Color(0xFFFFFFFF) +val errorLightHighContrast = Color(0xFF600004) +val onErrorLightHighContrast = Color(0xFFFFFFFF) +val errorContainerLightHighContrast = Color(0xFF98000A) +val onErrorContainerLightHighContrast = Color(0xFFFFFFFF) +val backgroundLightHighContrast = Color(0xFFFDF9EC) +val onBackgroundLightHighContrast = Color(0xFF1C1C14) +val surfaceLightHighContrast = Color(0xFFFDF9EC) +val onSurfaceLightHighContrast = Color(0xFF000000) +val surfaceVariantLightHighContrast = Color(0xFFE6E3D1) +val onSurfaceVariantLightHighContrast = Color(0xFF000000) +val outlineLightHighContrast = Color(0xFF2D2D21) +val outlineVariantLightHighContrast = Color(0xFF4B4A3C) +val scrimLightHighContrast = Color(0xFF000000) +val inverseSurfaceLightHighContrast = Color(0xFF323128) +val inverseOnSurfaceLightHighContrast = Color(0xFFFFFFFF) +val inversePrimaryLightHighContrast = Color(0xFFCECA75) +val surfaceDimLightHighContrast = Color(0xFFBCB9AC) +val surfaceBrightLightHighContrast = Color(0xFFFDF9EC) +val surfaceContainerLowestLightHighContrast = Color(0xFFFFFFFF) +val surfaceContainerLowLightHighContrast = Color(0xFFF5F1E3) +val surfaceContainerLightHighContrast = Color(0xFFE6E2D5) +val surfaceContainerHighLightHighContrast = Color(0xFFD8D4C7) +val surfaceContainerHighestLightHighContrast = Color(0xFFCAC7BA) + +val primaryDark = Color(0xFFCECA75) +val onPrimaryDark = Color(0xFF333200) +val primaryContainerDark = Color(0xFF4B4900) +val onPrimaryContainerDark = Color(0xFFEAE68E) +val secondaryDark = Color(0xFFCBC8A4) +val onSecondaryDark = Color(0xFF323118) +val secondaryContainerDark = Color(0xFF49482C) +val onSecondaryContainerDark = Color(0xFFE8E4BF) +val tertiaryDark = Color(0xFFA5D0BB) +val onTertiaryDark = Color(0xFF0C3729) +val tertiaryContainerDark = Color(0xFF264E3F) +val onTertiaryContainerDark = Color(0xFFC0ECD7) +val errorDark = Color(0xFFFFB4AB) +val onErrorDark = Color(0xFF690005) +val errorContainerDark = Color(0xFF93000A) +val onErrorContainerDark = Color(0xFFFFDAD6) +val backgroundDark = Color(0xFF14140C) +val onBackgroundDark = Color(0xFFE6E2D5) +val surfaceDark = Color(0xFF14140C) +val onSurfaceDark = Color(0xFFE6E2D5) +val surfaceVariantDark = Color(0xFF48473A) +val onSurfaceVariantDark = Color(0xFFCAC7B6) +val outlineDark = Color(0xFF949181) +val outlineVariantDark = Color(0xFF48473A) +val scrimDark = Color(0xFF000000) +val inverseSurfaceDark = Color(0xFFE6E2D5) +val inverseOnSurfaceDark = Color(0xFF323128) +val inversePrimaryDark = Color(0xFF636117) +val surfaceDimDark = Color(0xFF14140C) +val surfaceBrightDark = Color(0xFF3B3930) +val surfaceContainerLowestDark = Color(0xFF0F0E07) +val surfaceContainerLowDark = Color(0xFF1C1C14) +val surfaceContainerDark = Color(0xFF212018) +val surfaceContainerHighDark = Color(0xFF2B2A22) +val surfaceContainerHighestDark = Color(0xFF36352C) + +val primaryDarkMediumContrast = Color(0xFFE4E088) +val onPrimaryDarkMediumContrast = Color(0xFF282700) +val primaryContainerDarkMediumContrast = Color(0xFF979445) +val onPrimaryContainerDarkMediumContrast = Color(0xFF000000) +val secondaryDarkMediumContrast = Color(0xFFE1DEB9) +val onSecondaryDarkMediumContrast = Color(0xFF27270E) +val secondaryContainerDarkMediumContrast = Color(0xFF949271) +val onSecondaryContainerDarkMediumContrast = Color(0xFF000000) +val tertiaryDarkMediumContrast = Color(0xFFBAE6D1) +val onTertiaryDarkMediumContrast = Color(0xFF002C1E) +val tertiaryContainerDarkMediumContrast = Color(0xFF709A87) +val onTertiaryContainerDarkMediumContrast = Color(0xFF000000) +val errorDarkMediumContrast = Color(0xFFFFD2CC) +val onErrorDarkMediumContrast = Color(0xFF540003) +val errorContainerDarkMediumContrast = Color(0xFFFF5449) +val onErrorContainerDarkMediumContrast = Color(0xFF000000) +val backgroundDarkMediumContrast = Color(0xFF14140C) +val onBackgroundDarkMediumContrast = Color(0xFFE6E2D5) +val surfaceDarkMediumContrast = Color(0xFF14140C) +val onSurfaceDarkMediumContrast = Color(0xFFFFFFFF) +val surfaceVariantDarkMediumContrast = Color(0xFF48473A) +val onSurfaceVariantDarkMediumContrast = Color(0xFFE0DDCB) +val outlineDarkMediumContrast = Color(0xFFB5B2A2) +val outlineVariantDarkMediumContrast = Color(0xFF939181) +val scrimDarkMediumContrast = Color(0xFF000000) +val inverseSurfaceDarkMediumContrast = Color(0xFFE6E2D5) +val inverseOnSurfaceDarkMediumContrast = Color(0xFF2B2A22) +val inversePrimaryDarkMediumContrast = Color(0xFF4C4A00) +val surfaceDimDarkMediumContrast = Color(0xFF14140C) +val surfaceBrightDarkMediumContrast = Color(0xFF46453B) +val surfaceContainerLowestDarkMediumContrast = Color(0xFF080803) +val surfaceContainerLowDarkMediumContrast = Color(0xFF1F1E16) +val surfaceContainerDarkMediumContrast = Color(0xFF292820) +val surfaceContainerHighDarkMediumContrast = Color(0xFF34332A) +val surfaceContainerHighestDarkMediumContrast = Color(0xFF3F3E35) + +val primaryDarkHighContrast = Color(0xFFF8F49A) +val onPrimaryDarkHighContrast = Color(0xFF000000) +val primaryContainerDarkHighContrast = Color(0xFFCAC671) +val onPrimaryContainerDarkHighContrast = Color(0xFF0C0C00) +val secondaryDarkHighContrast = Color(0xFFF5F1CB) +val onSecondaryDarkHighContrast = Color(0xFF000000) +val secondaryContainerDarkHighContrast = Color(0xFFC7C4A0) +val onSecondaryContainerDarkHighContrast = Color(0xFF0C0C00) +val tertiaryDarkHighContrast = Color(0xFFCDFAE4) +val onTertiaryDarkHighContrast = Color(0xFF000000) +val tertiaryContainerDarkHighContrast = Color(0xFFA1CCB8) +val onTertiaryContainerDarkHighContrast = Color(0xFF000E08) +val errorDarkHighContrast = Color(0xFFFFECE9) +val onErrorDarkHighContrast = Color(0xFF000000) +val errorContainerDarkHighContrast = Color(0xFFFFAEA4) +val onErrorContainerDarkHighContrast = Color(0xFF220001) +val backgroundDarkHighContrast = Color(0xFF14140C) +val onBackgroundDarkHighContrast = Color(0xFFE6E2D5) +val surfaceDarkHighContrast = Color(0xFF14140C) +val onSurfaceDarkHighContrast = Color(0xFFFFFFFF) +val surfaceVariantDarkHighContrast = Color(0xFF48473A) +val onSurfaceVariantDarkHighContrast = Color(0xFFFFFFFF) +val outlineDarkHighContrast = Color(0xFFF4F0DE) +val outlineVariantDarkHighContrast = Color(0xFFC6C3B2) +val scrimDarkHighContrast = Color(0xFF000000) +val inverseSurfaceDarkHighContrast = Color(0xFFE6E2D5) +val inverseOnSurfaceDarkHighContrast = Color(0xFF000000) +val inversePrimaryDarkHighContrast = Color(0xFF4C4A00) +val surfaceDimDarkHighContrast = Color(0xFF14140C) +val surfaceBrightDarkHighContrast = Color(0xFF525046) +val surfaceContainerLowestDarkHighContrast = Color(0xFF000000) +val surfaceContainerLowDarkHighContrast = Color(0xFF212018) +val surfaceContainerDarkHighContrast = Color(0xFF323128) +val surfaceContainerHighDarkHighContrast = Color(0xFF3D3C32) +val surfaceContainerHighestDarkHighContrast = Color(0xFF48473D) + + + + + + + diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Theme.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Theme.kt new file mode 100644 index 0000000..f1c8035 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Theme.kt @@ -0,0 +1,98 @@ +package com.elitec.appmakeup.presentation.theme + +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.lightColorScheme +import androidx.compose.material3.darkColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.Immutable +import androidx.compose.ui.graphics.Color + +// Colores para el tema oscuro +val DarkColorScheme = darkColorScheme( + primary = Color(0xFF5B88B2), // Azul medio (base) + onPrimary = Color(0xFFE6E6E6), + primaryContainer = Color(0xFF3A5E7E), // Azul oscuro para contraste + onPrimaryContainer = Color(0xFFD6E3F3), + + secondary = Color(0xFF4E6E8F), // Azul grisáceo + onSecondary = Color(0xFFE6E6E6), + secondaryContainer = Color(0xFF39516F), + onSecondaryContainer = Color(0xFFD8E3F0), + + tertiary = Color(0xFF8C4A6F), // Magenta oscuro + onTertiary = Color(0xFFE6E6E6), + tertiaryContainer = Color(0xFF6A3857), + onTertiaryContainer = Color(0xFFF3D5E6), + + background = Color(0xFF121212), // Negro puro + onBackground = Color(0xFFE6E6E6), + + surface = Color(0xFF1E252F), // Gris azulado oscuro + onSurface = Color(0xFFE6E6E6), + surfaceVariant = Color(0xFF2A323E), + onSurfaceVariant = Color(0xFFB0B0B0), + + error = Color(0xFFCF6679), // Rojo suave + onError = Color(0xFF121212), + errorContainer = Color(0xFFB00020), + onErrorContainer = Color(0xFFE6E6E6) +) + +val LightColorScheme = lightColorScheme( + primary = Color(0xFF5B88B2), // Azul medio (color base) + onPrimary = Color(0xFFFFFFFF), // Blanco para contraste + primaryContainer = Color(0xFFD5E3F3), // Azul muy claro (fondo de contenedores) + onPrimaryContainer = Color(0xFF0F1D2B), + + secondary = Color(0xFF6B94B5), // Azul-grisáceo secundario + onSecondary = Color(0xFFFFFFFF), + secondaryContainer = Color(0xFFD8E3F0), + onSecondaryContainer = Color(0xFF172430), + + tertiary = Color(0xFFB25B8E), // Magenta suave de apoyo + onTertiary = Color(0xFFFFFFFF), + tertiaryContainer = Color(0xFFF3D5E6), + onTertiaryContainer = Color(0xFF2B0F1D), + + background = Color(0xFFFFFFFF), // Blanco puro + onBackground = Color(0xFF1C2526), + + surface = Color(0xFFFAFAFA), // Gris muy claro + onSurface = Color(0xFF1C2526), + surfaceVariant = Color(0xFFE1E7ED), // Gris-azulado suave + onSurfaceVariant = Color(0xFF454F57), + + error = Color(0xFFB00020), // Rojo brillante + onError = Color(0xFFFFFFFF), + errorContainer = Color(0xFFFCDADA), + onErrorContainer = Color(0xFF410002) +) + +@Immutable +data class ColorFamily( + val color: Color, + val onColor: Color, + val colorContainer: Color, + val onColorContainer: Color +) + +val unspecified_scheme = ColorFamily( + Color.Unspecified, Color.Unspecified, Color.Unspecified, Color.Unspecified +) + +@Composable +fun AppTheme( + darkTheme: Boolean = isSystemInDarkTheme(), + // Dynamic color is available on Android 12+ + content: @Composable() () -> Unit +) { + val colorScheme = if (darkTheme) { DarkColorScheme } else { LightColorScheme } + + MaterialTheme( + colorScheme = colorScheme, + typography = AppTypography, + content = content + ) +} + diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Type.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Type.kt new file mode 100644 index 0000000..ad84042 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/theme/Type.kt @@ -0,0 +1,36 @@ +package com.elitec.appmakeup.presentation.theme + +import androidx.compose.material3.Typography +import androidx.compose.runtime.Composable +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import appmakeup.composeapp.generated.resources.Res +import appmakeup.composeapp.generated.resources.abrilFatface_regular +import appmakeup.composeapp.generated.resources.poppins_black +import appmakeup.composeapp.generated.resources.poppins_bold +import appmakeup.composeapp.generated.resources.poppins_extraBold +import appmakeup.composeapp.generated.resources.poppins_italic +import appmakeup.composeapp.generated.resources.poppins_light +import appmakeup.composeapp.generated.resources.poppins_medium +import appmakeup.composeapp.generated.resources.poppins_regular +import appmakeup.composeapp.generated.resources.poppins_semiBold +import org.jetbrains.compose.resources.Font + +val AppTypography = Typography() + +@Composable +fun abrilFatfaceFontFamily() = FontFamily( + Font(Res.font.abrilFatface_regular, weight = FontWeight.Normal) +) + +@Composable +fun poppinsFontFamily() = FontFamily( + Font(Res.font.poppins_regular, weight = FontWeight.Normal), + Font(Res.font.poppins_italic, weight = FontWeight.Medium), + Font(Res.font.poppins_medium, weight = FontWeight.Medium), + Font(Res.font.poppins_bold, weight = FontWeight.Bold), + Font(Res.font.poppins_extraBold, weight = FontWeight.ExtraBold), + Font(Res.font.poppins_light, weight = FontWeight.Light), + Font(Res.font.poppins_semiBold, weight = FontWeight.SemiBold), + Font(Res.font.poppins_black, weight = FontWeight.Black), +) diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt new file mode 100644 index 0000000..8c84083 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt @@ -0,0 +1,79 @@ +package com.elitec.appmakeup.presentation.viewmodels + +import androidx.lifecycle.ViewModel +import com.elitec.appmakeup.generation.GenerateCodeUseCase +import com.elitec.appmakeup.presentation.states.ExportUiState +import com.elitec.appmakeup.projects.usecase.project.LoadProjectUseCase +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.update + +class ExportViewModel( + private val loadProjectUseCase: LoadProjectUseCase, + private val generateCodeUseCase: GenerateCodeUseCase +) : ViewModel() { + + private val _uiState = MutableStateFlow(ExportUiState()) + val uiState: StateFlow = _uiState + + /* --------------------------- + * Init + * --------------------------- */ + + fun loadProject(path: String) { + try { + val project = loadProjectUseCase.execute(path) + _uiState.update { + it.copy(project = project) + } + } catch (e: Exception) { + _uiState.update { + it.copy(error = e.message) + } + } + } + + /* --------------------------- + * Options + * --------------------------- */ + + fun toggleDryRun(enabled: Boolean) { + _uiState.update { it.copy(dryRun = enabled) } + } + + /* --------------------------- + * Export + * --------------------------- */ + + fun runExport() { + val project = _uiState.value.project ?: return + + _uiState.update { + it.copy(isRunning = true, error = null, result = null) + } + + try { + // 🔑 El dry-run debe venir reflejado en el proyecto / contexto + generateCodeUseCase.execute( + project, true + ) + + _uiState.update { + it.copy( + result = if (_uiState.value.dryRun) + "Dry-run completed successfully" + else + "Project exported successfully" + ) + } + } catch (e: Exception) { + _uiState.update { + it.copy(error = e.message) + } + } finally { + _uiState.update { + it.copy(isRunning = false) + } + } + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt index 5e024a5..f2e7daa 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt @@ -1,6 +1,9 @@ package com.elitec.appmakeup.presentation.viewmodels import androidx.lifecycle.ViewModel +import com.elitec.appmakeup.core.v4.definition.CoreEntity +import com.elitec.appmakeup.core.v4.definition.CoreLayer +import com.elitec.appmakeup.core.v4.definition.CoreProperty import com.elitec.appmakeup.generation.GenerateCodeUseCase import com.elitec.appmakeup.presentation.states.ProjectEditorUiState import com.elitec.appmakeup.projects.model.AppFeature @@ -11,6 +14,7 @@ import com.elitec.appmakeup.projects.usecase.feature.GetFeatureUseCase import com.elitec.appmakeup.projects.usecase.feature.ListFeaturesUseCase import com.elitec.appmakeup.projects.usecase.feature.RemoveFeatureUseCase import com.elitec.appmakeup.projects.usecase.project.LoadProjectUseCase +import com.elitec.appmakeup.projects.usecase.project.SaveProjectUseCase import com.elitec.appmakeup.projects.usecase.property.AddPropertyUseCase import com.elitec.appmakeup.projects.usecase.property.ListPropertiesUseCase import com.elitec.appmakeup.projects.usecase.property.RemovePropertyUseCase @@ -20,6 +24,7 @@ import kotlinx.coroutines.flow.update class ProjectEditorViewModel( private val loadProjectUseCase: LoadProjectUseCase, + private val saveProjectUseCase: SaveProjectUseCase, private val listFeaturesUseCase: ListFeaturesUseCase, private val getFeatureUseCase: GetFeatureUseCase, private val listPropertiesUseCase: ListPropertiesUseCase, @@ -28,9 +33,9 @@ class ProjectEditorViewModel( private val addPropertyUseCase: AddPropertyUseCase, private val removePropertyUseCase: RemovePropertyUseCase, private val generateCodeUseCase: GenerateCodeUseCase -): ViewModel() { - private val _uiState = MutableStateFlow(ProjectEditorUiState(isLoading = true)) +) : ViewModel() { + private val _uiState = MutableStateFlow(ProjectEditorUiState(isLoading = true)) val uiState: StateFlow = _uiState /* --------------------------- @@ -57,17 +62,24 @@ class ProjectEditorViewModel( val updated = addFeatureUseCase.execute( project, - AppFeature(name = name, properties = emptyList()) + AppFeature( + name = name, + properties = emptyList() + ) ) - refreshProject(updated) + persistAndRefresh(updated) + selectFeature(name) } fun removeFeature(name: String) { val project = currentProject() ?: return val updated = removeFeatureUseCase.execute(project, name) - refreshProject(updated) + persistAndRefresh(updated) + + // si borraste la seleccionada, limpia selección + _uiState.update { it.copy(selectedFeature = null, properties = emptyList()) } } fun selectFeature(name: String) { @@ -108,7 +120,8 @@ class ProjectEditorViewModel( ) ) - refreshProject(updated) + persistAndRefresh(updated) + selectFeature(featureName) } fun removeProperty(featureName: String, propertyName: String) { @@ -120,22 +133,25 @@ class ProjectEditorViewModel( propertyName ) - refreshProject(updated) + persistAndRefresh(updated) + selectFeature(featureName) } /* --------------------------- - * Code generation + * Code generation / Export * --------------------------- */ - fun generateCode() { + fun exportProject() { val project = currentProject() ?: return + _uiState.update { it.copy(isExporting = true, error = null) } + try { - generateCodeUseCase.execute(project) + generateCodeUseCase.execute(project, dryRun = false) } catch (e: Exception) { - _uiState.update { - it.copy(error = e.message) - } + _uiState.update { it.copy(error = e.message) } + } finally { + _uiState.update { it.copy(isExporting = false) } } } @@ -143,6 +159,11 @@ class ProjectEditorViewModel( * Helpers * --------------------------- */ + private fun persistAndRefresh(project: AppMakeupProject) { + saveProjectUseCase.execute(project) + refreshProject(project) + } + private fun refreshProject(project: AppMakeupProject) { val features = listFeaturesUseCase.execute(project) @@ -150,8 +171,6 @@ class ProjectEditorViewModel( it.copy( project = project, features = features, - selectedFeature = null, - properties = emptyList(), isLoading = false, error = null ) diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt index 2fba65b..53538be 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt @@ -128,7 +128,7 @@ val coreV4Module = module { planningStage = get(), generationStage = get(), writingStage = get(), - reportingStage = get() + reportingStage = DefaultReportingStage(ReportFormat.CLI) ) } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt index f0ec31f..fbd116f 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt @@ -10,7 +10,7 @@ class ProjectExporter( private val pipeline: GenerationPipeline ) { - fun export(project: AppMakeupProject) { + fun export(project: AppMakeupProject, dryRun: Boolean) { val packagePath = project.packageName.replace(".", "/") @@ -26,7 +26,8 @@ class ProjectExporter( GenerationContext( architecture = DefaultArchitecture.value, feature = coreFeature, - outputPath = outputPath + outputPath = outputPath, + options = mapOf("dryRun" to dryRun) ) ) } diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt index 1df677c..f3a5662 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt @@ -6,7 +6,7 @@ class ProjectCodeGenerator( private val exporter: ProjectExporter ) : CodeGenerator { - override fun generate(intent: CodeGenerationIntent) { - exporter.export(intent.project) + override fun generate(intent: CodeGenerationIntent, dryRun: Boolean) { + exporter.export(intent.project, dryRun) } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt index 944395c..65acc6b 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/main.kt @@ -1,6 +1,7 @@ package com.elitec.appmakeup import androidx.compose.foundation.clickable +import androidx.compose.foundation.isSystemInDarkTheme import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row @@ -20,7 +21,9 @@ import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Scaffold import androidx.compose.material3.Surface +import androidx.compose.material3.Text import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color @@ -35,6 +38,9 @@ import appmakeup.composeapp.generated.resources.sinfotow import appmakeup.composeapp.generated.resources.toolicon import com.elitec.appmakeup.di.initKoin import com.elitec.appmakeup.presentation.navigation.MainNavigationWrapper +import com.elitec.appmakeup.presentation.theme.AppTheme +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch import org.jetbrains.compose.resources.painterResource import org.koin.core.context.startKoin @@ -46,7 +52,7 @@ fun main() = application { LaunchedEffect(null) { initKoin() } - + val scope = rememberCoroutineScope() Window( resizable = false, undecorated = true, @@ -55,69 +61,76 @@ fun main() = application { onCloseRequest = ::exitApplication, title = "AppMakeup", ) { - Scaffold( - topBar = { - Row( - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.End, - modifier = Modifier.fillMaxWidth() - ) { - Surface( - shape = RoundedCornerShape(5.dp), - color = MaterialTheme.colorScheme.onBackground, - onClick = { - windowState.isMinimized = true - } + AppTheme { + Scaffold( + topBar = { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.End, + modifier = Modifier.fillMaxWidth() ) { - Icon( - imageVector = Icons.Default.Minimize, - contentDescription = "", - tint = MaterialTheme.colorScheme.background, - modifier = Modifier.size(20.dp) - ) - } + Surface( + shape = RoundedCornerShape(5.dp), + color = MaterialTheme.colorScheme.onBackground, + onClick = { + windowState.isMinimized = true + } + ) { + Icon( + imageVector = Icons.Default.Minimize, + contentDescription = "", + tint = MaterialTheme.colorScheme.background, + modifier = Modifier.size(20.dp) + ) + } - Spacer(modifier = Modifier.width(8.dp)) - Surface( - shape = RoundedCornerShape(5.dp), - color = MaterialTheme.colorScheme.onBackground, - onClick = { - if(windowState.placement == WindowPlacement.Maximized) { - windowState.placement = WindowPlacement.Floating - return@Surface + Spacer(modifier = Modifier.width(8.dp)) + Surface( + shape = RoundedCornerShape(5.dp), + color = MaterialTheme.colorScheme.onBackground, + onClick = { + if(windowState.placement == WindowPlacement.Maximized) { + windowState.placement = WindowPlacement.Floating + return@Surface + } + windowState.placement = WindowPlacement.Maximized } - windowState.placement = WindowPlacement.Maximized + ) { + Icon( + imageVector = Icons.Default.Maximize, + contentDescription = "", + tint = MaterialTheme.colorScheme.background, + modifier = Modifier.size(20.dp) + ) } - ) { - Icon( - imageVector = Icons.Default.Maximize, - contentDescription = "", - tint = MaterialTheme.colorScheme.background, - modifier = Modifier.size(20.dp) - ) - } - Spacer(modifier = Modifier.width(8.dp)) - Surface( - shape = RoundedCornerShape(5.dp), - color = MaterialTheme.colorScheme.onBackground, - onClick = { - exitApplication() + Spacer(modifier = Modifier.width(8.dp)) + Surface( + shape = RoundedCornerShape(5.dp), + color = MaterialTheme.colorScheme.onBackground, + onClick = { + exitApplication() + } + ) { + Icon( + imageVector = Icons.Default.Close, + contentDescription = "", + tint = MaterialTheme.colorScheme.background, + modifier = Modifier.size(20.dp) + ) } - ) { - Icon( - imageVector = Icons.Default.Close, - contentDescription = "", - tint = MaterialTheme.colorScheme.background, - modifier = Modifier.size(20.dp) - ) } - } - }, - bottomBar = {} - ) { innerPaddings -> - MainNavigationWrapper( - modifier = Modifier.fillMaxSize().padding(innerPaddings) - ) + }, + bottomBar = { + Text(text = isSystemInDarkTheme().toString()) + }, + ) { innerPaddings -> + MainNavigationWrapper( + onAppReady = { + windowState.placement = WindowPlacement.Maximized + }, + modifier = Modifier.fillMaxSize().padding(innerPaddings) + ) + } } } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt index 1eb933e..6dd8769 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/projects/persistence/FileProjectPersistence.kt @@ -12,12 +12,12 @@ class FileProjectPersistence : ProjectPersistence { } override fun save(project: AppMakeupProject) { - val file = File(project.path, "appmakeup.json") + val file = File(project.path, "projectConfig.amk") file.writeText(json.encodeToString(AppMakeupProject.serializer(), project)) } override fun load(path: String): AppMakeupProject { - val file = File(path, "appmakeup.json") + val file = File(path, "projectConfig.amk") return json.decodeFromString( AppMakeupProject.serializer(), file.readText() From a1d359ff666fb55ec23236fb3eb8f670d1a87082 Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Mon, 26 Jan 2026 11:28:29 -0600 Subject: [PATCH 18/20] preview after export files --- .../core/v4/contracts/GenerationResult.kt | 7 +- .../core/v4/pipeline/DefaultPlanningStage.kt | 16 ++ .../core/v4/pipeline/GenerationPipeline.kt | 14 +- .../core/v4/pipeline/PreviewWritingStage.kt | 18 ++ .../core/v4/pipeline/WritingStage.kt | 4 +- .../elitec/appmakeup/di/applicationModule.kt | 2 + .../elitec/appmakeup/di/presentationModule.kt | 14 +- .../appmakeup/generation/CodeGenerator.kt | 5 +- .../generation/GenerateCodeUseCase.kt | 11 +- .../PreviewGenerationPlanUseCase.kt | 13 ++ .../com/elitec/appmakeup/logs/Logger.kt | 15 ++ .../navigation/MainNavigationWrapper.kt | 7 +- .../presentation/screens/ExportScreen.kt | 147 +++++++++++---- .../presentation/screens/HomeScreen.kt | 48 +++-- .../screens/ProjectEditorScreen.kt | 35 ++-- .../screens/components/AddFeatureInput.kt | 19 +- .../screens/components/AddPropertyInput.kt | 19 +- ...ojectEditorContent.kt => EditorContent.kt} | 107 ++++++----- .../components/GenerationPlanPreview.kt | 46 +++++ .../screens/components/PreviewFilesList.kt | 30 +++ .../states/GenerationPreviewUiState.kt | 9 + .../states/ProjectEditorUiState.kt | 4 +- .../viewmodels/ExportViewModel.kt | 53 +++++- .../viewmodels/ProjectEditorViewModel.kt | 175 +++++++++++------- .../projects/mappers/ProjectToCoreMapper.kt | 2 +- .../appmakeup/projects/model/AppFeature.kt | 3 +- .../projects/model/RepositoryConfig.kt | 14 ++ .../v4/pipeline/FileSystemWritingStage.jvm.kt | 21 +-- .../com/elitec/appmakeup/di/coreV4Module.kt | 82 ++++---- .../appmakeup/di/infrastructureModule.kt | 8 +- .../com/elitec/appmakeup/di/initKoin.kt | 1 - .../elitec/appmakeup/di/validationModule.kt | 22 --- .../appmakeup/exports/ProjectExporter.kt | 67 ++++++- .../generation/ProjectCodeGenerator.kt | 9 +- 34 files changed, 747 insertions(+), 300 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/PreviewWritingStage.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/PreviewGenerationPlanUseCase.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/logs/Logger.kt rename composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/{ProjectEditorContent.kt => EditorContent.kt} (51%) create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/GenerationPlanPreview.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/PreviewFilesList.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/GenerationPreviewUiState.kt create mode 100644 composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/RepositoryConfig.kt delete mode 100644 composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/contracts/GenerationResult.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/contracts/GenerationResult.kt index 2ee0a7a..aa5a320 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/contracts/GenerationResult.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/contracts/GenerationResult.kt @@ -1,12 +1,9 @@ package com.elitec.appmakeup.core.v4.contracts sealed class GenerationResult { - object Success : GenerationResult() - - data class Failure( - val reason: String - ) : GenerationResult() + data class Failure(val reason: String) : GenerationResult() + data class Preview(val files: List) : GenerationResult() fun isSuccess(): Boolean = this is Success } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/DefaultPlanningStage.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/DefaultPlanningStage.kt index 4d64116..8b03776 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/DefaultPlanningStage.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/DefaultPlanningStage.kt @@ -10,21 +10,37 @@ class DefaultPlanningStage( private val mapperContracts: List = emptyList() ) : PlanningStage { + private val tag = "[DefaultPlanningStage]---> " override fun plan(context: GenerationContext): GenerationPlan { + println("$tag GenerationContext received: $context") + val layers = context.feature.layers + println("$tag Layers: $layers") val generateDomain = layers.contains(CoreLayer.DOMAIN) + println("$tag Generate domain: $generateDomain") val generateData = layers.contains(CoreLayer.DATA) + println("$tag Generate data: $generateData") val generatePresentation = layers.contains(CoreLayer.PRESENTATION) + println("$tag Generate presentation: $generatePresentation") val generateRepositories = generateData && repositoryContracts.isNotEmpty() + println("$tag Generate repositories: $generateRepositories") val generateMappers = generateData && mapperContracts.isNotEmpty() + println("$tag Generate mappers: $generateMappers") + + println( + "🧠 Plan => domain=$generateDomain, " + + "data=$generateData, " + + "repo=$generateRepositories, " + + "mapper=$generateMappers" + ) return GenerationPlan( generateDomain = generateDomain, diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/GenerationPipeline.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/GenerationPipeline.kt index 347d785..84b0ea8 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/GenerationPipeline.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/GenerationPipeline.kt @@ -12,9 +12,14 @@ class GenerationPipeline( private val reportingStage: ReportingStage ) { + private val tag = "[GenerationPipeline]---> " fun run(context: GenerationContext): GenerationResult { + println("$tag 🚀 GenerationPipeline.run START for feature: ${context.feature.name}") + val validation = validationStage.validate(context) + println("$tag Validation of GenerationContext: $validation") + if (!validation.isValid()) { return GenerationResult.Failure( (validation as ValidationResult.Invalid).reason @@ -22,10 +27,17 @@ class GenerationPipeline( } val plan = planningStage.plan(context) + println("$tag Plan of GenerationContext: $plan") val artifacts = generationStage.generate(context, plan) - val writeResult = writingStage.write(context.outputPath, artifacts) + println("📦 Artifacts generated: ${artifacts.size}") + + val writeResult = writingStage.write( + outputPath = context.outputPath, + artifacts = artifacts, + context = context + ) if (!writeResult.isSuccess()) return writeResult reportingStage.report(artifacts) diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/PreviewWritingStage.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/PreviewWritingStage.kt new file mode 100644 index 0000000..7c6f3e8 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/PreviewWritingStage.kt @@ -0,0 +1,18 @@ +package com.elitec.appmakeup.core.v4.pipeline + +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.contracts.GenerationResult + +class PreviewWritingStage : WritingStage { + + override fun write( + outputPath: String, + artifacts: List, + context: GenerationContext + ): GenerationResult { + + return GenerationResult.Preview( + files = artifacts.map { it.relativePath } + ) + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/WritingStage.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/WritingStage.kt index 4e41346..71ff7b0 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/WritingStage.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/WritingStage.kt @@ -1,10 +1,12 @@ package com.elitec.appmakeup.core.v4.pipeline +import com.elitec.appmakeup.core.v4.contracts.GenerationContext import com.elitec.appmakeup.core.v4.contracts.GenerationResult interface WritingStage { fun write( outputPath: String, - artifacts: List + artifacts: List, + context: GenerationContext ): GenerationResult } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt index 4656823..b871bd3 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/applicationModule.kt @@ -1,6 +1,7 @@ package com.elitec.appmakeup.di import com.elitec.appmakeup.generation.GenerateCodeUseCase +import com.elitec.appmakeup.generation.PreviewGenerationPlanUseCase import com.elitec.appmakeup.projects.usecase.feature.AddFeatureUseCase import com.elitec.appmakeup.projects.usecase.feature.GetFeatureUseCase import com.elitec.appmakeup.projects.usecase.feature.ListFeaturesUseCase @@ -37,4 +38,5 @@ val applicationModule = module { // Generation factory { GenerateCodeUseCase(get()) } + factory { PreviewGenerationPlanUseCase(get()) } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt index f7f9362..1366fa3 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/di/presentationModule.kt @@ -1,17 +1,20 @@ package com.elitec.appmakeup.di import com.elitec.appmakeup.presentation.viewmodels.CreateProjectViewModel +import com.elitec.appmakeup.presentation.viewmodels.ExportViewModel import com.elitec.appmakeup.presentation.viewmodels.HomeViewModel import com.elitec.appmakeup.presentation.viewmodels.ProjectEditorViewModel import org.koin.core.module.dsl.viewModel import org.koin.dsl.module val presentationModule = module { + viewModel { HomeViewModel( listRecentProjectsUseCase = get() ) } + viewModel { CreateProjectViewModel( createProjectUseCase = get() @@ -22,9 +25,6 @@ val presentationModule = module { ProjectEditorViewModel( loadProjectUseCase = get(), saveProjectUseCase = get(), - listFeaturesUseCase = get(), - getFeatureUseCase = get(), - listPropertiesUseCase = get(), addFeatureUseCase = get(), removeFeatureUseCase = get(), addPropertyUseCase = get(), @@ -32,4 +32,12 @@ val presentationModule = module { generateCodeUseCase = get() ) } + + viewModel { + ExportViewModel( + loadProjectUseCase = get(), + generateCodeUseCase = get(), + previewGenerationPlanUseCase = get() + ) + } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt index 81706ee..3bab2bb 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt @@ -1,6 +1,9 @@ package com.elitec.appmakeup.generation +import com.elitec.appmakeup.core.v4.contracts.GenerationResult +import com.elitec.appmakeup.projects.model.AppMakeupProject + interface CodeGenerator { - fun generate(intent: CodeGenerationIntent,dryRun: Boolean) + fun generate(intent: CodeGenerationIntent,dryRun: Boolean): GenerationResult } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt index 137c745..2b18a32 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt @@ -1,22 +1,27 @@ package com.elitec.appmakeup.generation +import com.elitec.appmakeup.core.v4.contracts.GenerationResult import com.elitec.appmakeup.projects.model.AppMakeupProject class GenerateCodeUseCase( private val codeGenerator: CodeGenerator ) { - fun execute(project: AppMakeupProject, dryRun: Boolean) { + private val tag = "[GenerateCodeUseCase]" + fun execute(project: AppMakeupProject, dryRun: Boolean): GenerationResult { + println("$tag Init executing Generation intent") require(project.features.isNotEmpty()) { "Project must have at least one feature to generate code" } val intent = CodeGenerationIntent( project = project, - exportPath = project.exportPath + exportPath = "${project.path}/export" ) - codeGenerator.generate(intent, dryRun) + + println("$tag make generation intent: $intent") + return codeGenerator.generate(intent, dryRun) } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/PreviewGenerationPlanUseCase.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/PreviewGenerationPlanUseCase.kt new file mode 100644 index 0000000..329aa52 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/PreviewGenerationPlanUseCase.kt @@ -0,0 +1,13 @@ +package com.elitec.appmakeup.generation + +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.pipeline.GenerationPlan +import com.elitec.appmakeup.core.v4.pipeline.PlanningStage + +class PreviewGenerationPlanUseCase( + private val planningStage: PlanningStage +) { + + fun execute(context: GenerationContext): GenerationPlan = + planningStage.plan(context) +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/logs/Logger.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/logs/Logger.kt new file mode 100644 index 0000000..ead1608 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/logs/Logger.kt @@ -0,0 +1,15 @@ +package com.elitec.appmakeup.logs + +object Logger { + fun error(tag: String? = "", message: String, error: Throwable) { + println("[$tag] ----> ❌ ERROR___ $message \n Cause: $error") + } + + fun success(tag: String? = "", message: String) { + println("[$tag] ----> ✅ $message") + } + + fun warning(tag: String? = "", message: String) { + println("[$tag] ----> ⚠️⚠ $message") + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt index be3eb7e..7a3b19c 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/navigation/MainNavigationWrapper.kt @@ -60,11 +60,8 @@ fun MainNavigationWrapper( ProjectEditorScreen( projectPath = path, - onExportFinish = { + onNavigateToExport = { navController.navigate(MainScreens.Export(path)) - }, - onBack = { - navController.navigate(MainScreens.Home) } ) } @@ -72,7 +69,7 @@ fun MainNavigationWrapper( val path = backStackEntry.toRoute().path ExportScreen( projectPath = path, - onDone = { navController.popBackStack() } + onBack = { navController.popBackStack() } ) } } diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt index b30d6b3..6848148 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ExportScreen.kt @@ -2,67 +2,152 @@ package com.elitec.appmakeup.presentation.screens import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width import androidx.compose.material3.Button +import androidx.compose.material3.Checkbox import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.Divider import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.elitec.appmakeup.presentation.screens.components.GenerationPlanPreview +import com.elitec.appmakeup.presentation.screens.components.PreviewFilesList +import com.elitec.appmakeup.presentation.viewmodels.ExportViewModel +import org.koin.compose.viewmodel.koinViewModel @Composable fun ExportScreen( projectPath: String, - onDone: () -> Unit + onBack: () -> Unit, + viewModel: ExportViewModel = koinViewModel() ) { - var isGenerating by remember { mutableStateOf(true) } - var error by remember { mutableStateOf(null) } - - LaunchedEffect(null) { - try { - // aquí llamas a GenerateCodeUseCase vía ViewModel - // exportViewModel.generate(projectPath) - isGenerating = false - } catch (e: Exception) { - error = e.message - isGenerating = false - } + val state by viewModel.uiState.collectAsStateWithLifecycle() + val previewState by viewModel.uiPreviewState.collectAsStateWithLifecycle() + + LaunchedEffect(projectPath) { + viewModel.loadProject(projectPath) } Column( modifier = Modifier .fillMaxSize() .padding(24.dp), - verticalArrangement = Arrangement.Center + verticalArrangement = Arrangement.spacedBy(16.dp) ) { - when { - isGenerating -> { - CircularProgressIndicator() - Spacer(Modifier.height(16.dp)) - Text("Generando código…") - } - error != null -> { - Text(error!!, color = MaterialTheme.colorScheme.error) - Button(onClick = onDone) { - Text("Volver") - } + + /* --------------------------- + * Header + * --------------------------- */ + + Text( + text = "Export project", + style = MaterialTheme.typography.headlineSmall + ) + + state.project?.let { project -> + Text("Project: ${project.name}") + Text("Package: ${project.packageName}") + Text("Features: ${project.features.size}") + } + + Divider() + + /* --------------------------- + * Options + * --------------------------- */ + + Row(verticalAlignment = Alignment.CenterVertically) { + Checkbox( + checked = state.dryRun, + onCheckedChange = viewModel::toggleDryRun + ) + Spacer(Modifier.width(8.dp)) + Text("Dry-run (do not write files)") + } + + Divider() + + /* --------------------------- + * Preview: Generation plan + * --------------------------- */ + + Text( + text = "Generation plan", + style = MaterialTheme.typography.titleMedium + ) + + GenerationPlanPreview(previewState) + + Divider() + + /* --------------------------- + * Preview: Files (dry-run) + * --------------------------- */ + + if (previewState.previewFiles.isNotEmpty()) { + Text( + text = "Files preview", + style = MaterialTheme.typography.titleMedium + ) + + PreviewFilesList(previewState.previewFiles) + } + + Spacer(Modifier.height(8.dp)) + + /* --------------------------- + * Actions + * --------------------------- */ + + Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) { + + Button( + onClick = viewModel::runPreview, + enabled = state.project != null && !state.isRunning + ) { + Text("Preview") } - else -> { - Text("Código generado correctamente 🎉") - Spacer(Modifier.height(16.dp)) - Button(onClick = onDone) { - Text("Volver al editor") - } + + Button( + onClick = viewModel::runExport, + enabled = state.project != null && !state.isRunning + ) { + Text(if (state.dryRun) "Run dry-run" else "Export") } } + + if (state.isRunning) { + CircularProgressIndicator() + } + + state.result?.let { + Text(it, color = MaterialTheme.colorScheme.primary) + } + + state.error?.let { + Text(it, color = MaterialTheme.colorScheme.error) + } + + Spacer(Modifier.weight(1f)) + + OutlinedButton(onClick = onBack) { + Text("Back") + } } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt index bfd0d4e..81bfa62 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/HomeScreen.kt @@ -1,14 +1,21 @@ package com.elitec.appmakeup.presentation.screens +import androidx.compose.animation.AnimatedVisibility import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.Button import androidx.compose.material3.Divider import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect @@ -28,6 +35,7 @@ fun HomeScreen( viewModel: HomeViewModel = koinViewModel() ) { val state by viewModel.uiState.collectAsStateWithLifecycle() + val lazyColumnState = rememberLazyListState() LaunchedEffect(Unit) { viewModel.loadRecentProjects() @@ -49,17 +57,35 @@ fun HomeScreen( Text("Proyectos recientes", style = MaterialTheme.typography.titleMedium) - if (state.recentProjects.isEmpty()) { - Text("No hay proyectos recientes") - } else { - state.recentProjects.forEach { path -> - Text( - text = path, - modifier = Modifier - .fillMaxWidth() - .clickable { onOpenProject(path) } - .padding(8.dp) - ) + AnimatedVisibility( + visible = state.recentProjects.isEmpty() + ) { + Row( + modifier = Modifier.fillMaxWidth() + ) { + Text("No hay proyectos recientes") + } + } + + AnimatedVisibility( + visible = state.recentProjects.isNotEmpty() + ) { + Surface( + color = MaterialTheme.colorScheme.surface, + modifier = Modifier.fillMaxWidth(), + shape = RoundedCornerShape(10.dp) + ) { + LazyColumn { + items(state.recentProjects) { path -> + Text( + text = path, + modifier = Modifier + .fillMaxWidth() + .clickable { onOpenProject(path) } + .padding(8.dp) + ) + } + } } } diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt index 45e16ac..5f520a7 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/ProjectEditorScreen.kt @@ -3,27 +3,29 @@ package com.elitec.appmakeup.presentation.screens import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.elitec.appmakeup.presentation.screens.components.EditorContent import com.elitec.appmakeup.presentation.screens.components.ErrorView -import com.elitec.appmakeup.presentation.screens.components.ProjectEditorContent import com.elitec.appmakeup.presentation.viewmodels.ProjectEditorViewModel import org.koin.compose.viewmodel.koinViewModel @Composable fun ProjectEditorScreen( projectPath: String, - onBack: () -> Unit, - onExportFinish: () -> Unit, - modifier: Modifier = Modifier, + onNavigateToExport: () -> Unit, viewModel: ProjectEditorViewModel = koinViewModel() ) { val state by viewModel.uiState.collectAsStateWithLifecycle() + // Cargar proyecto una sola vez LaunchedEffect(projectPath) { viewModel.loadProject(projectPath) } @@ -39,23 +41,30 @@ fun ProjectEditorScreen( } state.error != null -> { - ErrorView( - message = state.error!!, - onBack = onBack - ) + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center + ) { + Text( + text = state.error ?: "Unknown error", + color = MaterialTheme.colorScheme.error + ) + } } - state.project != null -> { - ProjectEditorContent( + else -> { + EditorContent( state = state, + onSelectFeature = viewModel::selectFeature, onAddFeature = viewModel::addFeature, onRemoveFeature = viewModel::removeFeature, - onSelectFeature = viewModel::selectFeature, onAddProperty = viewModel::addProperty, onRemoveProperty = viewModel::removeProperty, onExport = { - viewModel.exportProject() - onExportFinish() + viewModel.export() + if (state.canExport) { + onNavigateToExport() + } } ) } diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt index ea3a1a8..94f964f 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddFeatureInput.kt @@ -15,24 +15,25 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.unit.dp @Composable -fun AddFeatureInput( - onAddFeature: (String) -> Unit -) { +fun AddFeatureInput(onAddFeature: (String) -> Unit) { var name by remember { mutableStateOf("") } Row { OutlinedTextField( value = name, onValueChange = { name = it }, - label = { Text("New feature") } + label = { Text("New feature") }, + modifier = Modifier.weight(1f) ) Spacer(Modifier.width(8.dp)) - Button(onClick = { - if (name.isNotBlank()) { - onAddFeature(name) - name = "" + Button( + onClick = { + if (name.isNotBlank()) { + onAddFeature(name) + name = "" + } } - }) { + ) { Text("Add") } } diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt index d0978bb..a634f42 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/AddPropertyInput.kt @@ -28,23 +28,28 @@ fun AddPropertyInput( onValueChange = { name = it }, label = { Text("Property name") } ) + OutlinedTextField( value = type, onValueChange = { type = it }, label = { Text("Type") } ) + Row(verticalAlignment = Alignment.CenterVertically) { Checkbox(checked = isId, onCheckedChange = { isId = it }) Text("Identifier") } - Button(onClick = { - if (name.isNotBlank()) { - onAddProperty(featureName, name, type, isId) - name = "" - isId = false + + Button( + onClick = { + if (name.isNotBlank()) { + onAddProperty(featureName, name, type, isId) + name = "" + isId = false + } } - }) { - Text("Add Property") + ) { + Text("Add property") } } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ProjectEditorContent.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/EditorContent.kt similarity index 51% rename from composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ProjectEditorContent.kt rename to composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/EditorContent.kt index 226c777..a6459ac 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/ProjectEditorContent.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/EditorContent.kt @@ -1,7 +1,6 @@ package com.elitec.appmakeup.presentation.screens.components import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer @@ -18,39 +17,37 @@ import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.unit.dp import com.elitec.appmakeup.presentation.states.ProjectEditorUiState @Composable -fun ProjectEditorContent( +fun EditorContent( state: ProjectEditorUiState, + onSelectFeature: (String) -> Unit, onAddFeature: (String) -> Unit, onRemoveFeature: (String) -> Unit, - onSelectFeature: (String) -> Unit, onAddProperty: (String, String, String, Boolean) -> Unit, onRemoveProperty: (String, String) -> Unit, onExport: () -> Unit ) { Row(modifier = Modifier.fillMaxSize().padding(16.dp)) { - /* ---------- Feature list ---------- */ - Column( - modifier = Modifier.weight(0.3f) - ) { + /* --------------------------- + * Features + * --------------------------- */ + Column(modifier = Modifier.weight(0.3f)) { Text("Features", style = MaterialTheme.typography.titleMedium) - Spacer(Modifier.height(8.dp)) - state.features.forEach { feature -> Row( - modifier = Modifier - .fillMaxWidth() + modifier = Modifier.fillMaxWidth() .clickable { onSelectFeature(feature.name) } .padding(8.dp), - horizontalArrangement = Arrangement.SpaceBetween + verticalAlignment = Alignment.CenterVertically ) { - Text(feature.name) + Text(feature.name, modifier = Modifier.weight(1f)) IconButton(onClick = { onRemoveFeature(feature.name) }) { Icon(Icons.Default.Delete, contentDescription = null) } @@ -58,64 +55,64 @@ fun ProjectEditorContent( } Spacer(Modifier.height(8.dp)) - AddFeatureInput(onAddFeature) } Spacer(Modifier.width(16.dp)) - /* ---------- Feature editor ---------- */ - Column( - modifier = Modifier.weight(0.7f) - ) { - val feature = state.selectedFeature - - if (feature == null) { - Text("Select a feature to edit") - return@Column - } - - Text( - "Feature: ${feature.name}", - style = MaterialTheme.typography.titleMedium - ) - - Spacer(Modifier.height(8.dp)) - - Text("Properties") - - Spacer(Modifier.height(4.dp)) - - state.properties.forEach { prop -> - Row( - modifier = Modifier.fillMaxWidth(), - horizontalArrangement = Arrangement.SpaceBetween - ) { - Text("${prop.name}: ${prop.type}") - IconButton( - onClick = { - onRemoveProperty(feature.name, prop.name) - } + /* --------------------------- + * Feature detail + * --------------------------- */ + Column(modifier = Modifier.weight(0.7f)) { + state.selectedFeature?.let { feature -> + Text( + "Feature: ${feature.name}", + style = MaterialTheme.typography.titleMedium + ) + + feature.properties.forEach { prop -> + Row( + modifier = Modifier.fillMaxWidth().padding(8.dp), + verticalAlignment = Alignment.CenterVertically ) { - Icon(Icons.Default.Delete, contentDescription = null) + Text( + "${prop.name}: ${prop.type}" + + if (prop.isIdentifier) " (ID)" else "", + modifier = Modifier.weight(1f) + ) + + IconButton( + onClick = { + onRemoveProperty(feature.name, prop.name) + } + ) { + Icon(Icons.Default.Delete, contentDescription = null) + } } } + + Spacer(Modifier.height(8.dp)) + AddPropertyInput(feature.name, onAddProperty) } - Spacer(Modifier.height(8.dp)) + Spacer(Modifier.height(16.dp)) - AddPropertyInput( - featureName = feature.name, - onAddProperty = onAddProperty - ) + /* --------------------------- + * Validation + * --------------------------- */ + if (state.validationErrors.isNotEmpty()) { + state.validationErrors.forEach { + Text(it, color = MaterialTheme.colorScheme.error) + } + } - Spacer(Modifier.height(24.dp)) + Spacer(Modifier.height(16.dp)) Button( onClick = onExport, - enabled = !state.isExporting + enabled = state.canExport ) { - Text(if (state.isExporting) "Exporting..." else "Export Project") + Text("Export project") } } } diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/GenerationPlanPreview.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/GenerationPlanPreview.kt new file mode 100644 index 0000000..1b78e9d --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/GenerationPlanPreview.kt @@ -0,0 +1,46 @@ +package com.elitec.appmakeup.presentation.screens.components + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.width +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Check +import androidx.compose.material.icons.filled.Close +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import com.elitec.appmakeup.presentation.states.GenerationPreviewUiState + +@Composable +fun GenerationPlanPreview(state: GenerationPreviewUiState) { + Column(verticalArrangement = Arrangement.spacedBy(4.dp)) { + PlanItem("Domain layer", state.generateDomain) + PlanItem("Data layer", state.generateData) + PlanItem("Repositories", state.generateRepositories) + PlanItem("Mappers", state.generateMappers) + } +} + +@Composable +private fun PlanItem(label: String, enabled: Boolean) { + Row(verticalAlignment = Alignment.CenterVertically) { + Icon( + imageVector = + if (enabled) Icons.Default.Check else Icons.Default.Close, + contentDescription = null, + tint = + if (enabled) + MaterialTheme.colorScheme.primary + else + MaterialTheme.colorScheme.onSurfaceVariant + ) + Spacer(Modifier.width(8.dp)) + Text(label) + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/PreviewFilesList.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/PreviewFilesList.kt new file mode 100644 index 0000000..b5c599d --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/screens/components/PreviewFilesList.kt @@ -0,0 +1,30 @@ +package com.elitec.appmakeup.presentation.screens.components + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp + +@Composable +fun PreviewFilesList(files: List) { + Column( + modifier = Modifier + .fillMaxWidth() + .heightIn(max = 200.dp) + .padding(start = 8.dp), + verticalArrangement = Arrangement.spacedBy(4.dp) + ) { + files.forEach { file -> + Text( + text = "• $file", + style = MaterialTheme.typography.bodySmall + ) + } + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/GenerationPreviewUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/GenerationPreviewUiState.kt new file mode 100644 index 0000000..5ea4fca --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/GenerationPreviewUiState.kt @@ -0,0 +1,9 @@ +package com.elitec.appmakeup.presentation.states + +data class GenerationPreviewUiState( + val generateDomain: Boolean = false, + val generateData: Boolean = false, + val generateRepositories: Boolean = false, + val generateMappers: Boolean = false, + val previewFiles: List = emptyList() +) \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt index 5c50e2f..042ed99 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/states/ProjectEditorUiState.kt @@ -9,8 +9,8 @@ data class ProjectEditorUiState( val project: AppMakeupProject? = null, val features: List = emptyList(), val selectedFeature: AppFeature? = null, - val properties: List = emptyList(), + val validationErrors: List = emptyList(), val isLoading: Boolean = false, - val isExporting: Boolean = false, // ✅ NUEVO + val canExport: Boolean = false, val error: String? = null ) \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt index 8c84083..3596b52 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt @@ -1,8 +1,12 @@ package com.elitec.appmakeup.presentation.viewmodels import androidx.lifecycle.ViewModel +import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.contracts.GenerationResult import com.elitec.appmakeup.generation.GenerateCodeUseCase +import com.elitec.appmakeup.generation.PreviewGenerationPlanUseCase import com.elitec.appmakeup.presentation.states.ExportUiState +import com.elitec.appmakeup.presentation.states.GenerationPreviewUiState import com.elitec.appmakeup.projects.usecase.project.LoadProjectUseCase import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow @@ -10,12 +14,16 @@ import kotlinx.coroutines.flow.update class ExportViewModel( private val loadProjectUseCase: LoadProjectUseCase, - private val generateCodeUseCase: GenerateCodeUseCase + private val generateCodeUseCase: GenerateCodeUseCase, + private val previewGenerationPlanUseCase: PreviewGenerationPlanUseCase ) : ViewModel() { private val _uiState = MutableStateFlow(ExportUiState()) val uiState: StateFlow = _uiState + private val _uiPreviewState = MutableStateFlow(GenerationPreviewUiState()) + val uiPreviewState: StateFlow = _uiPreviewState + /* --------------------------- * Init * --------------------------- */ @@ -53,17 +61,18 @@ class ExportViewModel( } try { - // 🔑 El dry-run debe venir reflejado en el proyecto / contexto generateCodeUseCase.execute( - project, true + project = project, + dryRun = _uiState.value.dryRun ) _uiState.update { it.copy( - result = if (_uiState.value.dryRun) - "Dry-run completed successfully" - else - "Project exported successfully" + result = + if (_uiState.value.dryRun) + "Dry-run completed successfully" + else + "Project exported successfully" ) } } catch (e: Exception) { @@ -76,4 +85,34 @@ class ExportViewModel( } } } + + fun previewPlan(context: GenerationContext) { + val plan = previewGenerationPlanUseCase.execute(context) + + _uiPreviewState.update { + it.copy( + generateDomain = plan.generateDomain, + generateData = plan.generateData, + generateRepositories = plan.generateRepositories, + generateMappers = plan.generateMappers + ) + } + } + + fun runPreview() { + val project = _uiState.value.project ?: return + + val result = generateCodeUseCase.execute( + project = project, + dryRun = true + ) + + if (result is GenerationResult.Preview) { + _uiPreviewState.update { + it.copy( + previewFiles = result.files + ) + } + } + } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt index f2e7daa..87c2a45 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ProjectEditorViewModel.kt @@ -25,9 +25,6 @@ import kotlinx.coroutines.flow.update class ProjectEditorViewModel( private val loadProjectUseCase: LoadProjectUseCase, private val saveProjectUseCase: SaveProjectUseCase, - private val listFeaturesUseCase: ListFeaturesUseCase, - private val getFeatureUseCase: GetFeatureUseCase, - private val listPropertiesUseCase: ListPropertiesUseCase, private val addFeatureUseCase: AddFeatureUseCase, private val removeFeatureUseCase: RemoveFeatureUseCase, private val addPropertyUseCase: AddPropertyUseCase, @@ -39,13 +36,13 @@ class ProjectEditorViewModel( val uiState: StateFlow = _uiState /* --------------------------- - * Project lifecycle + * Load * --------------------------- */ fun loadProject(path: String) { try { val project = loadProjectUseCase.execute(path) - refreshProject(project) + refresh(project) } catch (e: Exception) { _uiState.update { it.copy(isLoading = false, error = e.message) @@ -54,129 +51,173 @@ class ProjectEditorViewModel( } /* --------------------------- - * Feature management + * Feature * --------------------------- */ fun addFeature(name: String) { val project = currentProject() ?: return - val updated = addFeatureUseCase.execute( - project, - AppFeature( - name = name, - properties = emptyList() + if (project.features.any { it.name == name }) { + fail("Feature '$name' already exists") + return + } + + val feature = AppFeature( + name = name, + properties = listOf( + AppProperty( + name = "id", + type = "String", + isIdentifier = true + ) ) ) - persistAndRefresh(updated) - selectFeature(name) + refresh(addFeatureUseCase.execute(project, feature)) } fun removeFeature(name: String) { val project = currentProject() ?: return - val updated = removeFeatureUseCase.execute(project, name) - persistAndRefresh(updated) + if (project.features.size == 1) { + fail("Project must contain at least one feature") + return + } - // si borraste la seleccionada, limpia selección - _uiState.update { it.copy(selectedFeature = null, properties = emptyList()) } + refresh(removeFeatureUseCase.execute(project, name)) } fun selectFeature(name: String) { - val project = currentProject() ?: return - - val feature = getFeatureUseCase.execute(project, name) - val properties = feature?.let { - listPropertiesUseCase.execute(project, it.name) - }.orEmpty() - - _uiState.update { - it.copy( - selectedFeature = feature, - properties = properties - ) - } + val feature = currentProject()?.features?.find { it.name == name } + _uiState.update { it.copy(selectedFeature = feature) } } /* --------------------------- - * Property management + * Properties * --------------------------- */ fun addProperty( featureName: String, propertyName: String, type: String, - isIdentifier: Boolean = false + isIdentifier: Boolean ) { val project = currentProject() ?: return - val updated = addPropertyUseCase.execute( - project, - featureName, - AppProperty( - name = propertyName, - type = type, - isIdentifier = isIdentifier + val feature = project.features.find { it.name == featureName } ?: return + + if (isIdentifier && feature.properties.any { it.isIdentifier }) { + fail("Feature '$featureName' already has an identifier") + return + } + + refresh( + addPropertyUseCase.execute( + project, + featureName, + AppProperty(propertyName, type, isIdentifier) ) ) - - persistAndRefresh(updated) - selectFeature(featureName) } fun removeProperty(featureName: String, propertyName: String) { val project = currentProject() ?: return + val feature = project.features.find { it.name == featureName } ?: return - val updated = removePropertyUseCase.execute( - project, - featureName, - propertyName - ) + val property = feature.properties.find { it.name == propertyName } ?: return - persistAndRefresh(updated) - selectFeature(featureName) + if (property.isIdentifier) { + fail("An identifier property cannot be removed") + return + } + + refresh(removePropertyUseCase.execute(project, featureName, propertyName)) } /* --------------------------- - * Code generation / Export + * Export * --------------------------- */ - fun exportProject() { + fun export() { val project = currentProject() ?: return - _uiState.update { it.copy(isExporting = true, error = null) } - - try { - generateCodeUseCase.execute(project, dryRun = false) - } catch (e: Exception) { - _uiState.update { it.copy(error = e.message) } - } finally { - _uiState.update { it.copy(isExporting = false) } + val errors = validateProject(project) + if (errors.isNotEmpty()) { + _uiState.update { it.copy(validationErrors = errors) } + return } + + generateCodeUseCase.execute(project, true) } /* --------------------------- * Helpers * --------------------------- */ - private fun persistAndRefresh(project: AppMakeupProject) { - saveProjectUseCase.execute(project) - refreshProject(project) - } - - private fun refreshProject(project: AppMakeupProject) { - val features = listFeaturesUseCase.execute(project) + private fun refresh(project: AppMakeupProject) { + val errors = validateProject(project) _uiState.update { it.copy( project = project, - features = features, + features = project.features, + selectedFeature = null, + validationErrors = errors, + canExport = errors.isEmpty(), isLoading = false, error = null ) } + + saveProjectUseCase.execute(project) + } + + private fun fail(message: String) { + _uiState.update { it.copy(error = message) } } private fun currentProject(): AppMakeupProject? = _uiState.value.project + + private fun validateProject(project: AppMakeupProject): List { + val errors = mutableListOf() + + if (project.features.isEmpty()) { + errors += "Project must contain at least one feature" + } + + project.features.forEach { feature -> + if (feature.properties.isEmpty()) { + errors += "Feature '${feature.name}' must have at least one property" + } + + val identifiers = feature.properties.count { it.isIdentifier } + if (identifiers != 1) { + errors += "Feature '${feature.name}' must have exactly one identifier property" + } + } + + return errors + } + + private fun validateFeature(feature: AppFeature): String? { + + val identifiers = + feature.properties.count { it.isIdentifier } + + if (identifiers != 1) { + return "Feature '${feature.name}' must have exactly one identifier" + } + + feature.repository?.let { + if (!it.isValid()) { + return "Repository for '${feature.name}' must support at least one operation" + } + } + + return null + } + + fun canExport(): Boolean = + _uiState.value.features.all { validateFeature(it) == null } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/mappers/ProjectToCoreMapper.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/mappers/ProjectToCoreMapper.kt index 327d650..2671451 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/mappers/ProjectToCoreMapper.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/mappers/ProjectToCoreMapper.kt @@ -12,7 +12,7 @@ class ProjectToCoreMapper { fun mapFeature(feature: AppFeature): CoreFeature { val entity = CoreEntity( - name = feature.name, + name = feature.name.replaceFirstChar { it.uppercase() }, properties = feature.properties.map { CoreProperty( name = it.name, diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppFeature.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppFeature.kt index 9e0ee84..de7b3e0 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppFeature.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/AppFeature.kt @@ -5,5 +5,6 @@ import kotlinx.serialization.Serializable @Serializable data class AppFeature( val name: String, - val properties: List + val properties: List, + val repository: RepositoryConfig? = null ) \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/RepositoryConfig.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/RepositoryConfig.kt new file mode 100644 index 0000000..4eb1e2a --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/projects/model/RepositoryConfig.kt @@ -0,0 +1,14 @@ +package com.elitec.appmakeup.projects.model + +import kotlinx.serialization.Serializable + +@Serializable +data class RepositoryConfig( + val supportsCreate: Boolean = false, + val supportsRead: Boolean = true, + val supportsUpdate: Boolean = false, + val supportsDelete: Boolean = false +) { + fun isValid(): Boolean = + supportsCreate || supportsRead || supportsUpdate || supportsDelete +} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt index 4e224a9..d028bca 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/core/v4/pipeline/FileSystemWritingStage.jvm.kt @@ -1,42 +1,37 @@ package com.elitec.appmakeup.core.v4.pipeline +import com.elitec.appmakeup.core.v4.contracts.GenerationContext import com.elitec.appmakeup.core.v4.contracts.GenerationResult import java.io.File class FileSystemWritingStage( - private val options: WritingOptions = _root_ide_package_.com.elitec.appmakeup.core.v4.pipeline.WritingOptions() + private val options: WritingOptions = WritingOptions() ) : WritingStage { override fun write( outputPath: String, - artifacts: List + artifacts: List, + context: GenerationContext ): GenerationResult { - artifacts.forEach { artifact -> + val dryRun = context.options["dryRun"] as? Boolean ?: false + artifacts.forEach { artifact -> val file = File(outputPath, artifact.relativePath) - if (options.dryRun) { - // Simulación: no tocar filesystem + if (dryRun) { println("[DRY-RUN] Would write: ${file.path}") return@forEach } - // Crear directorios si no existen - file.parentFile?.let { parent -> - if (!parent.exists()) { - parent.mkdirs() - } - } + file.parentFile?.mkdirs() - // Archivo ya existe if (file.exists() && !options.overwrite) { return GenerationResult.Failure( "File already exists and overwrite=false: ${file.path}" ) } - // Escritura real file.writeText(artifact.content) } diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt index 53538be..e8f0c4e 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/coreV4Module.kt @@ -16,6 +16,7 @@ import com.elitec.appmakeup.core.v4.pipeline.FileSystemWritingStage import com.elitec.appmakeup.core.v4.pipeline.GenerationPipeline import com.elitec.appmakeup.core.v4.pipeline.GenerationStage import com.elitec.appmakeup.core.v4.pipeline.PlanningStage +import com.elitec.appmakeup.core.v4.pipeline.PreviewWritingStage import com.elitec.appmakeup.core.v4.pipeline.ReportFormat import com.elitec.appmakeup.core.v4.pipeline.ReportingStage import com.elitec.appmakeup.core.v4.pipeline.ValidationStage @@ -29,20 +30,20 @@ import org.koin.dsl.module val coreV4Module = module { - /* ------------------------- - * GENERATORS (CONCRETOS) - * ------------------------- */ + /* ========================================================= + * GENERATORS + * ========================================================= */ single { FeatureSkeletonGenerator() } single { DomainEntityGenerator() } - single { RepositoryGenerator( contracts = get()) } - single { UseCaseGenerator( contracts = get()) } - single { RepositoryImplGenerator( contracts = get()) } - single { MapperGenerator( contracts = get()) } + single { RepositoryGenerator(contracts = get()) } + single { UseCaseGenerator(contracts = get()) } + single { RepositoryImplGenerator(contracts = get()) } + single { MapperGenerator(contracts = get()) } - /* ------------------------- + /* ========================================================= * VALIDATION - * ------------------------- */ + * ========================================================= */ single { EntityValidator() } single { FeatureValidator(get()) } @@ -55,11 +56,10 @@ val coreV4Module = module { ) } - /* ------------------------- + /* ========================================================= * PLANNING - * ------------------------- */ + * ========================================================= */ - // Para MVP: listas explícitas (aunque estén vacías) single> { emptyList() } single> { emptyList() } @@ -70,9 +70,9 @@ val coreV4Module = module { ) } - /* ------------------------- + /* ========================================================= * GENERATION - * ------------------------- */ + * ========================================================= */ single { DefaultGenerationStage( @@ -89,46 +89,64 @@ val coreV4Module = module { get() ) ), - presentationGenerator = null, // Core V5 - repositoryGenerator = null, // ya incluido arriba - mapperGenerator = null // ya incluido arriba + presentationGenerator = null, + repositoryGenerator = null, + mapperGenerator = null ) } - /* ------------------------- - * WRITING - * ------------------------- */ + /* ========================================================= + * WRITING (REAL) + * ========================================================= */ single { FileSystemWritingStage( options = WritingOptions( - dryRun = true, + dryRun = false, overwrite = true ) ) } - /* ------------------------- + /* ========================================================= + * WRITING (PREVIEW) + * ========================================================= */ + + single { + PreviewWritingStage() + } + + /* ========================================================= * REPORTING - * ------------------------- */ + * ========================================================= */ single { - DefaultReportingStage( - format = ReportFormat.CLI - ) + DefaultReportingStage(ReportFormat.CLI) } - /* ------------------------- - * PIPELINE (CLAVE) - * ------------------------- */ + /* ========================================================= + * PIPELINES + * ========================================================= */ + + // Pipeline REAL + single { + GenerationPipeline( + validationStage = get(), + planningStage = get(), + generationStage = get(), + writingStage = get(), + reportingStage = get() + ) + } - single { + // Pipeline PREVIEW + single { GenerationPipeline( validationStage = get(), planningStage = get(), generationStage = get(), - writingStage = get(), - reportingStage = DefaultReportingStage(ReportFormat.CLI) + writingStage = get(), + reportingStage = get() ) } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt index 34e1712..320b9a3 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/infrastructureModule.kt @@ -11,19 +11,19 @@ import org.koin.dsl.module val infrastructureModule = module { - // Persistencia de proyecto single { FileProjectPersistence() } - // Recientes single { FileRecentProjectsRepository() } - // Export / generación single { - ProjectExporter(get()) + ProjectExporter( + pipeline = get(), + previewPipeline = get() + ) } single { diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt index d6d5bea..cfffdda 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/initKoin.kt @@ -6,7 +6,6 @@ fun initKoin() { startKoin { modules( infrastructureModule, - validationModule, coreV4Module, applicationModule, presentationModule diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt deleted file mode 100644 index 7fc4f5d..0000000 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/di/validationModule.kt +++ /dev/null @@ -1,22 +0,0 @@ -package com.elitec.appmakeup.di - -import com.elitec.appmakeup.core.v4.pipeline.ValidationStage -import com.elitec.appmakeup.core.v4.validation.ArchitectureValidator -import com.elitec.appmakeup.core.v4.validation.DefaultValidationStage -import com.elitec.appmakeup.core.v4.validation.EntityValidator -import com.elitec.appmakeup.core.v4.validation.FeatureValidator -import org.koin.dsl.module - -val validationModule = module { - - single { EntityValidator() } - single { FeatureValidator(get()) } - single { ArchitectureValidator() } - - single { - DefaultValidationStage( - featureValidator = get(), - architectureValidator = get() - ) - } -} \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt index fbd116f..83a8e14 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt @@ -2,27 +2,59 @@ package com.elitec.appmakeup.exports import com.elitec.appmakeup.core.architecture.DefaultArchitecture import com.elitec.appmakeup.core.v4.contracts.GenerationContext +import com.elitec.appmakeup.core.v4.contracts.GenerationResult import com.elitec.appmakeup.core.v4.pipeline.GenerationPipeline +import com.elitec.appmakeup.logs.Logger import com.elitec.appmakeup.projects.mappers.ProjectToCoreMapper import com.elitec.appmakeup.projects.model.AppMakeupProject class ProjectExporter( - private val pipeline: GenerationPipeline + private val pipeline: GenerationPipeline, + private val previewPipeline: GenerationPipeline ) { - fun export(project: AppMakeupProject, dryRun: Boolean) { + private val tag = "ProjectExporter::DESKTOP" + + fun export( + project: AppMakeupProject, + dryRun: Boolean + ): GenerationResult { + + Logger.success( + tag, + "Init generation code in platform (dryRun=$dryRun)" + ) val packagePath = project.packageName.replace(".", "/") + Logger.success( + tag, + "Generation code package path: $packagePath" + ) val outputPath = "${project.path}/export/composeApp/src/androidMain/kotlin/$packagePath" + Logger.success( + tag, + "Generation output path: $outputPath" + ) + + val pipelineToUse = + if (dryRun) previewPipeline else pipeline + + var lastResult: GenerationResult = GenerationResult.Success + project.features.forEach { feature -> + Logger.warning( + tag, + "Scanning feature: ${feature.name}" + ) + val coreFeature = ProjectToCoreMapper().mapFeature(feature) - pipeline.run( + val result = pipelineToUse.run( GenerationContext( architecture = DefaultArchitecture.value, feature = coreFeature, @@ -30,6 +62,35 @@ class ProjectExporter( options = mapOf("dryRun" to dryRun) ) ) + + when (result) { + is GenerationResult.Failure -> { + Logger.error( + tag, + "Generation failed for feature ${feature.name}", + RuntimeException(result.reason) + ) + return result + } + + is GenerationResult.Preview -> { + Logger.success( + tag, + "Preview generated for feature ${feature.name} (${result.files.size} files)" + ) + lastResult = result + } + + GenerationResult.Success -> { + Logger.success( + tag, + "Generation completed for feature ${feature.name}" + ) + lastResult = result + } + } } + + return lastResult } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt index f3a5662..d6520f0 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt @@ -1,12 +1,17 @@ package com.elitec.appmakeup.generation +import com.elitec.appmakeup.core.v4.contracts.GenerationResult import com.elitec.appmakeup.exports.ProjectExporter +import com.elitec.appmakeup.projects.model.AppMakeupProject class ProjectCodeGenerator( private val exporter: ProjectExporter ) : CodeGenerator { - override fun generate(intent: CodeGenerationIntent, dryRun: Boolean) { - exporter.export(intent.project, dryRun) + private val tag = "[ProjectCodeGenerator]---> " + + override fun generate(intent: CodeGenerationIntent, dryRun: Boolean): GenerationResult { + println("$tag Init executing Generation in platform with \ndryRun: $dryRun") + return exporter.export(intent.project, dryRun) } } \ No newline at end of file From 9454aa1d0cdb578d42ed1402e01b0dfbb8ca7b0b Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Mon, 26 Jan 2026 11:36:08 -0600 Subject: [PATCH 19/20] preview after export files --- .../appmakeup/generation/CodeGenerator.kt | 1 + .../generation/GenerateCodeUseCase.kt | 4 +++ .../viewmodels/ExportViewModel.kt | 13 +++------ .../appmakeup/exports/ProjectExporter.kt | 27 +++++++++++++++++++ .../generation/ProjectCodeGenerator.kt | 5 ++++ 5 files changed, 40 insertions(+), 10 deletions(-) diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt index 3bab2bb..72d5033 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/CodeGenerator.kt @@ -6,4 +6,5 @@ import com.elitec.appmakeup.projects.model.AppMakeupProject interface CodeGenerator { fun generate(intent: CodeGenerationIntent,dryRun: Boolean): GenerationResult + fun preview(project: AppMakeupProject): List } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt index 2b18a32..a73229e 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/generation/GenerateCodeUseCase.kt @@ -24,4 +24,8 @@ class GenerateCodeUseCase( println("$tag make generation intent: $intent") return codeGenerator.generate(intent, dryRun) } + + fun preview(project: AppMakeupProject): List { + return codeGenerator.preview(project) + } } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt index 3596b52..35ccc97 100644 --- a/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/elitec/appmakeup/presentation/viewmodels/ExportViewModel.kt @@ -102,17 +102,10 @@ class ExportViewModel( fun runPreview() { val project = _uiState.value.project ?: return - val result = generateCodeUseCase.execute( - project = project, - dryRun = true - ) + val files = generateCodeUseCase.preview(project) - if (result is GenerationResult.Preview) { - _uiPreviewState.update { - it.copy( - previewFiles = result.files - ) - } + _uiPreviewState.update { + it.copy(previewFiles = files) } } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt index 83a8e14..c5800a1 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/exports/ProjectExporter.kt @@ -93,4 +93,31 @@ class ProjectExporter( return lastResult } + + fun preview(project: AppMakeupProject): List { + val allFiles = mutableListOf() + + val packagePath = project.packageName.replace(".", "/") + val outputPath = + "${project.path}/export/composeApp/src/androidMain/kotlin/$packagePath" + + project.features.forEach { feature -> + val coreFeature = ProjectToCoreMapper().mapFeature(feature) + + val result = previewPipeline.run( + GenerationContext( + architecture = DefaultArchitecture.value, + feature = coreFeature, + outputPath = outputPath, + options = mapOf("dryRun" to true) + ) + ) + + if (result is GenerationResult.Preview) { + allFiles += result.files + } + } + + return allFiles + } } \ No newline at end of file diff --git a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt index d6520f0..5007c0f 100644 --- a/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt +++ b/composeApp/src/jvmMain/kotlin/com/elitec/appmakeup/generation/ProjectCodeGenerator.kt @@ -14,4 +14,9 @@ class ProjectCodeGenerator( println("$tag Init executing Generation in platform with \ndryRun: $dryRun") return exporter.export(intent.project, dryRun) } + + override fun preview(project: AppMakeupProject): List { + println("$tag Preview Generation in platform ") + return exporter.preview(project) + } } \ No newline at end of file From bc6045c4f1b11723c3dd9b40979ebb0d4922e81b Mon Sep 17 00:00:00 2001 From: Danielito1996 Date: Mon, 26 Jan 2026 11:43:02 -0600 Subject: [PATCH 20/20] docs coreV4 --- README.md | 265 ++++++++++++++++++++++++++++-------------------------- 1 file changed, 136 insertions(+), 129 deletions(-) diff --git a/README.md b/README.md index fd4dc01..6c04fd8 100644 --- a/README.md +++ b/README.md @@ -1,188 +1,204 @@ -# AppMakeup — Core V2 - ---- +# AppMakeup — Core V4 (Closed) ## 🚀 What is AppMakeup? -**AppMakeup** is a desktop application built with **Kotlin Multiplatform** and **Compose Desktop** whose goal is to **visually model application architecture and generate deterministic project structures** following Clean Architecture principles. +**AppMakeup** is a desktop application built with **Kotlin Multiplatform** and **Compose Desktop** that allows you to **model application architecture visually** and **generate deterministic project structures and code** following Clean Architecture principles. -AppMakeup is intentionally **not** an AI tool, nor a "smart" code generator. +AppMakeup is **not an AI tool**. It does **not**: -- guess business logic -- generate application behavior -- run or compile generated apps +- infer business logic +- guess architecture decisions +- generate behavior automatically -Instead, AppMakeup focuses on **architecture as a first-class concept**. +Instead, AppMakeup is a **deterministic architecture compiler**. -> You design the architecture explicitly. AppMakeup materializes it safely. +> You declare architecture. AppMakeup materializes it safely. --- -## 🎯 Why AppMakeup exists - -In real projects, most long-term problems come from: - -- unclear architecture decisions -- inconsistent project structures -- premature coupling between layers -- uncontrolled growth of modules - -AppMakeup exists to solve those problems **before code is written**. - -It allows developers to: -- model architecture visually -- enforce structure without loss of control -- evolve projects without rewrites -- keep Clean Architecture explicit and verifiable - ---- - -## 🧠 Core philosophy - -AppMakeup is built around these principles: +## 🧠 Core Philosophy (Unchanged) - Architecture first, code second - Structure before implementation - Predictability over magic - Deterministic generation -- Strict separation of layers +- Explicit contracts and layers - No filesystem access from UI - No domain logic in presentation -- Explicit, atomic use cases +- Atomic, testable use cases --- -## ✅ Current State — **Core V2 (Stable)** +## ✅ Current State — **Core V4 (Closed & Stable)** -AppMakeup is currently in **Core V2**, which is considered **stable and closed**. +Core V4 is now **feature-complete and closed**. -**Core V2 is about structure, not code.** +It represents the **first full generation-capable core**, where AppMakeup moves from *structure modeling* to **real, validated code generation** while preserving strict architectural guarantees. -This core establishes a solid foundation that future versions build upon without breaking. +Core V4 builds on Core V2 and Core V3 concepts but introduces a **generation pipeline**, **planning stage**, and **dry-run previews**. --- -## ✨ What Core V2 Includes +## ✨ What Core V4 Includes -### 🧭 Project lifecycle +### 🧭 Project Lifecycle - Create new projects - - application name - - package name - - workspace location - Open existing projects -- Persist recent projects on disk -- Normalize and deduplicate paths -- Remove invalid projects automatically +- Persist and validate projects on disk +- Versioned project format +- Recent projects registry + +--- + +### 🧩 Architecture Modeling + +- Features +- Domain entities +- Entity properties +- Identifier enforcement +- Layer selection per feature +- Validation before generation + +Invalid states are **prevented at editor level**. + +--- -### 🔍 Project validation +### 🧪 Generation Pipeline (Core V4) -Before opening a project, AppMakeup validates: +Core V4 introduces a **5-stage deterministic pipeline**: -- directory existence -- AppMakeup project structure -- presence of `project.amk.json` -- JSON integrity -- project version compatibility +1. **ValidationStage** + - Entity rules + - Feature rules + - Architecture constraints -All validation errors are **explicit and user-friendly**. +2. **PlanningStage** + - Decides what layers will be generated + - Domain / Data / Repositories / Mappers + - Fully testable and previewable + +3. **GenerationStage** + - Layer generators + - Templates + - No filesystem access + +4. **WritingStage** + - Real filesystem writer + - Dry-run writer (preview mode) + +5. **ReportingStage** + - CLI / Table / JSON output --- -## 🧩 Architecture Modeling +### 🧪 Dry-Run Mode -Inside a project, Core V2 supports: +Core V4 supports **true dry-run execution**: -- Feature definition -- Domain entity modeling -- Entity property modeling -- Dirty-state tracking -- Model validation before generation -- Deterministic structure generation +- No files are written +- Generated artifacts are collected +- Output paths are simulated +- Safe to run repeatedly -All modeling happens at the **domain level**, never at the code level. +Used for: +- UI preview +- Tests +- Validation before export --- -## 🏗️ Project Architecture (Internal) +### 🧩 Generation Plan Preview (UI) -AppMakeup follows **Clean Architecture**, adapted for a modeling-first tool. +Before exporting, users can see: -### Main layers +- Which layers will be generated +- Whether repositories/mappers apply +- Why a layer is skipped +- Validation errors per feature + +This makes generation **explainable**, not magical. + +--- + +### 🧾 Files Preview (Dry-Run Visual) + +The UI shows: +- Exact files that would be generated +- Relative paths +- Per-feature grouping + +Nothing is written unless explicitly exported. + +--- + +### 🏗️ Internal Architecture (Clean Architecture) **Domain** -- modeling entities -- validation rules -- use cases +- Core models +- Validators +- Generation pipeline +- Planning logic -**Data** -- repositories -- JSON persistence -- filesystem access (Okio) +**Application** +- Use cases +- Intent orchestration -**Templates & Generation** -- project templates -- structure generators -- filesystem writers +**Infrastructure** +- Filesystem +- Exporters +- Pipelines wiring (Koin) **Presentation** - Compose Desktop UI - ViewModels -- UI state management - -**Infrastructure** -- dependency injection (Koin) -- settings persistence -- application configuration +- UI state only --- ## 🧪 Testing & Quality -Core V2 has strong test coverage: +Core V4 is heavily tested: -- Domain logic is fully unit tested -- Structure generation is deterministic and testable -- Filesystem operations are tested using fake filesystems -- Tests validate **structure**, not code +- Pipeline unit tests +- Dry-run generation tests +- Failure-path tests +- Deterministic artifact assertions -Code style consistency is enforced using **ktlint**. +Generation is **100% testable without filesystem**. --- -## 🚫 What Core V2 Intentionally Does NOT Do - -To keep the core clean and extensible, Core V2 does **not**: +## 🚫 What Core V4 Does NOT Do -- generate Kotlin/Java code -- create ViewModels or Screens automatically -- run or compile generated projects -- perform automatic migrations -- provide undo/redo -- act as an IDE replacement +By design, Core V4 does **not**: -These are **deliberate design decisions**. +- generate UI screens +- generate ViewModels +- guess repository contracts +- auto-migrate projects +- act as an IDE +- include undo/redo (yet) --- -## 🗺️ Roadmap +## 🔮 What Comes Next — **Core V5 (Planned)** -### 🔜 Core V3 — Code Generation +Core V5 will focus on **advanced modeling and extensibility**: -- Code generation layer -- Android Clean Architecture generator -- `.kt` file generation -- Separation between structure and code -- Pluggable code generators +### Planned features -### 🔮 Core V4 — Advanced Modeling - -- Undo / Redo (Memento pattern) +- RepositoryContract editor (visual CRUD modeling) +- Explicit Mapper contracts +- Multi-platform generators (Android / KMP / Backend) - Plugin system -- Multi-platform generators -- Advanced templates -- Migration tooling +- Template customization +- Undo / Redo (Memento pattern) +- Project migrations +- Export profiles + +Core V5 will **not break Core V4 projects**. --- @@ -194,25 +210,16 @@ These are **deliberate design decisions**. ./gradlew :composeApp:run ``` -### Windows installer (MSI) - -```bash -./gradlew packageMsi -``` - --- -## 🤝 For contributors & forks - -This repository represents a **stable Core V2**. - -You can safely: +## 🤝 Final Notes -- build new code generators -- add project migrations -- extend templates -- improve UI/UX -- target new platforms +Core V4 marks a **major milestone**: -> Core V2 is designed to grow — not to be rewritten. +- Architecture is explicit +- Generation is deterministic +- Previews are safe +- Errors are explainable +> AppMakeup is no longer a generator. +> It is an **architecture compiler**.