Implemented Assumptions

src/data/AssumptionRepository.mts

@@ -0,0 +1,11 @@
+import Assumption from '~/domain/Assumption.mjs';
+import StorageRepository from './StorageRepository.mjs';
+import pkg from '~/../package.json' with { type: 'json' };
+import type { SemVerString } from '~/lib/SemVer.mjs';
+import AssumptionToJsonMapper from '~/mappers/AssumptionToJsonMapper.mjs';
+
+export default class AssumptionRepository extends StorageRepository<Assumption> {
+    constructor(storage: Storage) {
+        super('assumption', storage, new AssumptionToJsonMapper(pkg.version as SemVerString));
+    }
+}

src/domain/Assumption.mts

@@ -0,0 +1,8 @@
+import Requirement from './Requirement.mjs';
+
+/**
+ * An assumption is a property of the environment that is assumed to be true.
+ * Assumptions are used to simplify the problem and to make it more tractable.
+ * An example of an assumption would be: "Screen resolutions will not change during the execution of the program."
+ */
+export default class Assumption extends Requirement { }

src/domain/Environment.mts

@@ -13,11 +13,13 @@ export default class Environment extends Entity {
     glossaryIds: Uuid[];
     constraintIds: Uuid[];
     invariantIds: Uuid[];
+    assumptionIds: Uuid[];
 
     constructor(options: Properties<Environment>) {
         super(options);
         this.glossaryIds = options.glossaryIds;
         this.constraintIds = options.constraintIds;
         this.invariantIds = options.invariantIds;
+        this.assumptionIds = options.assumptionIds;
     }
 }

src/mappers/AssumptionToJsonMapper.mts

@@ -0,0 +1,20 @@
+import RequirementToJsonMapper, { type RequirementJson } from './RequirementToJsonMapper.mjs';
+import SemVer from '~/lib/SemVer.mjs';
+import Assumption from '~/domain/Assumption.mjs';
+
+export interface AssumptionJson extends RequirementJson { }
+
+export default class AssumptionToJsonMapper extends RequirementToJsonMapper {
+    override mapFrom(target: AssumptionJson): Assumption {
+        const version = new SemVer(target.serializationVersion);
+
+        if (version.gte('0.4.0'))
+            return new Assumption(target);
+
+        throw new Error(`Unsupported serialization version: ${version}`);
+    }
+
+    override mapTo(source: Assumption): AssumptionJson {
+        return super.mapTo(source);
+    }
+}

src/mappers/EnvironmentToJsonMapper.mts

@@ -7,6 +7,7 @@ export interface EnvironmentJson extends EntityJson {
     glossaryIds: Uuid[];
     constraintIds: Uuid[];
     invariantIds: Uuid[];
+    assumptionIds: Uuid[];
 }
 
 export default class EnvironmentToJsonMapper extends EntityToJsonMapper {
@@ -17,7 +18,8 @@ export default class EnvironmentToJsonMapper extends EntityToJsonMapper {
             return new Environment({
                 ...target,
                 constraintIds: target.constraintIds ?? [],
-                invariantIds: target.invariantIds ?? []
+                invariantIds: target.invariantIds ?? [],
+                assumptionIds: target.assumptionIds ?? []
             });
 
         throw new Error(`Unsupported serialization version: ${version}`);
@@ -28,7 +30,8 @@ export default class EnvironmentToJsonMapper extends EntityToJsonMapper {
             ...super.mapTo(source),
             glossaryIds: source.glossaryIds,
             constraintIds: source.constraintIds,
-            invariantIds: source.invariantIds
+            invariantIds: source.invariantIds,
+            assumptionIds: source.assumptionIds
         };
     }
 }

src/presentation/Application.mts

