@mathscan/geometry-engine 0.1.0

package/dist/schemas/exerciseV3.schema.d.ts

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+export declare const v3ExerciseSchemaVersion = 3;
+/**
+ * The exercise document ADR 0013 froze at version 3, so the v3 → v4 step can
+ * check what it was handed before promoting it (ADR 0015) — and so the v2 → v3
+ * step still has a version 3 to ask once the current schema has moved past it.
+ *
+ * Version 3 is version 2 plus `grading` and nothing else, so it is built on the
+ * frozen v2 transcription rather than transcribed a second time. `grading` is
+ * written out here with nothing imported from the current vocabulary, for the
+ * reason `exerciseV2.schema.ts` gives: a shared schema admits every later
+ * addition to it. Like that schema this one carries no cross-reference
+ * refinements and no issue messages; it only answers "could version 3 have
+ * said this?".
+ */
+export declare const geometryExerciseV3Schema: z.ZodObject<{
+    id: z.ZodString;
+    viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    showGrid: z.ZodOptional<z.ZodBoolean>;
+    entities: z.ZodType<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown>>;
+    draggableEntityIds: z.ZodArray<z.ZodString>;
+    allowedObjects: z.ZodArray<z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>>;
+    tools: z.ZodArray<z.ZodEnum<{
+        ruler: "ruler";
+        setSquare: "setSquare";
+        protractor: "protractor";
+    }>>;
+    goals: z.ZodArray<z.ZodUnion<z.ZodObject<{
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        pointIds: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"segment">;
+        targetLength: z.ZodNumber;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"point">;
+        referenceObjectId: z.ZodString;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    }, z.core.$strict>[]>>;
+    schemaVersion: z.ZodLiteral<3>;
+    grading: z.ZodOptional<z.ZodObject<{
+        extraObjects: z.ZodEnum<{
+            allow: "allow";
+            reject: "reject";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+//# sourceMappingURL=exerciseV3.schema.d.ts.map

package/dist/schemas/exerciseV3.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exerciseV3.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/exerciseV3.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMnC,CAAA"}

package/dist/schemas/geometryObject.schema.d.cts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const geometryObjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segment">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"line">;
+    through: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"circle">;
+    center: z.ZodString;
+    through: z.ZodString;
+}, z.core.$strict>], "type">;
+export type GeometryObject = z.infer<typeof geometryObjectSchema>;

package/dist/schemas/geometryObject.schema.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const geometryObjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segment">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"line">;
+    through: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"circle">;
+    center: z.ZodString;
+    through: z.ZodString;
+}, z.core.$strict>], "type">;
+export type GeometryObject = z.infer<typeof geometryObjectSchema>;
+//# sourceMappingURL=geometryObject.schema.d.ts.map

package/dist/schemas/geometryObject.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometryObject.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/geometryObject.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;4BAI/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/schemas/geometryState.schema.d.cts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { MigrationOutcome, MigrationStep } from './migrate.cjs';
+export declare const latestGeometryStateVersion = 2;
+export declare const geometryStateMigrations: readonly MigrationStep[];
+export declare const geometryStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    entities: z.ZodType<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown>>;
+    answerEntityIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type GeometryState = z.infer<typeof geometryStateSchema>;
+export declare function migrateGeometryState(input: unknown): MigrationOutcome;

package/dist/schemas/geometryState.schema.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { MigrationOutcome, MigrationStep } from './migrate.js';
+export declare const latestGeometryStateVersion = 2;
+export declare const geometryStateMigrations: readonly MigrationStep[];
+export declare const geometryStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    entities: z.ZodType<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown>>;
+    answerEntityIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type GeometryState = z.infer<typeof geometryStateSchema>;
+export declare function migrateGeometryState(input: unknown): MigrationOutcome;
+//# sourceMappingURL=geometryState.schema.d.ts.map

package/dist/schemas/geometryState.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometryState.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/geometryState.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAmB,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAA;AAatF,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAG3C,eAAO,MAAM,uBAAuB,EAAE,SAAS,aAAa,EAA0B,CAAA;AAUtF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuB5B,CAAA;AAEJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAK/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAErE"}

package/dist/schemas/givenElement.schema.d.cts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const givenElementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"point">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    draggable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segment">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"line">;
+    through: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"circle">;
+    center: z.ZodString;
+    through: z.ZodString;
+}, z.core.$strict>], "type">;
+export type GivenElement = z.infer<typeof givenElementSchema>;

