bazis 0.96.1

package/library/ui/index.ts

@@ -0,0 +1,129 @@
+export {
+  UiProfile,
+  isUiProfileAuthoringClass,
+  uiOperation,
+  uiEndpoint,
+  uiProfileAuthoringMetadataOf,
+} from "./UiProfile";
+export {
+  COMPILED_UI_SURFACE_V1_API_VERSION,
+  COMPILED_UI_SURFACE_V1_KIND,
+} from "./compiled-v1";
+export {
+  compileUiSurfaceV1,
+  indexOpenApiV1,
+} from "./compiler";
+export { defineUiProfile } from "./defineUiProfile";
+export { uiDiagnosticV1 } from "./diagnostics-v1";
+export {
+  UI_PROFILE_V1_API_VERSION,
+  UI_PROFILE_V1_KIND,
+} from "./profile-v1";
+export {
+  canonicalUiJson,
+  normalizeUiJsonObject,
+  normalizeUiJsonValue,
+  uiDocumentRevision,
+} from "./serialization";
+export type {
+  AnyUiProfileAuthoringOptions,
+  UiActionIntentOverride,
+  UiActionPlacementOverride,
+  UiAuthoringClass,
+  UiControllerClass,
+  UiControllerMethod,
+  UiControllerMethodKey,
+  UiControllerMethodReference,
+  UiCustomPageAuthoring,
+  UiCustomPageBaseAuthoring,
+  UiCustomPagesProfileAuthoringOptions,
+  UiDashboardBlockAuthoring,
+  UiDashboardPageAuthoring,
+  UiDataFieldKey,
+  UiDeleteAuthoringOverride,
+  UiDocumentPageAuthoring,
+  UiEndpointAuthoringOptions,
+  UiEndpointReference,
+  UiFeaturePageAuthoring,
+  UiFieldSelection,
+  UiListFieldOverride,
+  UiFormFieldMap,
+  UiFormFieldOverride,
+  UiFormAuthoringOverride,
+  UiListAuthoringOverride,
+  UiProfileAuthoringMetadata,
+  UiProfileAuthoringOptions,
+  UiProfileNavigationOverride,
+  UiProfileOperations,
+  UiRequestClass,
+  UiResponseReference,
+  UiResponseValue,
+  UiSettingsPageAuthoring,
+  UiSortField,
+} from "./UiProfile";
+export type {
+  CompiledUiActionV1,
+  CompiledUiCustomPageBaseV1,
+  CompiledUiCustomPageV1,
+  CompiledUiDashboardBlockV1,
+  CompiledUiDashboardPageV1,
+  CompiledUiDocumentPageV1,
+  CompiledUiFeaturePageV1,
+  CompiledUiNavigationItemV1,
+  CompiledUiOperationRefV1,
+  CompiledUiResourceOperationsV1,
+  CompiledUiResourceV1,
+  CompiledUiSettingsPageV1,
+  CompiledUiSurfaceLinksV1,
+  CompiledUiSurfaceMetadataV1,
+  CompiledUiSurfaceSpecV1,
+  CompiledUiSurfaceV1,
+} from "./compiled-v1";
+export type {
+  CompileUiSurfaceV1Options,
+  CompileUiSurfaceV1Result,
+  UiOpenApiHttpMethodV1,
+  UiOpenApiIndexResultV1,
+  UiOpenApiIndexV1,
+  UiOpenApiOperationV1,
+} from "./compiler";
+export type {
+  UiDiagnosticSeverityV1,
+  UiDiagnosticV1,
+} from "./diagnostics-v1";
+export type {
+  UiActionIntentV1,
+  UiActionPlacementV1,
+  UiActionProfileV1,
+  UiCustomPageBaseProfileV1,
+  UiCustomPageProfileV1,
+  UiDashboardBlockProfileV1,
+  UiDashboardPageProfileV1,
+  UiDetailProfileV1,
+  UiDetailSectionProfileV1,
+  UiDocumentPageProfileV1,
+  UiFeaturePageProfileV1,
+  UiFieldProfileV1,
+  UiFormProfileV1,
+  UiFormsProfileV1,
+  UiListProfileV1,
+  UiNavigationProfileV1,
+  UiOperationRefV1,
+  UiProfileMetadataV1,
+  UiProfileSpecV1,
+  UiProfileV1,
+  UiResourceOperationsProfileV1,
+  UiResourceProfileV1,
+  UiSchemaCategorizationV1,
+  UiSchemaCategoryV1,
+  UiSchemaControlV1,
+  UiSchemaElementV1,
+  UiSchemaLabelV1,
+  UiSchemaLayoutV1,
+  UiSettingsPageProfileV1,
+} from "./profile-v1";
+export type {
+  UiJsonObject,
+  UiJsonPrimitive,
+  UiJsonValue,
+} from "./serialization";

