@selimssevgi/cube-design-angular 0.4.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selimssevgi/cube-design-angular",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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

@@ -468,6 +468,38 @@ export declare const TEXT_ORDERS: readonly TextOrder[];
  * the items' own order.
  */
 export declare function sortItems<T>(items: readonly T[], by: (item: T) => SortValue, dir: Direction, text?: TextOrder): T[];
+/** the sort key of my own order, beside an app's other `SortOption`s (kept by the app, per place). */
+export declare const MINE_SORT = "mine";
+/** why a move in my own order is refused: the fixed first piece stays first. */
+export type OrderRefusal = 'fixed-first';
+/**
+ * the order after `piece` is put just before `before` (null: last); the others keep their turn.
+ * refused when `piece` or `before` is the fixed first one; the same order when `piece` is not in
+ * it or `before` is itself.
+ */
+export declare function moveBefore<T>(order: readonly T[], piece: T, before: T | null, opts?: {
+  fixedFirst?: T | null;
+}): {
+  order: T[];
+  refused: OrderRefusal | null;
+};
+/** one piece of a place, as the order level shows it to the held one. */
+export interface CubeOrderPlace {
+  key: string;
+  /** its turn in the place now, from 0. */
+  at: number;
+  /** the held piece: ticked, "here now". */
+  held: boolean;
+  /** the fixed first piece: pale, it stays first. */
+  fixed: boolean;
+  /** a tap puts the held piece just before it; null for the held one itself. */
+  tap: 'before' | null;
+  refused: OrderRefusal | null;
+}
+/** the order level's pieces: the place's, in their order, as the held piece sees them. */
+export declare function orderOf(order: readonly string[], held: string, opts?: {
+  fixedFirst?: string | null;
+}): CubeOrderPlace[];
 /** what an app gives for where: its places and how they hold each other, from its own world. */
 export interface WhereSource {
   /** the place everything stands in at last: the top (mine, mosaic, my to-dos). */
@@ -569,14 +601,69 @@ export interface WhereWords {
 export declare function whereLevel(places: readonly CubePlace[], words?: WhereWords, opts?: {
   pathOf?: (place: CubePlace) => string[];
 }): ContextTile<CubePlace>[];
+/** one piece, as a bring level shows it. the words for it are the app's. */
+export interface CubeBring {
+  /** the piece's key, as the app's source knows it. */
+  key: string;
+  /** its name, from the source's `nameOf`. */
+  title: string;
+  /** it stands in the place things are brought into already (ticked). */
+  in: boolean;
+  /** the app put it in that place: it never leaves it. */
+  given: boolean;
+  /** it is the place things are brought into, listed pale where it stands. */
+  into: boolean;
+  /** the place stands inside it: bringing it would put it inside itself (pale). */
+  holdsInto: boolean;
+  /** what a tap asks for: bring it in too, or take it out of the place; null for the place itself. */
+  tap: 'stand' | 'take-out' | null;
+  /** why that tap would be refused, or null when it would be done. */
+  refused: WhereRefusal | null;
+  /** every other place it stands in, in order: for the app's line ("here too · and in kitchen"). */
+  places: string[];
+  /** inside it are pieces worth looking into (›): something there can be brought in, or is in. */
+  deeper: boolean;
+}
+/** how `bringOf` lists. */
+export interface BringOptions {
+  /** the place to look inside; the source's top by default. */
+  at?: string;
+  /** the pieces to list in place of what stands in `at` (lately, worked out by the app); no ›. */
+  pieces?: readonly string[];
+}
+/**
+ * the pieces that could be brought into `into`, as one level of bring things in: what stands in
+ * `at` (the top by default), in its order, hidden ones left out. a piece already in is ticked; the
+ * place itself and a piece holding it come pale; a piece with something to bring inside it gets
+ * `deeper` (›). a tap on one that is in takes it out, refused where the app put it and when it is
+ * its only place; on one that is not, it stands there too, refused when it would go inside itself
+ * or by the app's own rules (`WhereSource.refuses`).
+ */
+export declare function bringOf(source: WhereSource, into: string, opts?: BringOptions): CubeBring[];
+/** the words of bring things in, the app's: a piece's title and line. */
+export interface BringWords {
+  /** its title; the piece's name by default. */
+  title?(piece: CubeBring): string;
+  /** the line under it: here too and where else, where the app put it, why it can't come. */
+  line?(piece: CubeBring): string | null;
+}
 /**
- * the parts a context cube can have. the seven are the ones cubes found, and where (one piece in
- * many places, 0.3.0); an app may add its own, any string, and they come after the known ones.
+ * bring things in as context tiles: every piece, ticked (`inUse`) where it is in already; pale
+ * where a tap can do nothing or would be refused. each tile's `data` is its `CubeBring`, and a
+ * piece with `deeper` gets `zoom` (`['bring', key]` by default), drawn as a ›.
  */
-export type ContextPartKey = 'names' | 'change' | 'view' | 'sort' | 'move' | 'where' | 'whose' | 'hide' | (string & {});
+export declare function bringLevel(pieces: readonly CubeBring[], words?: BringWords, opts?: {
+  pathOf?: (piece: CubeBring) => string[];
+}): ContextTile<CubeBring>[];
 /**
- * cubes' rows: how it is called (names, change), how it is shown (view, sort), what i do with it
- * (move, where, whose, hide).
+ * the parts a context cube can have. the seven are the ones cubes found, where (one piece in many
+ * places, 0.3.0), and bring and order (bringing things in and my own order, 0.5.0); an app may add
+ * its own, any string, and they come after the known ones.
+ */
+export type ContextPartKey = 'names' | 'change' | 'bring' | 'view' | 'sort' | 'order' | 'move' | 'where' | 'whose' | 'hide' | (string & {});
+/**
+ * cubes' rows: how it is called (names, change, and bring things into it), how it is shown (view,
+ * sort, my own order), what i do with it (move, where, whose, hide).
  */
 export declare const CONTEXT_PART_ORDER: readonly ContextPartKey[];
 /** the parts in their rows; parts an app added come last, in the order it gave them. twice is once. */
@@ -743,6 +830,38 @@ export declare function sortLevel(options: readonly SortOption[], now: SortNow,
  * found is not known yet and comes last (`sortItems`); the words say so in their lines.
  */
 export declare function sortDirectionsLevel(option: SortOption, now: SortNow, words: ContextWords): ContextTile<Direction>[];
+/** the words of my own order, the app's. */
+export interface OrderWords {
+  /** a piece's title: its name. */
+  title(place: CubeOrderPlace): string;
+  /** the line under it ("here now", "stays first", "{held} before it"). */
+  line?(place: CubeOrderPlace): string | null;
+  /** the last tile: put it after everything. */
+  last: ContextWord;
+}
+/**
+ * order: the place's pieces as they come, the held one ticked; a tap on another puts the held one
+ * just before it (`moveBefore`), the fixed first one is pale; **last** comes at the end unless the
+ * held piece is last already. each tile's `data` is its `CubeOrderPlace`, or null for last.
+ */
+export declare function orderLevel(places: readonly CubeOrderPlace[], words: OrderWords): ContextTile<CubeOrderPlace | null>[];
+/** one way an app adds something to a place: bring things in, a new group, from lately. */
+export interface AddWay {
+  /** the app's own key. */
+  key: string;
+  title: string;
+  line?: string | null;
+  /** the icon's name; `plus` for the plus, `move` for the others by default. */
+  icon?: string;
+  /** the plus: something new (a name only), drawn last, as every own box is. */
+  adds?: boolean;
+}
+/**
+ * add as a level of its own (way b of the study): the app's ways to add to a place, as context
+ * tiles, the plus last. what add holds is the app's and may differ from place to place (somewhere
+ * it is only the plus, and then the app opens the name at once instead of this level).
+ */
+export declare function addLevel(ways: readonly AddWay[]): ContextTile<AddWay>[];
 /** how close a square's places are: from one big tile (0) to only its icon or small cube (4). */
 export type SquareLevel = 0 | 1 | 2 | 3 | 4;
 /** cubes' steps (`levelFor`), by a cell's side in px: a tile says less as the square fills. */
@@ -777,16 +896,32 @@ export interface SquareLayout {
 export declare const SQUARE_MAX_SIDE = 880;
 /** a row's height in one across, the list (cubes'). */
 export declare const SQUARE_LIST_ROW = 76;
+/** the place a square something can be added to aims for, in px (cube design, 2026-11-04). */
+export declare const SQUARE_LEAST_CELL = 200;
+/**
+ * how many across a square something can be added to stands at least, in a side this wide: as many
+ * as keep a place near `cell` px, at least `min` (3, the phone's turning front) and at most `max`.
+ * an empty piece is then a square of places with add first, never one place as wide as the screen
+ * (selim, 2026-11-04, way c of `studies/empty-piece-places.md`): 3 × 3 on a phone, 4 × 4 in a
+ * desktop column, 5 × 5 at the widest.
+ */
+export declare function squareLeast(side: number, opts?: {
+  cell?: number;
+  min?: number;
+  max?: number;
+}): number;
 /**
  * how this many tiles are laid out in a view, in this much room. the square view is the smallest
  * n × n that holds them, as wide as the room and the window's height allow; the other views are as
  * long as they need and scroll. open places only finish the last row, so a view never draws a whole
  * empty row (decision of 2026-11-01): three pieces in 4 × 5 are one row of four. the square keeps
- * its own rule, its size coming from the pieces.
+ * its own rule, its size coming from the pieces, and with `least` it stands at least that many
+ * across (a square something can be added to, decision of 2026-11-04).
  */
 export declare function squareLayout(view: ViewKey, count: number, room: SquareRoom, opts?: {
   maxSide?: number;
   listRow?: number;
+  least?: number;
 }): SquareLayout;
 /** what a tile's template is given. */
 export interface CubeSquareTileContext<T> {
@@ -846,6 +981,13 @@ export declare class CubeSquare<T> {
   readonly listRow: import("@angular/core").InputSignal<number>;
   /** open places dashed, where something could come (a cube of mine, a level with a plus). */
   readonly dashed: import("@angular/core").InputSignal<boolean>;
+  /**
+   * how many across a dashed square stands at least (decision of 2026-11-04): `'room'` (the
+   * default) as many as keep a place near 200 px (`squareLeast`: 3 × 3 on a phone, 4 × 4 or 5 × 5
+   * wider), a number for that many, `0` for the smallest square that holds the tiles. a square
+   * that is not dashed (nothing can come) always keeps the smallest.
+   */
+  readonly least: import("@angular/core").InputSignal<number | "room">;
   /** what keeps a tile the same tile across changes, so it is not drawn anew; its place by default. */
   readonly keyOf: import("@angular/core").InputSignal<(tile: T, index: number) => unknown>;
   /**
@@ -938,6 +1080,11 @@ export declare class CubeSquare<T> {
       "required": false;
       "isSignal": true;
     };
+    "least": {
+      "alias": "least";
+      "required": false;
+      "isSignal": true;
+    };
     "keyOf": {
       "alias": "keyOf";
       "required": false;