package/dist/schemas/givenElement.schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const givenElementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"point">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    draggable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segment">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"line">;
+    through: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"circle">;
+    center: z.ZodString;
+    through: z.ZodString;
+}, z.core.$strict>], "type">;
+export type GivenElement = z.infer<typeof givenElementSchema>;
+//# sourceMappingURL=givenElement.schema.d.ts.map

package/dist/schemas/givenElement.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"givenElement.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/givenElement.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;4BAK7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schemas/goals/createGoal.schema.d.cts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const createGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"create">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+}, z.core.$strict>;
+export type CreateGoal = z.infer<typeof createGoalSchema>;

package/dist/schemas/goals/createGoal.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const createGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"create">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+}, z.core.$strict>;
+export type CreateGoal = z.infer<typeof createGoalSchema>;
+//# sourceMappingURL=createGoal.schema.d.ts.map

package/dist/schemas/goals/createGoal.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/createGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;;;;;;;kBAMlB,CAAA;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/schemas/goals/geometryGoal.schema.d.cts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"create">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"throughPoints">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+    pointIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"perpendicular">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+    referenceObjectId: z.ZodString;
+    throughPointId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"parallel">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+    referenceObjectId: z.ZodString;
+    throughPointId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segmentLength">;
+    objectType: z.ZodLiteral<"segment">;
+    targetLength: z.ZodNumber;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"midpoint">;
+    objectType: z.ZodLiteral<"point">;
+    referenceObjectId: z.ZodString;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>], "type">;
+export type GeometryGoal = z.infer<typeof geometryGoalSchema>;

package/dist/schemas/goals/geometryGoal.schema.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"create">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"throughPoints">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+    pointIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"perpendicular">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+    referenceObjectId: z.ZodString;
+    throughPointId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"parallel">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>;
+    referenceObjectId: z.ZodString;
+    throughPointId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segmentLength">;
+    objectType: z.ZodLiteral<"segment">;
+    targetLength: z.ZodNumber;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"midpoint">;
+    objectType: z.ZodLiteral<"point">;
+    referenceObjectId: z.ZodString;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>], "type">;
+export type GeometryGoal = z.infer<typeof geometryGoalSchema>;
+//# sourceMappingURL=geometryGoal.schema.d.ts.map

package/dist/schemas/goals/geometryGoal.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometryGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/geometryGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAO7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schemas/goals/goalKindDeclaration.d.cts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { EntityDefinition } from '../../geometry/entityModel.cjs';
+import { ObjectTypeName } from '../objectTypeName.schema.cjs';
+import { GeometryGoal } from './geometryGoal.schema.cjs';
+/**
+ * The kinds a goal means when it says "segment or line": the objects that have
+ * a direction.
+ *
+ * `throughPoints`, `perpendicular` and `parallel` all reduce their subject to
+ * an endpoint pair and measure that pair. A circle is an object with two
+ * parents too — its centre and its through-point — so without this test it is
+ * measured as the segment between them (M2.G.3).
+ */
+export declare function isDirectedObjectType(name: ObjectTypeName): boolean;
+/** An authoring error, at a path relative to the goal that produced it. */
+export interface GoalAuthoringIssue {
+    path: Array<string | number>;
+    message: string;
+}
+/**
+ * What a cross-reference rule may ask about the exercise around its goal.
+ *
+ * One member, in the M2 vocabulary: a rule asking "is this a point?" and a rule
+ * asking "is this a segment?" are the same question, and answering both from
+ * `kind` is what lets one set of rules serve a v1 exercise (through
+ * `definitionOfGiven()`) and a v2 one (whose `entities` record already holds
+ * definitions) without a second copy.
+ */
+export interface GoalAuthoringContext {
+    definitionOf(id: string): EntityDefinition | undefined;
+}
+export interface GoalKindDeclaration<TGoal extends GeometryGoal = GeometryGoal> {
+    kind: TGoal['type'];
+    schema: z.ZodType<TGoal>;
+    /**
+     * Every given the goal names, points and objects alike. Removing any of them
+     * orphans the goal, which is the teacher editor's question and not a list of
+     * type tests it has to keep in step with the goal union.
+     */
+    referencedGivenIds(goal: TGoal): readonly string[];
+    /**
+     * What this kind requires of the exercise around it. Shape is the schema's
+     * job; this is only what needs the other givens to answer.
+     */
+    crossReferenceIssues(goal: TGoal, exercise: GoalAuthoringContext): GoalAuthoringIssue[];
+}
+export type GoalKindDeclarationRegistry = {
+    [K in GeometryGoal['type']]: GoalKindDeclaration<Extract<GeometryGoal, {
+        type: K;
+    }>>;
+};
+export declare const goalKindDeclarations: GoalKindDeclarationRegistry;
+export declare function declarationFor(goal: GeometryGoal): GoalKindDeclaration;

