sg-widgets-core 0.1.0

package/dist/mock.d.mts

@@ -0,0 +1,167 @@
+import { D as UploadFile, E as ThreadRow, Et as TextSearchFilter, O as UploadResult, R as StatusRecord, _ as SgClient, a as EventLogOptions, bt as EntityRef, c as HierarchyNode, ct as FieldSchema, h as SearchResult, l as HierarchyPath, m as SearchOptions, n as EntityRow, o as EventLogResult, r as EntityTypeInfo, s as FollowingOptions, v as SummarizeOptions, w as TextSearchRow, y as SummarizeResult } from "./client-BhHppzTV.mjs";
+//#region src/mock.d.ts
+/** What the next call should throw instead of answering. */
+export interface MockFailure {
+  /** HTTP status. Default 500. */
+  status?: number;
+  /** `errors[0].title`, which is what `RestClient` puts in `SgApiError.message`. */
+  message?: string;
+  /** Parsed response body, for code that inspects `SgApiError.body`. */
+  body?: unknown;
+}
+export interface MockClientOptions {
+  /** Fixture seed. The same seed always produces the same site. Default 1. */
+  seed?: number;
+  /** Simulated round trip, in milliseconds, applied to every call. Default 0. */
+  latencyMs?: number;
+  /** Arm a failure for the very first call, for demoing an error state without extra wiring. */
+  failNext?: MockFailure | null;
+  /** How many rows of the scaled types to generate. Default 60 Versions. */
+  counts?: {
+    versions?: number;
+  };
+  /**
+   * What `in_last`, `in_next` and `in_calendar_*` resolve against: an ISO string,
+   * epoch milliseconds, or a function read on every call. Default: the current time.
+   * Fixture dates are offsets from `MOCK_NOW`, so pin it there to filter them.
+   */
+  now?: string | number | (() => number);
+}
+/** Midday on the mock site's today, for a caller pinning `now` so relative-date filters land on the fixtures. */
+export declare const MOCK_NOW: string;
+export declare class MockClient implements SgClient {
+  private readonly fixtures;
+  private readonly latencyMs;
+  private readonly clock;
+  private pendingFailure;
+  constructor(options?: MockClientOptions);
+  /**
+   * Make the next call reject with an `SgApiError`, for demoing an error state.
+   * Pass `null` to disarm one that was already set.
+   */
+  failNext(failure?: MockFailure | null): void;
+  /** Rows of a type, in id order. Handy for writing assertions against the fixtures. */
+  rowsOf(entityType: string): ReadonlyArray<Readonly<Record<string, unknown>>>;
+  private gate;
+  private schemaOf;
+  entityTypes(): Promise<EntityTypeInfo[]>;
+  fields(entityType: string, projectId?: number): Promise<Record<string, FieldSchema>>;
+  fieldWithProject(entityType: string, field: string, projectId: number): Promise<FieldSchema>;
+  search(entityType: string, options: SearchOptions): Promise<SearchResult>;
+  textSearch(text: string, entityTypes: Record<string, TextSearchFilter>, page?: {
+    size?: number;
+    number?: number;
+  }): Promise<TextSearchRow[]>;
+  update(entityType: string, id: number, patch: Record<string, unknown>): Promise<EntityRow>;
+  /**
+   * Counts without paging rows.
+   *
+   * `count` and the numeric aggregates are modelled; the rest of the vocabulary the
+   * endpoint prints is not. A grouping returns one group per distinct value with the
+   * empties under a `''` group, `group_value` is what the grouping was computed on and
+   * `group_name` the server's render of it, and one type per field per call wins
+   * (020_summarize).
+   */
+  summarize(entityType: string, options?: SummarizeOptions): Promise<SummarizeResult>;
+  /** An entity group's value is the reference with its name and `valid` (020_summarize); a code is itself. */
+  private groupValueOf;
+  /**
+   * A field the server cannot group is 400 `Grouping is not allowed for field
+   * <Type>.<field>.` on `image` and `summary` (field_types/image, field_types/summary),
+   * and a `pivot_column` is 500 (field_types/pivot_column). `Note.read_by_current_user`,
+   * the per-person read state, is refused the same way; the corpus has not measured it.
+   */
+  private refuseGrouping;
+  /**
+   * One level of the navigation tree.
+   *
+   * The shape is post_hierarchy_expand's: a node with `label`, `ref`, `path` and one
+   * level of `children`. Which levels a project has is the site's own navigation
+   * configuration and not a fixed hierarchy - the probed site's Shot path runs through
+   * the field name `sg_sequence` (post_hierarchy_search) - so this fixture offers the
+   * two branches that configuration draws for a stock project: Shots under their
+   * Sequence, and Assets flat.
+   */
+  hierarchyExpand(path: string): Promise<HierarchyNode>;
+  /**
+   * Where a row sits in the tree. The endpoint takes an entity and answers its
+   * breadcrumb; it does not match words (post_hierarchy_search).
+   */
+  hierarchySearch(rootPath: string, entity: EntityRef): Promise<HierarchyPath[]>;
+  /** What a level of the tree is called, without opening it. */
+  private labelAtPath;
+  /** The row a `.../id/<n>` path segment names, from the type the path last named. */
+  private rowAtPath;
+  /** The breadcrumb to a row, root first, the row itself last. Empty when it is not in the tree. */
+  private pathTo;
+  statuses(): Promise<StatusRecord[]>;
+  /**
+   * Create one row and answer it.
+   *
+   * `project` is the whole contract on a project-scoped type, and the schema's
+   * `mandatory` flags are not it: the identity field is optional and the server
+   * fills it, except on a Note, which stays titleless (012_create_version,
+   * entity_types/Note). Nothing is unique, so two identical creates make two rows.
+   */
+  create(entityType: string, body: Record<string, unknown>): Promise<EntityRow>;
+  /**
+   * Put a file on a row, as the three-call handshake leaves the site.
+   *
+   * The field in the path picks the kind: `image` a Thumbnail, another field an
+   * Attachment on it, no field a generic Attachment on `attachment_links`
+   * (recipes/001). The mock moves no bytes, so there is no `ETag` to give back.
+   */
+  upload(entityType: string, id: number, file: UploadFile): Promise<UploadResult>;
+  /**
+   * An entity link is a `{type, id}` hash. A bare id is refused naming the class it
+   * got (entity_types/Reply, field_types/entity) and a hash with no `type` naming the
+   * missing key (field_types/entity).
+   */
+  private checkLink;
+  /** The next free id of a type, which is what a create takes. */
+  private nextId;
+  /** The reverse view of a link the server fills in: a Reply lands in `Note.replies`. */
+  private linkBack;
+  /**
+   * A Note, its Attachments and its Replies in one list in time order.
+   *
+   * The author key follows the row type, `created_by` on a Note and an Attachment
+   * and `user` on a Reply, whose hash carries an avatar the other two do not, and
+   * so does what `entityFields` can widen: the Reply entry is accepted and changes
+   * nothing (get_entity_notes_id_thread_contents).
+   */
+  threadContents(noteId: number, entityFields?: Record<string, string[]>): Promise<ThreadRow[]>;
+  /** One thread row, in the flat shape the endpoint answers. */
+  private threadRow;
+  /** `{id, name, type}`, plus a presigned `image` when the row is a Reply. */
+  private threadAuthor;
+  /**
+   * What changed, newest first. `meta` is read off the row because it takes no
+   * filter and no sort, and the cut is made on `project`, `entity`, `event_type`,
+   * `attribute_name` and `created_at` (025_event_log).
+   */
+  eventLog(options?: EventLogOptions): Promise<EventLogResult>;
+  /**
+   * Everything one person follows, unpaged. `entity` takes the schema name or the
+   * snake_case plural, and both cuts are made server-side
+   * (get_entity_human_users_id_following).
+   */
+  following(userId: number, options?: FollowingOptions): Promise<EntityRef[]>;
+  private displayNameOfRef;
+  private decorate;
+  private project;
+  private resolveProjection;
+  /**
+   * Resolve a plain or dotted path to the values it reaches. `strict` makes an
+   * unknown field or an unknown middle type throw the 400 the API answers in a
+   * filter; the projection side wants a silent miss instead.
+   */
+  private walk;
+  /** The data type a filter path lands on, for choosing the comparison and validating the operator. */
+  private dataTypeAt;
+  private linkedPair;
+  private matchGroup;
+  private matchCondition;
+  private applySort;
+}
+//#endregion