@selimssevgi/cube-design-angular 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selimssevgi/cube-design-angular",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "cube design in angular: the pieces anlat, mosaic and cubes share, starting with the isometric cube picture.",
   "keywords": [
     "angular",

package/types/selimssevgi-cube-design-angular.d.ts

@@ -2330,4 +2330,204 @@ export declare class ReportClient {
   static ɵfac: i0.ɵɵFactoryDeclaration<ReportClient, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-export type { ArtDrawing, ArtOptions, ArtShape, CubeArt, DrawnArt };
+type Id = string;
+/**
+ * what a piece is, fixed by the place it was added and never read again (invariant 3):
+ * - `lobby`: a tile of the app's lobby (what the app gives, or a group i made there)
+ * - `domain`: the door from the lobby into my domain, where my tables stand side by side
+ * - `table`: a table of mine in the domain (moments, people)
+ * - `item`: a thing i added to a table's names (a moment, a person)
+ * - `way`: a way of looking at every item of a table (added at the table, or close up)
+ * - `answer`: an answer of a way (added inside it)
+ * where a piece stands later (a way carried into a way i made stands there as its answer) never
+ * changes what it was made as; the screen reads where it stands.
+ */
+type Place = 'lobby' | 'domain' | 'table' | 'item' | 'way' | 'answer';
+interface Piece {
+  id: Id;
+  /** every name it has had, the one in use first; [] is not named yet. */
+  names: string[];
+  hidden: boolean;
+  /** made by the app, never by the person. */
+  given: boolean;
+  place: Place;
+  made: number;
+  /** a table only: every word its names tile has had, the one in use first; none is the default, "names" (round four). */
+  list?: string[];
+}
+/** a piece standing in a holder: one row per place. taking out ends it; nothing is deleted. */
+interface In {
+  piece: Id;
+  holder: Id;
+  order: number;
+  since: number;
+  ended?: number;
+  /** the place it was added (or given); a carry moves it with the piece. */
+  home: boolean;
+}
+interface World {
+  top: Id;
+  pieces: Record<Id, Piece>;
+  ins: In[];
+  clock: number;
+}
+interface Note {
+  says: string;
+  undo?: World;
+  refused?: boolean;
+}
+interface Result {
+  world: World;
+  note?: Note;
+}
+type TileKind = 'lobby' | 'group' | 'door' | 'table' | 'list' | 'row' | 'column' | 'option' | 'unknown' | 'choice' | 'hidden' | 'name' | 'add';
+interface Tile {
+  id: Id;
+  kind: TileKind;
+  name: string;
+  line: string;
+  ticked?: boolean;
+  given?: boolean;
+  holds?: number;
+}
+interface Level {
+  path: Id[];
+  title: string;
+  line: string;
+  /** kept for the runner: nothing is ever lifted in round three. */
+  lifted: boolean;
+  tiles: Tile[];
+}
+export interface CubePhysicsWords {
+  /** a piece with no name yet ("not named yet"): the app never names. */
+  notNamed: string;
+  /** a table's names tile until i give it a word of mine ("names"). */
+  names: string;
+  /** the pale tile of what was hidden on a level, and its level ("hidden"). */
+  hidden: string;
+  /** inside a way: the items in none of its answers; close up, a way not answered ("not known yet"). */
+  notKnownYet: string;
+  /** the add tile ("add"). */
+  add: string;
+  /** close up, under the item's own name tile ("its name"). */
+  itsName: string;
+  /** close up, a yes or no way the item stands in ("yes"). */
+  yes: string;
+  /** a level whose piece is gone ("not here any more"). */
+  notHereAnyMore: string;
+  /** under a feature's name in the lobby ("what the app keeps here"). */
+  appKeepsHere: string;
+  /** between the first names a tile lists (", "), and after the last when there are more (" …"). */
+  and: string;
+  more: string;
+  /** the refusals: why a move does nothing. */
+  notHere: string;
+  notInsideItself: string;
+  notWithItself: string;
+  standsOnItsOwn: string;
+  eachOnItsOwn: string;
+  domainHoldsTables: string;
+  domainHoldsThings: string;
+  lobbyIsTheApp: string;
+  tablesSideBySide: string;
+  inOneOfItsAnswers: string;
+  notInThisTable: string;
+  staysWhereMade: string;
+  needsOnePlace: string;
+  staysWhereGiven: string;
+  neverOutOfHome: string;
+  /** the quiet line after a move (with undo): names in use filled in. */
+  stoodIn: (piece: string, onto: string) => string;
+  madeOne: (name: string, a: string, b: string, way: string) => string;
+  movedInto: (piece: string, to: string) => string;
+  hiddenKept: (piece: string) => string;
+  shownAgain: (piece: string) => string;
+}
+/** a step: the names of the table before it (the items). an id, never shown. */
+declare const NAMES = "names";
+/** a step: the pale tile of what was hidden on the level before it (F1). */
+declare const HIDDEN = "hidden";
+/** a step: inside a way, the items in none of its answers. */
+declare const UNKNOWN = "unknown";
+/** a step: close up, one way with answers asked of the item (choice:<way>). */
+declare const CHOICE = "choice:";
+/** the names tile of a table is held as `names:<table>`; its word is mine, the app's default until i say. */
+declare const LIST = "names:";
+declare const isToken: (s: string) => boolean;
+type Role = 'lobby' | 'domain' | 'table' | 'names' | 'item' | 'way' | 'answer' | 'hidden' | 'unknown' | 'choice';
+/**
+ * the physics, speaking the app's words. every reading and move is pure: it takes a world and gives
+ * back a level, or a new world with what to say (a note, with the world before it for undo).
+ */
+export declare function cubePhysics(words: CubePhysicsWords): {
+  listWords: (w: World, t: Id) => string[];
+  nameOf: (w: World, id: Id) => string;
+  placeOf: (w: World, id: Id) => Place | null;
+  partsIn: (w: World, holder: Id, hidden?: boolean) => Id[];
+  holdersOf: (w: World, id: Id) => string[];
+  stands: (w: World, piece: Id, holder: Id) => boolean;
+  homeOf: (w: World, id: Id) => Id | null;
+  lobbyZone: (w: World, id: Id) => boolean;
+  itemsOf: (w: World, t: Id) => string[];
+  tableOf: (w: World, id: Id) => Id | null;
+  domainOf: (w: World, id: Id) => Id | null;
+  tablesIn: (w: World, d: Id, hidden?: boolean) => string[];
+  waysOf: (w: World, t: Id, hidden?: boolean) => string[];
+  answersOf: (w: World, way: Id, t?: Id | null, hidden?: boolean) => Id[];
+  shared: (w: World, way: Id) => boolean;
+  siblings: (w: World, a: Id, b: Id) => boolean;
+  outOf: (path: Id[]) => Id[];
+  roleAt: (w: World, path: Id[]) => Role;
+  contextTable: (w: World, path: Id[]) => Id | null;
+  walksThrough: (_w: World, _path: Id[]) => boolean;
+  choicesOf: (w: World, item: Id, t: Id) => Tile[];
+  linkedTables: (w: World, _item: Id, t: Id) => Id[];
+  hiddenOf: (w: World, path: Id[]) => Id[];
+  stepOf: (t: Tile) => string | null;
+  stepsInto: (w: World, path: Id[], t: Tile) => string[] | null;
+  levelAt: (w: World, path: Id[]) => Level;
+  livesIn: (w: World, id: Id) => string;
+  lobbyLinkable: (w: World, holder: Id) => Id[];
+  pathTo: (w: World, id: Id) => Id[] | null;
+  pathInto: (w: World, path: Id[], t: Tile) => Id[] | null;
+  addAt: (w: World, at: string, name: string, given?: boolean) => Result;
+  dropIn: (w: World, piece: Id, onto: Id, path: Id[]) => Result;
+  makeOne: (w: World, a: Id, b: Id, path: Id[], name?: string) => Result;
+  placeRefusal: (w: World, piece: Id, holder: Id) => string | null;
+  placeAlso: (w: World, piece: Id, holder: Id) => Result;
+  givenAt: (w: World, id: Id) => Id | null;
+  takeOutRefusal: (w: World, piece: Id, holder: Id) => string | null;
+  takeOut: (w: World, piece: Id, holder: Id) => Result;
+  pick: (w: World, item: Id, _way: Id, answer: Id) => Result;
+  linkable: (w: World, item: Id, t: Id) => Id[];
+  linked: (w: World, a: Id, b: Id) => boolean;
+  link: (w: World, a: Id, b: Id) => Result;
+  rename: (w: World, piece: Id, name: string) => Result;
+  hide: (w: World, piece: Id) => Result;
+  show: (w: World, piece: Id) => Result;
+  undo: (note: Note) => Result;
+  settle: (_w: World, _left: Id, _before: World) => Result | null;
+  build: {
+    make: (w: World, at: Id, name: string | null, p: Place, given?: boolean) => Id;
+    stand: (w: World, piece: Id, holder: Id, home?: boolean) => void;
+  };
+  model: {
+    levelAt: (w: World, path: Id[]) => Level;
+    outOf: (path: Id[]) => Id[];
+    add: (w: World, at: string, name: string, given?: boolean) => Result;
+    dropIn: (w: World, piece: Id, onto: Id, path: Id[]) => Result;
+    makeOne: (w: World, a: Id, b: Id, path: Id[], name?: string) => Result;
+    placeAlso: (w: World, piece: Id, holder: Id) => Result;
+    takeOut: (w: World, piece: Id, holder: Id) => Result;
+    pick: (w: World, item: Id, _way: Id, answer: Id) => Result;
+    link: (w: World, a: Id, b: Id) => Result;
+    rename: (w: World, piece: Id, name: string) => Result;
+    hide: (w: World, piece: Id) => Result;
+    show: (w: World, piece: Id) => Result;
+    undo: (note: Note) => Result;
+    settle: (_w: World, _left: Id, _before: World) => Result | null;
+  };
+};
+/** the physics an app made with its words (`cubePhysics(words)`). */
+type CubePhysics = ReturnType<typeof cubePhysics>;
+export { type ArtDrawing, type ArtOptions, type ArtShape, type CubeArt, type CubePhysics, type DrawnArt, CHOICE as PHYSICS_CHOICE, HIDDEN as PHYSICS_HIDDEN, LIST as PHYSICS_LIST, NAMES as PHYSICS_NAMES, UNKNOWN as PHYSICS_UNKNOWN, type Id as PhysicsId, type In as PhysicsIn, type Level as PhysicsLevel, type Note as PhysicsNote, type Piece as PhysicsPiece, type Place as PhysicsPlace, type Result as PhysicsResult, type Role as PhysicsRole, type Tile as PhysicsTile, type TileKind as PhysicsTileKind, type World as PhysicsWorld, isToken as isPhysicsToken };