@@ -69,6 +69,7 @@ export default class Application extends Container {
             (await import('./pages/solution/environment/GlossaryPage.mjs')).default,
             (await import('./pages/solution/environment/ConstraintsPage.mjs')).default,
             (await import('./pages/solution/environment/InvariantsPage.mjs')).default,
+            (await import('./pages/solution/environment/AssumptionsPage.mjs')).default,
             (await import('./pages/solution/goals/GoalsIndexPage.mjs')).default,
             (await import('./pages/solution/goals/RationalePage.mjs')).default,
             (await import('./pages/solution/goals/FunctionalityPage.mjs')).default,

src/presentation/pages/solution/NewSolutionPage.mts

@@ -111,6 +111,7 @@ export default class NewSolutionPage extends Page {
                 glossaryIds: [],
                 constraintIds: [],
                 invariantIds: [],
+                assumptionIds: []
             }),
             goals = new Goals({
                 id: solution.goalsId,

src/presentation/pages/solution/environment/AssumptionsPage.mts

@@ -0,0 +1,79 @@
+import type { Uuid } from '~/types/Uuid.mjs';
+import type Environment from '~/domain/Environment.mjs';
+import Assumption from '~/domain/Assumption.mjs';
+import SolutionRepository from '~/data/SolutionRepository.mjs';
+import EnvironmentRepository from '~/data/EnvironmentRepository.mjs';
+import AssumptionRepository from '~/data/AssumptionRepository.mjs';
+import Page from '~/presentation/pages/Page.mjs';
+import { DataTable } from '~/presentation/components/DataTable.mjs';
+import html from '~/presentation/lib/html.mjs';
+
+const { p } = html;
+
+export default class AssumptionPage extends Page {
+    static override route = '/:solution/environment/assumptions';
+    static {
+        customElements.define('x-page-assumtptions', this);
+    }
+
+    #solutionRepository = new SolutionRepository(localStorage);
+    #environmentRepository = new EnvironmentRepository(localStorage);
+    #assumptionRepository = new AssumptionRepository(localStorage);
+    #environment?: Environment;
+
+    constructor() {
+        super({ title: 'Assumptions' }, []);
+
+        const dataTable = new DataTable<Assumption>({
+            columns: {
+                id: { headerText: 'ID', readonly: true, formType: 'hidden', unique: true },
+                statement: { headerText: 'Statement', required: true, formType: 'text', unique: true }
+            },
+            select: async () => {
+                if (!this.#environment)
+                    return [];
+
+                return await this.#assumptionRepository.getAll(t => this.#environment!.assumptionIds.includes(t.id));
+            },
+            onCreate: async item => {
+                const assumption = new Assumption({ ...item, id: self.crypto.randomUUID() });
+                this.#environment!.assumptionIds.push(assumption.id);
+                await Promise.all([
+                    this.#assumptionRepository.add(assumption),
+                    this.#environmentRepository.update(this.#environment!)
+                ]);
+            },
+            onUpdate: async item => {
+                await this.#assumptionRepository.update(new Assumption({
+                    ...item
+                }));
+            },
+            onDelete: async id => {
+                this.#environment!.assumptionIds = this.#environment!.assumptionIds.filter(x => x !== id);
+                await Promise.all([
+                    this.#assumptionRepository.delete(id),
+                    this.#environmentRepository.update(this.#environment!)
+                ]);
+            }
+        });
+
+        this.append(
+            p(`
+                An assumption is a property of the environment that is assumed to be true.
+                Assumptions are used to simplify the problem and to make it more tractable.
+                An example of an assumption would be: "Screen resolution will not change during the execution of the program".
+            `),
+            dataTable
+        );
+
+        this.#environmentRepository.addEventListener('update', () => dataTable.renderData());
+        this.#assumptionRepository.addEventListener('update', () => dataTable.renderData());
+        const solutionId = this.urlParams['solution'] as Uuid;
+        this.#solutionRepository.getBySlug(solutionId).then(solution => {
+            this.#environmentRepository.get(solution!.environmentId).then(environment => {
+                this.#environment = environment;
+                dataTable.renderData();
+            });
+        });
+    }
+}

src/presentation/pages/solution/environment/EnvironmentsIndexPage.mts

@@ -35,7 +35,15 @@ export default class EnvironmentsIndexPage extends Page {
                     title: 'Invariants',
                     icon: 'lock',
                     href: `${location.pathname}/invariants`
-                })
+                }),
+                new MiniCard({
+                    title: 'Assumptions',
+                    // There is no icon for assumptions, so might as well use this one.
+                    // "As sure as the sun rises in the east"
+                    // https://en.wikipedia.org/wiki/Sunrise_problem
+                    icon: 'sunrise',
+                    href: `${location.pathname}/assumptions`
+                }),
             ])
         );
     }