package/dist/schemas/goals/goalKindDeclaration.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { EntityDefinition } from '../../geometry/entityModel.js';
+import { ObjectTypeName } from '../objectTypeName.schema.js';
+import { GeometryGoal } from './geometryGoal.schema.js';
+/**
+ * The kinds a goal means when it says "segment or line": the objects that have
+ * a direction.
+ *
+ * `throughPoints`, `perpendicular` and `parallel` all reduce their subject to
+ * an endpoint pair and measure that pair. A circle is an object with two
+ * parents too — its centre and its through-point — so without this test it is
+ * measured as the segment between them (M2.G.3).
+ */
+export declare function isDirectedObjectType(name: ObjectTypeName): boolean;
+/** An authoring error, at a path relative to the goal that produced it. */
+export interface GoalAuthoringIssue {
+    path: Array<string | number>;
+    message: string;
+}
+/**
+ * What a cross-reference rule may ask about the exercise around its goal.
+ *
+ * One member, in the M2 vocabulary: a rule asking "is this a point?" and a rule
+ * asking "is this a segment?" are the same question, and answering both from
+ * `kind` is what lets one set of rules serve a v1 exercise (through
+ * `definitionOfGiven()`) and a v2 one (whose `entities` record already holds
+ * definitions) without a second copy.
+ */
+export interface GoalAuthoringContext {
+    definitionOf(id: string): EntityDefinition | undefined;
+}
+export interface GoalKindDeclaration<TGoal extends GeometryGoal = GeometryGoal> {
+    kind: TGoal['type'];
+    schema: z.ZodType<TGoal>;
+    /**
+     * Every given the goal names, points and objects alike. Removing any of them
+     * orphans the goal, which is the teacher editor's question and not a list of
+     * type tests it has to keep in step with the goal union.
+     */
+    referencedGivenIds(goal: TGoal): readonly string[];
+    /**
+     * What this kind requires of the exercise around it. Shape is the schema's
+     * job; this is only what needs the other givens to answer.
+     */
+    crossReferenceIssues(goal: TGoal, exercise: GoalAuthoringContext): GoalAuthoringIssue[];
+}
+export type GoalKindDeclarationRegistry = {
+    [K in GeometryGoal['type']]: GoalKindDeclaration<Extract<GeometryGoal, {
+        type: K;
+    }>>;
+};
+export declare const goalKindDeclarations: GoalKindDeclarationRegistry;
+export declare function declarationFor(goal: GeometryGoal): GoalKindDeclaration;
+//# sourceMappingURL=goalKindDeclaration.d.ts.map

package/dist/schemas/goals/goalKindDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goalKindDeclaration.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/goalKindDeclaration.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAO9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAElE;AAED,2EAA2E;AAC3E,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IAC5B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAA;CACvD;AAED,MAAM,WAAW,mBAAmB,CAAC,KAAK,SAAS,YAAY,GAAG,YAAY;IAC5E,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACnB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACxB;;;;OAIG;IACH,kBAAkB,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,MAAM,EAAE,CAAA;IAClD;;;OAGG;IACH,oBAAoB,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,oBAAoB,GAAG,kBAAkB,EAAE,CAAA;CACxF;AAED,MAAM,MAAM,2BAA2B,GAAG;KACvC,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,GAAG,mBAAmB,CAAC,OAAO,CAAC,YAAY,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC;CACrF,CAAA;AA0CD,eAAO,MAAM,oBAAoB,EAAE,2BA8EK,CAAA;AAQxC,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,mBAAmB,CAEtE"}

package/dist/schemas/goals/midpointGoal.schema.d.cts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const midpointGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"midpoint">;
+    objectType: z.ZodLiteral<"point">;
+    referenceObjectId: z.ZodString;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>;
+export type MidpointGoal = z.infer<typeof midpointGoalSchema>;