@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/model/cds-1.0.0.ts

@@ -0,0 +1,212 @@
+export const CDS_SCHEMA_VERSION = "cds/1.0.0" as const;
+export const LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION =
+  "persisted-editor-snapshot/1" as const;
+export const PERSISTED_EDITOR_SNAPSHOT_VERSION =
+  "persisted-editor-snapshot/2" as const;
+export const COMPATIBILITY_REPORT_VERSION = "compatibility-report/1" as const;
+
+export type CDS_SchemaVersion = typeof CDS_SCHEMA_VERSION;
+export type PersistedEditorSnapshotVersion =
+  | typeof LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION
+  | typeof PERSISTED_EDITOR_SNAPSHOT_VERSION;
+export type CompatibilityReportVersion = typeof COMPATIBILITY_REPORT_VERSION;
+
+export type Id = string;
+export type UUID = string;
+export type ISO8601DateTime = string;
+export type Base64 = string;
+export type PartName = string;
+export type RelationshipId = string;
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+
+export interface JsonObject {
+  [key: string]: JsonValue | undefined;
+}
+
+export interface ModelValidationIssue {
+  path: string;
+  message: string;
+}
+
+export class ModelValidationError extends Error {
+  readonly issues: readonly ModelValidationIssue[];
+
+  constructor(message: string, issues: readonly ModelValidationIssue[]) {
+    super(message);
+    this.name = "ModelValidationError";
+    this.issues = issues;
+  }
+}
+
+const UUID_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ISO_8601_UTC_PATTERN =
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+export function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+export function isUuid(value: unknown): value is UUID {
+  return typeof value === "string" && UUID_PATTERN.test(value);
+}
+
+export function isIso8601UtcTimestamp(
+  value: unknown,
+): value is ISO8601DateTime {
+  return (
+    typeof value === "string" &&
+    ISO_8601_UTC_PATTERN.test(value) &&
+    !Number.isNaN(Date.parse(value))
+  );
+}
+
+export function asPlainObject(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): Record<string, unknown> | null {
+  if (!isPlainObject(value)) {
+    issues.push({ path, message: "Expected a plain object." });
+    return null;
+  }
+
+  return value;
+}
+
+export function expectString(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): string | null {
+  if (!isNonEmptyString(value)) {
+    issues.push({ path, message: "Expected a non-empty string." });
+    return null;
+  }
+
+  return value;
+}
+
+export function expectStringAllowEmpty(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): string | null {
+  if (typeof value !== "string") {
+    issues.push({ path, message: "Expected a string." });
+    return null;
+  }
+
+  return value;
+}
+
+export function expectExactString<T extends string>(
+  value: unknown,
+  expected: T,
+  path: string,
+  issues: ModelValidationIssue[],
+): T | null {
+  if (value !== expected) {
+    issues.push({
+      path,
+      message: `Expected ${JSON.stringify(expected)}.`,
+    });
+    return null;
+  }
+
+  return expected;
+}
+
+export function expectIso8601UtcTimestamp(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): ISO8601DateTime | null {
+  if (!isIso8601UtcTimestamp(value)) {
+    issues.push({
+      path,
+      message: "Expected an ISO 8601 UTC timestamp string.",
+    });
+    return null;
+  }
+
+  return value;
+}
+
+export function expectUuid(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): UUID | null {
+  if (!isUuid(value)) {
+    issues.push({
+      path,
+      message: "Expected an RFC 4122 UUID string.",
+    });
+    return null;
+  }
+
+  return value;
+}
+
+export function sortRecordKeys<T>(
+  record: Record<string, T>,
+): Array<[string, T]> {
+  return Object.entries(record).sort(([left], [right]) =>
+    left.localeCompare(right),
+  );
+}
+
+export function assertValid(
+  issues: readonly ModelValidationIssue[],
+  message: string,
+): void {
+  if (issues.length > 0) {
+    throw new ModelValidationError(message, issues);
+  }
+}
+
+function toStableJsonValue(value: unknown): JsonValue {
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  ) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => toStableJsonValue(item));
+  }
+
+  if (!isPlainObject(value)) {
+    throw new TypeError("Cannot serialize non-JSON value.");
+  }
+
+  const sortedEntries = sortRecordKeys(value).filter(
+    ([, entryValue]) => entryValue !== undefined,
+  );
+  const result: JsonObject = {};
+
+  for (const [key, entryValue] of sortedEntries) {
+    result[key] = toStableJsonValue(entryValue);
+  }
+
+  return result;
+}
+
+export function stableStringify(value: unknown): string {
+  return JSON.stringify(toStableJsonValue(value));
+}