@almadar/core 10.37.0 → 10.38.0

package/dist/mock/index.js

@@ -0,0 +1,695 @@
+import { z } from 'zod';
+
+// src/mock/random.ts
+var seedState = 42;
+function seedRandom(value) {
+  seedState = (value ?? 42) >>> 0;
+}
+function nextFloat() {
+  seedState = seedState * 1664525 + 1013904223 >>> 0;
+  return seedState / 4294967296;
+}
+function randomInt({ min, max }) {
+  return Math.floor(nextFloat() * (max - min + 1)) + min;
+}
+function randomFloat({
+  min,
+  max,
+  fractionDigits = 2
+}) {
+  const value = nextFloat() * (max - min) + min;
+  const factor = 10 ** fractionDigits;
+  return Math.round(value * factor) / factor;
+}
+function randomBoolean() {
+  return nextFloat() < 0.5;
+}
+function randomArrayElement(array) {
+  return array[randomInt({ min: 0, max: array.length - 1 })];
+}
+function shuffleArray(array) {
+  const copy = array.slice();
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = randomInt({ min: 0, max: i });
+    const tmp = copy[i];
+    copy[i] = copy[j];
+    copy[j] = tmp;
+  }
+  return copy;
+}
+function randomPastDate({ years = 1 } = {}) {
+  const now = Date.now();
+  const maxAge = years * 365 * 24 * 60 * 60 * 1e3;
+  const age = Math.floor(nextFloat() * maxAge);
+  return new Date(now - age);
+}
+function randomRecentDate({ days = 30 } = {}) {
+  const now = Date.now();
+  const maxAge = days * 24 * 60 * 60 * 1e3;
+  const age = Math.floor(nextFloat() * maxAge);
+  return new Date(now - age);
+}
+function randomAnytimeDate() {
+  const now = Date.now();
+  const maxAge = 100 * 365 * 24 * 60 * 60 * 1e3;
+  const age = Math.floor(nextFloat() * maxAge);
+  return new Date(now - age);
+}
+var LOREM_WORDS = [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "ut",
+  "labore",
+  "et",
+  "dolore",
+  "magna",
+  "aliqua",
+  "enim",
+  "ad",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud",
+  "exercitation",
+  "ullamco",
+  "laboris",
+  "nisi",
+  "aliquip",
+  "ex",
+  "ea",
+  "commodo",
+  "consequat",
+  "duis",
+  "aute",
+  "irure",
+  "in",
+  "reprehenderit",
+  "voluptate",
+  "velit",
+  "esse",
+  "cillum",
+  "fugiat",
+  "nulla",
+  "pariatur",
+  "excepteur",
+  "sint",
+  "occaecat",
+  "cupidatat",
+  "non",
+  "proident",
+  "sunt",
+  "culpa",
+  "qui",
+  "officia",
+  "deserunt",
+  "mollit",
+  "anim",
+  "id",
+  "est",
+  "laborum"
+];
+function randomWords(count) {
+  const words = [];
+  for (let i = 0; i < count; i++) {
+    words.push(randomArrayElement(LOREM_WORDS));
+  }
+  return words.join(" ");
+}
+function randomSentence() {
+  const words = randomWords(randomInt({ min: 4, max: 8 }));
+  return words.charAt(0).toUpperCase() + words.slice(1) + ".";
+}
+function randomUuid() {
+  const hex = () => randomInt({ min: 0, max: 15 }).toString(16);
+  return `${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}-${hex()}${hex()}${hex()}${hex()}-4${hex()}${hex()}${hex()}-${hex()}${hex()}${hex()}${hex()}-${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}`;
+}
+function randomColor() {
+  const channel = () => randomInt({ min: 0, max: 255 }).toString(16).padStart(2, "0");
+  return `#${channel()}${channel()}${channel()}`;
+}
+var PASSWORD_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
+function randomPassword(length = 12) {
+  let password = "";
+  for (let i = 0; i < length; i++) {
+    password += randomArrayElement(PASSWORD_CHARS.split(""));
+  }
+  return password;
+}
+function randomEmail() {
+  const user = randomWords(1).toLowerCase().replace(/\s+/g, ".");
+  const domain = randomWords(1).toLowerCase().replace(/\s+/g, "");
+  return `${user}@${domain}.com`;
+}
+function randomUrl() {
+  const slug2 = randomWords(2).toLowerCase().replace(/\s+/g, "-");
+  return `https://example.com/${slug2}`;
+}
+function randomPhone() {
+  const area = randomInt({ min: 200, max: 999 });
+  const prefix = randomInt({ min: 200, max: 999 });
+  const line = randomInt({ min: 0, max: 9999 }).toString().padStart(4, "0");
+  return `+1 (${area}) ${prefix}-${line}`;
+}
+var ID_PREFIXES = {
+  orbital: "orb_",
+  entity: "ent_",
+  trait: "trt_",
+  event: "evt_",
+  page: "pag_",
+  service: "svc_",
+  theme: "thm_",
+  palette: "pal_"
+};
+function brand(value) {
+  return value;
+}
+function makeIdKind(kind) {
+  const prefix = ID_PREFIXES[kind];
+  const is = (value) => value.startsWith(prefix) && value.length > prefix.length;
+  const as = (value) => {
+    if (!is(value)) {
+      throw new Error(
+        `Expected ${kind} id (prefix "${prefix}"), got: ${JSON.stringify(value)}`
+      );
+    }
+    return brand(value);
+  };
+  return { prefix, is, as };
+}
+var orbitalKind = makeIdKind("orbital");
+var entityKind = makeIdKind("entity");
+var traitKind = makeIdKind("trait");
+var eventKind = makeIdKind("event");
+var pageKind = makeIdKind("page");
+var serviceKind = makeIdKind("service");
+var themeKind = makeIdKind("theme");
+var paletteKind = makeIdKind("palette");
+var isOrbitalId = orbitalKind.is;
+var isEntityId = entityKind.is;
+var isTraitId = traitKind.is;
+var isEventId = eventKind.is;
+var isPageId = pageKind.is;
+var isServiceId = serviceKind.is;
+var isThemeId = themeKind.is;
+var isPaletteEntryId = paletteKind.is;
+z.string().refine(isOrbitalId, { message: `Expected an orbital id (prefix "${ID_PREFIXES.orbital}")` });
+var EntityIdSchema = z.string().refine(isEntityId, { message: `Expected an entity id (prefix "${ID_PREFIXES.entity}")` });
+var TraitIdSchema = z.string().refine(isTraitId, { message: `Expected a trait id (prefix "${ID_PREFIXES.trait}")` });
+z.string().refine(isEventId, { message: `Expected an event id (prefix "${ID_PREFIXES.event}")` });
+z.string().refine(isPageId, { message: `Expected a page id (prefix "${ID_PREFIXES.page}")` });
+z.string().refine(isServiceId, { message: `Expected a service id (prefix "${ID_PREFIXES.service}")` });
+z.string().refine(isThemeId, { message: `Expected a theme id (prefix "${ID_PREFIXES.theme}")` });
+z.string().refine(isPaletteEntryId, { message: `Expected a palette-entry id (prefix "${ID_PREFIXES.palette}")` });
+var LedgerKindSchema = z.enum([
+  "orbital",
+  "entity",
+  "trait",
+  "event",
+  "page",
+  "service",
+  "theme"
+]);
+var LedgerEntrySchema = z.object({
+  id: z.string(),
+  kind: LedgerKindSchema,
+  bakedName: z.string(),
+  curName: z.string(),
+  renames: z.array(
+    z.object({ from: z.string(), to: z.string(), at: z.string() })
+  ),
+  owner: z.enum(["std", "io", "workspace"]),
+  parent: TraitIdSchema.optional()
+});
+z.object({
+  schemaVersion: z.literal(1),
+  entries: z.record(LedgerEntrySchema)
+});
+var JsonValueSchema = z.lazy(
+  () => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(JsonValueSchema), z.record(JsonValueSchema)])
+);
+
+// src/types/field.ts
+var FIELD_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "timestamp",
+  "datetime",
+  "email",
+  "url",
+  "phone",
+  "uuid",
+  "image",
+  "array",
+  "object",
+  "enum",
+  "relation",
+  "trait",
+  "slot",
+  "pattern"
+];
+z.enum(FIELD_TYPES);
+var RelationCardinalitySchema = z.enum([
+  "one",
+  "many",
+  "one-to-many",
+  "many-to-one",
+  "many-to-many"
+]);
+var RelationConfigSchema = z.object({
+  entity: z.string().min(1, "Target entity is required"),
+  entityId: EntityIdSchema.optional(),
+  field: z.string().optional(),
+  cardinality: RelationCardinalitySchema.optional(),
+  onDelete: z.enum(["cascade", "nullify", "restrict"]).optional(),
+  // Legacy compatibility fields
+  foreignKey: z.string().optional(),
+  target: z.string().optional(),
+  type: RelationCardinalitySchema.optional()
+}).transform((data) => {
+  const normalized = {
+    entity: data.entity || data.target || "",
+    entityId: data.entityId,
+    cardinality: data.cardinality || data.type,
+    field: data.field,
+    onDelete: data.onDelete
+  };
+  return normalized;
+});
+var FIELD_TYPE_ALIASES = {
+  text: "string",
+  int: "number",
+  float: "number",
+  ts: "timestamp"
+};
+var EntityFieldSchema = z.lazy(() => {
+  const baseFieldShape = {
+    name: z.string().min(1, "Field name is required").optional(),
+    required: z.boolean().optional(),
+    default: JsonValueSchema.optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    properties: z.record(EntityFieldSchema).optional(),
+    intrinsic: z.boolean().optional(),
+    description: z.string().optional(),
+    synonyms: z.string().optional()
+  };
+  function scalarVariant(t) {
+    return z.object({
+      ...baseFieldShape,
+      type: z.literal(t),
+      values: z.array(z.string()).optional()
+    });
+  }
+  return z.preprocess(
+    (input) => {
+      if (input === null || typeof input !== "object" || !("type" in input) || typeof input.type !== "string") {
+        return input;
+      }
+      const obj = input;
+      const next = { ...obj };
+      const aliased = FIELD_TYPE_ALIASES[obj.type];
+      if (aliased !== void 0) next.type = aliased;
+      if (next.enum !== void 0 && next.values === void 0) {
+        next.values = next.enum;
+      }
+      delete next.enum;
+      return next;
+    },
+    z.discriminatedUnion("type", [
+      scalarVariant("string"),
+      scalarVariant("number"),
+      scalarVariant("boolean"),
+      scalarVariant("date"),
+      scalarVariant("timestamp"),
+      scalarVariant("datetime"),
+      scalarVariant("email"),
+      scalarVariant("url"),
+      scalarVariant("phone"),
+      scalarVariant("uuid"),
+      scalarVariant("image"),
+      scalarVariant("trait"),
+      scalarVariant("slot"),
+      scalarVariant("pattern"),
+      // Enum variant — REQUIRES non-empty values.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("enum"),
+        values: z.array(z.string()).min(1, "Enum field requires a non-empty `values` array")
+      }),
+      // Relation variant — REQUIRES relation config.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("relation"),
+        relation: RelationConfigSchema
+      }),
+      // Array variant — items optional to match relaxed TS shape.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("array"),
+        items: EntityFieldSchema.optional()
+      }),
+      // Object variant — fixed-key struct (`properties`) or dynamic-key
+      // map (`Map K V`, uniform value schema in `items`).
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("object"),
+        items: EntityFieldSchema.optional(),
+        values: z.array(z.string()).optional()
+      })
+    ])
+  );
+});
+var ENTITY_ROLES = [
+  "player",
+  "enemy",
+  "npc",
+  "item",
+  "tile",
+  "projectile",
+  "effect",
+  "ui",
+  "decoration",
+  "vehicle"
+];
+z.enum(ENTITY_ROLES);
+var VISUAL_STYLES = ["pixel", "vector", "hd", "1-bit", "isometric"];
+var VisualStyleSchema = z.enum(VISUAL_STYLES);
+var ASSET_DIMENSIONS = ["2d", "3d"];
+var AssetDimensionSchema = z.enum(ASSET_DIMENSIONS);
+var ASSET_ASPECTS = ["1:1", "16:9", "5:7", "8:1"];
+var AssetAspectSchema = z.enum(ASSET_ASPECTS);
+var ANIMATION_NAMES = ["idle", "walk", "attack", "hit", "death"];
+var AnimationNameSchema = z.enum(ANIMATION_NAMES);
+var SPRITE_DIRECTIONS = ["se", "sw"];
+var SpriteDirectionSchema = z.enum(SPRITE_DIRECTIONS);
+var AnimationDefSchema = z.object({
+  row: z.number().int().nonnegative(),
+  frames: z.number().int().positive(),
+  frameRate: z.number().positive(),
+  loop: z.boolean()
+});
+z.object({
+  unit: z.string().optional(),
+  type: z.string().optional(),
+  frameWidth: z.number().positive(),
+  frameHeight: z.number().positive(),
+  columns: z.number().int().positive(),
+  rows: z.number().int().positive(),
+  directions: z.array(SpriteDirectionSchema),
+  sheets: z.record(SpriteDirectionSchema, z.string()),
+  animations: z.record(AnimationNameSchema, AnimationDefSchema)
+});
+var SubTextureSchema = z.object({
+  x: z.number().nonnegative(),
+  y: z.number().nonnegative(),
+  width: z.number().positive(),
+  height: z.number().positive(),
+  frameX: z.number().optional(),
+  frameY: z.number().optional(),
+  frameWidth: z.number().positive().optional(),
+  frameHeight: z.number().positive().optional()
+});
+z.object({
+  imagePath: z.string(),
+  subTextures: z.record(z.string(), SubTextureSchema)
+});
+z.object({
+  imagePath: z.string(),
+  tileWidth: z.number().positive(),
+  tileHeight: z.number().positive(),
+  columns: z.number().int().positive(),
+  rows: z.number().int().positive(),
+  margin: z.number().nonnegative().optional(),
+  spacing: z.number().nonnegative().optional(),
+  names: z.array(z.string()).optional()
+});
+var SemanticAssetRefSchema = z.object({
+  role: z.string().min(1),
+  category: z.string().min(1),
+  animations: z.array(z.string()).optional(),
+  style: VisualStyleSchema.optional(),
+  variant: z.string().optional(),
+  dimension: AssetDimensionSchema.optional(),
+  aspect: AssetAspectSchema.optional()
+});
+SemanticAssetRefSchema.extend({
+  url: z.string(),
+  atlas: z.string().optional(),
+  sprite: z.string().optional(),
+  name: z.string().optional(),
+  thumbnailUrl: z.string().optional()
+});
+var AssetCatalogEntrySchema = z.object({
+  url: z.string(),
+  name: z.string(),
+  category: z.string(),
+  kind: z.enum(["image", "spritesheet", "audio", "scene", "portrait", "model", "other"]),
+  thumbnailUrl: z.string().optional(),
+  dimension: AssetDimensionSchema.optional(),
+  aspect: AssetAspectSchema.optional()
+});
+z.array(AssetCatalogEntrySchema);
+var ScenePosSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number().optional()
+});
+var CAMERA_MODES = ["isometric", "perspective", "top-down", "follow", "chase"];
+var CameraModeSchema = z.enum(CAMERA_MODES);
+z.object({
+  pos: ScenePosSchema.optional(),
+  target: ScenePosSchema.optional(),
+  zoom: z.number().optional(),
+  fov: z.number().optional(),
+  mode: CameraModeSchema.optional()
+});
+
+// src/types/entity.ts
+var EntityPersistenceSchema = z.enum([
+  "persistent",
+  "runtime"
+]);
+z.object({
+  name: z.string().min(1, "Entity name is required"),
+  persistence: EntityPersistenceSchema.default("persistent"),
+  shared: z.boolean().optional(),
+  collection: z.string().optional(),
+  fields: z.array(EntityFieldSchema).min(1, "At least one field is required"),
+  instances: z.array(z.record(z.unknown())).optional(),
+  timestamps: z.boolean().optional(),
+  softDelete: z.boolean().optional(),
+  description: z.string().optional(),
+  visual_prompt: z.string().optional(),
+  assetRef: SemanticAssetRefSchema.optional()
+});
+function isFieldValue(value) {
+  if (value === null) return true;
+  const kind = typeof value;
+  if (kind === "string" || kind === "number" || kind === "boolean") return true;
+  if (value instanceof Date) return true;
+  if (Array.isArray(value)) return value.every((item) => isFieldValue(item));
+  if (kind === "object" && value !== null && typeof value === "object") {
+    return Object.values(value).every((item) => item === void 0 || isFieldValue(item));
+  }
+  return false;
+}
+
+// src/mock/sampleValue.ts
+var MAX_NESTED_DEPTH = 3;
+var RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+var IMAGE_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "image",
+  "imageurl",
+  "image_url",
+  "photo",
+  "photourl",
+  "photo_url",
+  "avatar",
+  "avatarurl",
+  "avatar_url",
+  "thumbnail",
+  "thumbnailurl",
+  "thumbnail_url",
+  "picture",
+  "pictureurl",
+  "cover",
+  "coverurl",
+  "banner",
+  "bannerurl"
+]);
+function sampleImageUrl(entityName, fieldName, ctx, width = 400, height = 400) {
+  const salt = ctx.strategy === "seeded" ? randomInt({ min: 0, max: 1e3 }) : ctx.index;
+  const seed = `${entityName}-${fieldName}-${salt}`;
+  return `https://picsum.photos/seed/${encodeURIComponent(seed)}/${width}/${height}`;
+}
+function titleCase(name) {
+  const spaced = name.split("").flatMap((c) => c === "_" || c === "-" ? [" "] : c === c.toUpperCase() && c !== c.toLowerCase() ? [" ", c] : [c]).join("");
+  return spaced.split(/\s+/).filter((w) => w.length > 0).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function slug(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase() || "value";
+}
+function indexUuid(index) {
+  return `00000000-0000-4000-8000-${index.toString(16).padStart(12, "0").slice(-12)}`;
+}
+function declaredValues(field) {
+  const values = "values" in field ? field.values : void 0;
+  return values && values.length > 0 ? values : void 0;
+}
+function isDeclaredDefaultHonored(field) {
+  const value = field.default;
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "number" || typeof value === "boolean") return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value === "object") return true;
+  if (typeof value !== "string") return false;
+  const values = declaredValues(field);
+  if (value === "") return values !== void 0 && values.includes("");
+  return values === void 0;
+}
+function sampleRowCount(entity, requested) {
+  return entity.persistence === "runtime" ? 1 : requested;
+}
+function sampleText(field, ctx) {
+  const fieldName = field.name ?? "field";
+  if (IMAGE_FIELD_NAMES.has(fieldName.toLowerCase())) {
+    return sampleImageUrl(ctx.entityName, fieldName, ctx);
+  }
+  return ctx.strategy === "seeded" ? randomWords(2) : `${titleCase(fieldName)} ${ctx.index}`;
+}
+function sampleDate(ctx, dateOnly) {
+  if (ctx.strategy === "index") {
+    const month = String(ctx.index % 12 + 1).padStart(2, "0");
+    return dateOnly ? `2026-${month}-15` : `2026-${month}-15T00:00:00.000Z`;
+  }
+  const iso = randomRecentDate({ days: 30 }).toISOString();
+  return dateOnly ? iso.split("T")[0] : iso;
+}
+function sampleRelation(field) {
+  return field.relation?.cardinality === "one" ? "" : [];
+}
+function sampleArray(field, ctx) {
+  const depth = ctx.depth ?? 0;
+  if (!field.items || depth >= MAX_NESTED_DEPTH) return [];
+  const count = ctx.strategy === "seeded" ? randomInt({ min: 3, max: 5 }) : 3;
+  const elementName = field.name ?? "item";
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const element = { ...field.items, name: `${elementName}[${i}]` };
+    out.push(
+      sampleFieldValue(element, {
+        ...ctx,
+        index: ctx.index * 10 + i,
+        depth: depth + 1
+      }) ?? null
+    );
+  }
+  return out;
+}
+function sampleObject(field, ctx) {
+  const depth = ctx.depth ?? 0;
+  if (!field.properties || depth >= MAX_NESTED_DEPTH) return null;
+  const out = {};
+  for (const [propName, propField] of Object.entries(field.properties)) {
+    const child = { ...propField, name: propName };
+    out[propName] = sampleFieldValue(child, { ...ctx, depth: depth + 1 }) ?? null;
+  }
+  return out;
+}
+function sampleFieldValue(field, ctx) {
+  const honoredDefault = field.default !== void 0 && isFieldValue(field.default) ? field.default : void 0;
+  if (field.intrinsic === true) return honoredDefault;
+  const isRuntime = ctx.persistence === "runtime";
+  if (isRuntime && honoredDefault !== void 0) return honoredDefault;
+  if (!isRuntime && isDeclaredDefaultHonored(field) && honoredDefault !== void 0) {
+    return honoredDefault;
+  }
+  const values = declaredValues(field);
+  if (values) {
+    const ordinal = isRuntime ? 1 : ctx.index;
+    return values[(ordinal - 1) % values.length];
+  }
+  switch (field.type) {
+    case "string":
+      return sampleText(field, ctx);
+    // Semantic domains synthesize a value that SATISFIES their own validator —
+    // the property that keeps the seeder and the validator from drifting.
+    case "email":
+      return ctx.strategy === "seeded" ? randomEmail() : `${slug(field.name ?? "user")}${ctx.index}@example.com`;
+    case "url":
+      return ctx.strategy === "seeded" ? randomUrl() : `https://example.com/${slug(field.name ?? "link")}/${ctx.index}`;
+    case "phone":
+      return ctx.strategy === "seeded" ? randomPhone() : `+1-555-${String(1e3 + ctx.index % 9e3).padStart(4, "0")}`;
+    case "uuid":
+      return ctx.strategy === "seeded" ? randomUuid() : indexUuid(ctx.index);
+    case "image":
+      return sampleImageUrl(ctx.entityName, field.name ?? "image", ctx);
+    case "number": {
+      if (ctx.strategy === "seeded") {
+        return randomInt({ min: field.min ?? 0, max: field.max ?? 100 });
+      }
+      const stepped = (field.min ?? 0) + ctx.index * 10;
+      return field.max !== void 0 && stepped > field.max ? field.max : stepped;
+    }
+    case "boolean":
+      return ctx.strategy === "seeded" ? randomBoolean() : ctx.index % 2 === 0;
+    case "date":
+      return sampleDate(ctx, true);
+    case "timestamp":
+    case "datetime":
+      return sampleDate(ctx, false);
+    case "enum":
+      return null;
+    case "relation":
+      return sampleRelation(field);
+    case "array":
+      return sampleArray(field, ctx);
+    case "object":
+      return sampleObject(field, ctx);
+    case "trait":
+    case "slot":
+    case "pattern":
+      return void 0;
+    default:
+      return sampleText(field, ctx);
+  }
+}
+function sampleRow(entity, ctx) {
+  const row = {};
+  for (const field of entity.fields) {
+    const name = field.name;
+    if (!name || RESERVED_FIELD_NAMES.has(name)) continue;
+    const value = sampleFieldValue(field, {
+      ...ctx,
+      entityName: entity.name,
+      persistence: ctx.persistence ?? entity.persistence
+    });
+    if (value !== void 0) row[name] = value;
+  }
+  return row;
+}
+function sampleRows(entity, count, strategy) {
+  const rowCount = sampleRowCount(entity, count);
+  const rows = [];
+  for (let i = 1; i <= rowCount; i++) {
+    rows.push(sampleRow(entity, { index: i, strategy, persistence: entity.persistence }));
+  }
+  return rows;
+}
+
+export { IMAGE_FIELD_NAMES, isDeclaredDefaultHonored, randomAnytimeDate, randomArrayElement, randomBoolean, randomColor, randomEmail, randomFloat, randomInt, randomPassword, randomPastDate, randomPhone, randomRecentDate, randomSentence, randomUrl, randomUuid, randomWords, sampleFieldValue, sampleImageUrl, sampleRow, sampleRowCount, sampleRows, seedRandom, shuffleArray };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map