package/library/ui/profile-v1.ts

@@ -0,0 +1,191 @@
+import type { UiJsonObject } from "./serialization";
+
+export const UI_PROFILE_V1_API_VERSION = "ui.bazis.dev/v1" as const;
+export const UI_PROFILE_V1_KIND = "UiProfile" as const;
+
+export interface UiProfileV1 {
+  readonly apiVersion: typeof UI_PROFILE_V1_API_VERSION;
+  readonly kind: typeof UI_PROFILE_V1_KIND;
+  readonly metadata: UiProfileMetadataV1;
+  readonly spec: UiProfileSpecV1;
+}
+
+export interface UiProfileMetadataV1 {
+  readonly name: string;
+  readonly surface: string;
+  readonly owner: string;
+  readonly extensions?: UiJsonObject;
+}
+
+export interface UiProfileSpecV1 {
+  readonly resources: readonly UiResourceProfileV1[];
+  readonly customPages?: readonly UiCustomPageProfileV1[];
+  readonly requiredRendererCapabilities?: readonly string[];
+  readonly extensions?: UiJsonObject;
+}
+
+export interface UiCustomPageBaseProfileV1 {
+  readonly id: string;
+  readonly title: string;
+  readonly navigation?: UiNavigationProfileV1;
+}
+
+export interface UiSettingsPageProfileV1 extends UiCustomPageBaseProfileV1 {
+  readonly kind: "settings";
+  readonly operations: {
+    readonly read: UiOperationRefV1;
+    readonly update: UiOperationRefV1;
+  };
+  readonly form?: UiFormProfileV1;
+}
+
+export interface UiDocumentPageProfileV1 extends UiCustomPageBaseProfileV1 {
+  readonly kind: "document";
+  readonly operation: UiOperationRefV1;
+}
+
+export interface UiDashboardBlockProfileV1 {
+  readonly id: string;
+  readonly kind: "metric" | "document";
+  readonly title: string;
+  readonly operation: UiOperationRefV1;
+}
+
+export interface UiDashboardPageProfileV1 extends UiCustomPageBaseProfileV1 {
+  readonly kind: "dashboard";
+  readonly blocks: readonly UiDashboardBlockProfileV1[];
+}
+
+/** A feature-owned page rendered entirely by a registered client component. */
+export interface UiFeaturePageProfileV1 extends UiCustomPageBaseProfileV1 {
+  readonly kind: "feature";
+  readonly renderer: string;
+}
+
+export type UiCustomPageProfileV1 =
+  | UiSettingsPageProfileV1
+  | UiDocumentPageProfileV1
+  | UiDashboardPageProfileV1
+  | UiFeaturePageProfileV1;
+
+export interface UiResourceProfileV1 {
+  readonly id: string;
+  readonly title?: string;
+  readonly singularTitle?: string;
+  /** Response field whose value identifies a record in renderer routes/actions. */
+  readonly keyField?: string;
+  readonly navigation?: UiNavigationProfileV1;
+  readonly operations?: UiResourceOperationsProfileV1;
+  readonly list?: UiListProfileV1;
+  readonly detail?: UiDetailProfileV1;
+  readonly forms?: UiFormsProfileV1;
+  readonly actions?: readonly UiActionProfileV1[];
+  readonly extensions?: UiJsonObject;
+}
+
+export interface UiNavigationProfileV1 {
+  readonly title?: string;
+  readonly group?: string;
+  readonly icon?: string;
+  readonly order?: number;
+  readonly hidden?: boolean;
+}
+
+export interface UiOperationRefV1 {
+  readonly operationId: string;
+}
+
+export interface UiResourceOperationsProfileV1 {
+  readonly list?: UiOperationRefV1;
+  readonly read?: UiOperationRefV1;
+  readonly create?: UiOperationRefV1;
+  readonly update?: UiOperationRefV1;
+  readonly delete?: UiOperationRefV1;
+}
+
+export type UiFieldProfileV1 = string;
+
+export interface UiListProfileV1 {
+  readonly title?: string;
+  readonly columns?: readonly UiFieldProfileV1[];
+  readonly selectionFields?: readonly UiFieldProfileV1[];
+  readonly defaultSort?: string;
+  readonly pageSize?: number;
+}
+
+export interface UiDetailProfileV1 {
+  readonly titleField?: string;
+  readonly subtitleField?: string;
+  readonly statusField?: string;
+  readonly sections?: readonly UiDetailSectionProfileV1[];
+}
+
+export interface UiDetailSectionProfileV1 {
+  readonly id: string;
+  readonly title: string;
+  readonly fields: readonly UiFieldProfileV1[];
+}
+
+export interface UiFormsProfileV1 {
+  readonly create?: UiFormProfileV1;
+  readonly edit?: UiFormProfileV1;
+}
+
+export interface UiFormProfileV1 {
+  readonly title?: string;
+  readonly uiSchema?: UiSchemaElementV1;
+}
+
+export type UiSchemaElementV1 =
+  | UiSchemaControlV1
+  | UiSchemaLabelV1
+  | UiSchemaLayoutV1
+  | UiSchemaCategorizationV1
+  | UiSchemaCategoryV1;
+
+export interface UiSchemaControlV1 {
+  readonly type: "Control";
+  readonly scope: string;
+  readonly label?: string | boolean;
+  readonly options?: UiJsonObject;
+}
+
+export interface UiSchemaLabelV1 {
+  readonly type: "Label";
+  readonly text: string;
+}
+
+export interface UiSchemaLayoutV1 {
+  readonly type: "VerticalLayout" | "HorizontalLayout" | "Group";
+  readonly label?: string;
+  readonly elements: readonly UiSchemaElementV1[];
+}
+
+export interface UiSchemaCategorizationV1 {
+  readonly type: "Categorization";
+  readonly elements: readonly UiSchemaCategoryV1[];
+}
+
+export interface UiSchemaCategoryV1 {
+  readonly type: "Category";
+  readonly label: string;
+  readonly elements: readonly UiSchemaElementV1[];
+}
+
+export type UiActionIntentV1 = "primary" | "secondary" | "danger" | "neutral";
+
+export type UiActionPlacementV1 =
+  | "list.header"
+  | "list.row"
+  | "detail.header";
+
+export interface UiActionProfileV1 {
+  readonly id: string;
+  readonly title: string;
+  readonly operation: UiOperationRefV1;
+  readonly placements: readonly UiActionPlacementV1[];
+  readonly intent?: UiActionIntentV1;
+  readonly confirm?: string;
+  readonly refresh?: "none" | "resource" | "page" | "all";
+  readonly extensions?: UiJsonObject;
+}

