@elaraai/e3-ui 1.0.97 → 1.0.99

package/dist/test/schematic/schematic-records.examples.d.ts

@@ -0,0 +1,454 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** @jsxImportSource @elaraai/e3-ui */
+import { DictType, FloatType, IntegerType, NullType, StringType, StructType, VariantType, variant } from "@elaraai/east";
+/** A rack of the floor: its hall and model, placed by its centre, its box 0.6 m by 1.2 m. */
+export declare const StressRack: StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly model: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>;
+/** How hot a rack runs. */
+export declare const StressAlarm: VariantType<{
+    readonly ok: NullType;
+    readonly warm: NullType;
+    readonly hot: NullType;
+}>;
+/** A rack's load: what its card's bar, figure and dot draw. */
+export declare const StressLoad: StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>;
+/** A hall of the floor: its box and its name. */
+export declare const StressHall: StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>;
+/**
+ * The floor's racks, a row of 100 in each of the ten halls in turn — five
+ * halls to a row of the floor, each holding 50 rows, 0.7 m apart along a row
+ * and 2.4 m from row to row — so any count fills every hall's rows from the
+ * front: 20,000 racks fill each hall's first 20, and 50,000 the floor. The
+ * budget run makes the floor's 50,000 with it, and patches in what the seed's
+ * 20,000 lack.
+ */
+export declare const generateRacks: import("@elaraai/east").CallableFunctionExpr<[IntegerType], DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly model: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>;
+/** The racks' loads, keyed as the racks are: up to 12 kW of a 12 kW rack, warm past 9.6 and hot past 10.8. The budget run makes the floor's with it. */
+export declare const generateLoads: import("@elaraai/east").CallableFunctionExpr<[IntegerType], DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>>>;
+export declare const schematicStressRackCount: import("@elaraai/e3").DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "schematic_stress_rack_count">]>;
+export declare const schematicStressRacksGenerated: import("@elaraai/e3").TaskDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly model: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>, [variant<"field", "tasks">, variant<"field", "schematic_stress_racks_generated">, variant<"field", "output">]>;
+export declare const schematicStressRacks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly model: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_racks">], import("@elaraai/e3").IndexesOf<{
+    schematic_stress_racks_by_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly name: StringType;
+        readonly hall: StringType;
+        readonly model: StringType;
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+    }>, readonly [], {
+        readonly area: import("@elaraai/e3").AreaIndexOf<{
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
+        }>;
+    }>;
+    schematic_stress_racks_by_hall_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<{
+            hall: StringType;
+        }>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly name: StringType;
+        readonly hall: StringType;
+        readonly model: StringType;
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+    }>, readonly ["hall"], {
+        readonly area: import("@elaraai/e3").AreaIndexOf<{
+            readonly on: readonly ["hall"];
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
+        }>;
+    }>;
+    schematic_stress_racks_by_model: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["model"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly model: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly hall: StringType;
+                readonly model: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly hall: StringType;
+                        readonly model: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly hall: StringType;
+                        readonly model: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly hall: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly model: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly x: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly y: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly w: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly h: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly model: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>>;
+export declare const schematicStressRackLoads: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_rack_loads">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
+                }>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
+                }>;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
+                }>;
+            }>;
+            insert: StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
+                }>;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                        readonly alarm: VariantType<{
+                            readonly ok: NullType;
+                            readonly warm: NullType;
+                            readonly hot: NullType;
+                        }>;
+                    }>;
+                    after: StructType<{
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                        readonly alarm: VariantType<{
+                            readonly ok: NullType;
+                            readonly warm: NullType;
+                            readonly hot: NullType;
+                        }>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly kw: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly capacity: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly alarm: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly ok: NullType;
+                                readonly warm: NullType;
+                                readonly hot: NullType;
+                            }>;
+                            after: VariantType<{
+                                readonly ok: NullType;
+                                readonly warm: NullType;
+                                readonly hot: NullType;
+                            }>;
+                        }>;
+                        patch: VariantType<{
+                            readonly ok: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly warm: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly hot: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>>>>;
+/** A rack joined to another across the floor. */
+export declare const StressUplink: StructType<{
+    readonly from: StringType;
+    readonly to: StringType;
+}>;
+/**
+ * Uplinks from the front of Hall 1 to the front of Hall 5, 300 m across the floor: links whose far end a window over
+ * either hall doesn't hold, which it reads by key (#1393, SC22).
+ */
+export declare const schematicStressUplinks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly from: StringType;
+    readonly to: StringType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_uplinks">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly from: StringType;
+    readonly to: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly from: StringType;
+    readonly to: StringType;
+}>>>>;
+export declare const schematicStressHalls: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_stress_halls">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>>;
+export declare const schematicRecordIndexes: import("@elaraai/east").ExampleDef<[], any>;
+export declare const schematicRecordIndexesMobile: import("@elaraai/east").ExampleDef<[], any>;
+//# sourceMappingURL=schematic-records.examples.d.ts.map

package/dist/test/schematic/schematic-records.examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schematic-records.examples.d.ts","sourceRoot":"","sources":["../../../test/schematic/schematic-records.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAAsC;AACtC,OAAO,EAAa,QAAQ,EAAQ,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAiB,OAAO,EAAE,MAAM,eAAe,CAAC;AAmBzJ,6FAA6F;AAC7F,eAAO,MAAM,UAAU;;;;;;;;EAAgI,CAAC;AACxJ,2BAA2B;AAC3B,eAAO,MAAM,WAAW;;;;EAA+D,CAAC;AACxF,+DAA+D;AAC/D,eAAO,MAAM,UAAU;;;;;;;;EAAyE,CAAC;AACjG,iDAAiD;AACjD,eAAO,MAAM,UAAU;;;;;;EAA2F,CAAC;AAKnH;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;;;;;IAoBxB,CAAC;AAEH,wJAAwJ;AACxJ,eAAO,MAAM,aAAa;;;;;;;;IAYxB,CAAC;AAEH,eAAO,MAAM,wBAAwB,8HAAiF,CAAC;AACvH,eAAO,MAAM,6BAA6B;;;;;;;;mHAAyF,CAAC;AACpI,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkB/B,CAAC;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMnC,CAAC;AACH,iDAAiD;AACjD,eAAO,MAAM,YAAY;;;EAAmD,CAAC;AAC7E;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;KAOjC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;KAa/B,CAAC;AAEH,eAAO,MAAM,sBAAsB,6CAuDjC,CAAC;AAEH,eAAO,MAAM,4BAA4B,6CAwDvC,CAAC"}