package/library/ui/serialization.ts

@@ -0,0 +1,130 @@
+import { createHash } from "node:crypto";
+
+export type UiJsonPrimitive = string | number | boolean | null;
+export type UiJsonValue = UiJsonPrimitive | readonly UiJsonValue[] | UiJsonObject;
+
+export interface UiJsonObject {
+  readonly [key: string]: UiJsonValue;
+}
+
+/**
+ * Converts an input into a deeply frozen, key-sorted JSON value.
+ *
+ * The boundary is intentionally stricter than JSON.stringify: undefined,
+ * non-finite numbers, sparse arrays, accessors, class instances, symbols,
+ * functions and cycles are rejected instead of being silently changed.
+ */
+export function normalizeUiJsonValue(value: unknown, path = "$"): UiJsonValue {
+  return normalizeValue(value, path, new WeakSet<object>());
+}
+
+export function normalizeUiJsonObject(value: unknown, path = "$"): UiJsonObject {
+  const normalized = normalizeUiJsonValue(value, path);
+  if (normalized === null || Array.isArray(normalized) || typeof normalized !== "object") {
+    throw new TypeError(path + " must be a plain JSON object.");
+  }
+  return normalized as UiJsonObject;
+}
+
+export function canonicalUiJson(value: unknown): string {
+  return JSON.stringify(normalizeUiJsonValue(value));
+}
+
+export function uiDocumentRevision(value: unknown): string {
+  const digest = createHash("sha256").update(canonicalUiJson(value)).digest("hex");
+  return "sha256:" + digest;
+}
+
+function normalizeValue(value: unknown, path: string, active: WeakSet<object>): UiJsonValue {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(path + " must be a finite JSON number.");
+    }
+    return Object.is(value, -0) ? 0 : value;
+  }
+
+  if (typeof value !== "object") {
+    throw new TypeError(path + " contains a non-JSON " + typeof value + " value.");
+  }
+
+  if (active.has(value)) {
+    throw new TypeError(path + " contains a circular reference.");
+  }
+
+  active.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return normalizeArray(value, path, active);
+    }
+    return normalizeObject(value, path, active);
+  } finally {
+    active.delete(value);
+  }
+}
+
+function normalizeArray(value: readonly unknown[], path: string, active: WeakSet<object>): readonly UiJsonValue[] {
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new TypeError(path + " must not contain symbol properties.");
+  }
+
+  const enumerableKeys = Object.keys(value);
+  for (const key of enumerableKeys) {
+    if (!isArrayIndex(key) || Number(key) >= value.length) {
+      throw new TypeError(path + " must not contain non-index array properties.");
+    }
+  }
+
+  const normalized: UiJsonValue[] = [];
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.prototype.hasOwnProperty.call(value, index)) {
+      throw new TypeError(path + "[" + index + "] must not be an array hole.");
+    }
+    normalized.push(normalizeValue(value[index], path + "[" + index + "]", active));
+  }
+  return Object.freeze(normalized);
+}
+
+function normalizeObject(value: object, path: string, active: WeakSet<object>): UiJsonObject {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError(path + " must be a plain JSON object.");
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new TypeError(path + " must not contain symbol properties.");
+  }
+
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const normalized: Record<string, UiJsonValue> = {};
+  for (const key of Object.keys(descriptors).sort()) {
+    const descriptor = descriptors[key];
+    if (descriptor === undefined) {
+      continue;
+    }
+    if (!descriptor.enumerable) {
+      throw new TypeError(propertyPath(path, key) + " must be enumerable.");
+    }
+    if (!("value" in descriptor)) {
+      throw new TypeError(propertyPath(path, key) + " must not be an accessor property.");
+    }
+    normalized[key] = normalizeValue(descriptor.value, propertyPath(path, key), active);
+  }
+  return Object.freeze(normalized) as UiJsonObject;
+}
+
+function isArrayIndex(key: string): boolean {
+  if (!/^(0|[1-9][0-9]*)$/.test(key)) {
+    return false;
+  }
+  const value = Number(key);
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function propertyPath(path: string, key: string): string {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+    ? path + "." + key
+    : path + "[" + JSON.stringify(key) + "]";
+}