@aranova/tracking-next 0.27.0 → 1.0.0

package/dist/blog.js

@@ -81,18 +81,15 @@ function registerCapability(capability) {
   registered.add(capability);
 }
 
-// ../tracking-core/src/phone.ts
-var import_libphonenumber_js = require("libphonenumber-js");
-
 // ../tracking-core/src/resources/tracking-config-runtime.ts
 var DEFAULT_CDN_BASE_URL = "https://demos.aranova.io";
 var RETRY_MAX_MS = 5 * 6e4;
 
 // ../tracking-core/src/resources/blog/schema.ts
-var import_zod2 = require("zod");
+var z2 = __toESM(require("zod/mini"));
 
 // ../tracking-core/src/resources/blog/theme.ts
-var import_zod = require("zod");
+var z = __toESM(require("zod/mini"));
 var BLOG_BREAKPOINTS = ["sm", "md", "lg", "xl", "2xl", "3xl"];
 var BLOG_BREAKPOINT_MIN_WIDTHS_PX = {
   sm: 640,
@@ -111,40 +108,45 @@ var LENGTH = /^-?\d+(\.\d+)?(px|rem|em|%|ch|vw)$/;
 var LINE_HEIGHT = /^-?\d+(\.\d+)?(px|rem|em|%|ch|vw)?$/;
 var FONT_FAMILY_TOKEN = /^['"]?[a-zA-Z0-9 -]+['"]?$/;
 var FONT_FAMILY_VAR_TOKEN = /^var\(--[a-zA-Z0-9-]+\)$/;
-var colorValueSchema = import_zod.z.string().refine((v) => HEX_COLOR.test(v) || FUNCTIONAL_COLOR.test(v), {
-  message: "must be a #hex or rgb()/rgba()/hsl()/hsla()/oklch() color"
-});
-var lengthValueSchema = import_zod.z.string().regex(LENGTH, {
-  message: "must be a CSS length (px|rem|em|%|ch|vw)"
-});
-var lineHeightValueSchema = import_zod.z.string().regex(LINE_HEIGHT, {
-  message: "must be a CSS length or unitless line-height"
-});
-var fontWeightSchema = import_zod.z.number().int().min(100).max(1e3);
-var alignValueSchema = import_zod.z.enum(["left", "center", "right"]);
-var fontFamilySchema = import_zod.z.string().refine(
-  (v) => {
-    const tokens = v.split(",").map((t) => t.trim());
-    return tokens.length > 0 && tokens.every((t) => FONT_FAMILY_TOKEN.test(t) || FONT_FAMILY_VAR_TOKEN.test(t));
-  },
-  { message: "must be a comma-separated list of font-family or var(--custom-property) tokens" }
+var colorValueSchema = z.string().check(
+  z.refine((v) => HEX_COLOR.test(v) || FUNCTIONAL_COLOR.test(v), {
+    error: "must be a #hex or rgb()/rgba()/hsl()/hsla()/oklch() color"
+  })
+);
+var lengthValueSchema = z.string().check(z.regex(LENGTH, { error: "must be a CSS length (px|rem|em|%|ch|vw)" }));
+var lineHeightValueSchema = z.string().check(z.regex(LINE_HEIGHT, { error: "must be a CSS length or unitless line-height" }));
+var fontWeightSchema = z.int().check(z.gte(100), z.lte(1e3));
+var alignValueSchema = z.enum(["left", "center", "right"]);
+var fontFamilySchema = z.string().check(
+  z.refine(
+    (v) => {
+      const tokens = v.split(",").map((t) => t.trim());
+      return tokens.length > 0 && tokens.every((t) => FONT_FAMILY_TOKEN.test(t) || FONT_FAMILY_VAR_TOKEN.test(t));
+    },
+    { error: "must be a comma-separated list of font-family or var(--custom-property) tokens" }
+  )
 );
 function nullishField(schema) {
-  return schema.nullish().transform((v) => v ?? void 0);
+  return z.optional(
+    z.pipe(
+      z.nullish(schema),
+      z.transform((v) => v ?? void 0)
+    )
+  );
 }
 function breakpointMapSchema(valueSchema) {
-  return import_zod.z.object({
+  return z.object({
     base: valueSchema,
-    sm: nullishField(valueSchema).catch(void 0),
-    md: nullishField(valueSchema).catch(void 0),
-    lg: nullishField(valueSchema).catch(void 0),
-    xl: nullishField(valueSchema).catch(void 0),
-    "2xl": nullishField(valueSchema).catch(void 0),
-    "3xl": nullishField(valueSchema).catch(void 0)
+    sm: z.catch(nullishField(valueSchema), void 0),
+    md: z.catch(nullishField(valueSchema), void 0),
+    lg: z.catch(nullishField(valueSchema), void 0),
+    xl: z.catch(nullishField(valueSchema), void 0),
+    "2xl": z.catch(nullishField(valueSchema), void 0),
+    "3xl": z.catch(nullishField(valueSchema), void 0)
   });
 }
 function responsive(valueSchema) {
-  return import_zod.z.union([valueSchema, breakpointMapSchema(valueSchema)]);
+  return z.union([valueSchema, breakpointMapSchema(valueSchema)]);
 }
 var blogThemeColorsShape = {
   background: colorValueSchema,
@@ -158,14 +160,14 @@ var blogThemeColorsShape = {
   code_background: colorValueSchema,
   heading: colorValueSchema
 };
-var blogThemeColorsSchema = import_zod.z.object({
+var blogThemeColorsSchema = z.object({
   ...blogThemeColorsShape,
   // The ONE optional color in a resolved theme: when unset, headings fall back
   // to `text` in the stylesheet (`--_heading-color`), so `blogThemeToCssVars`
   // only emits `--ara-blog-color-heading` when a theme actually sets it.
   heading: nullishField(colorValueSchema)
 });
-var blogThemeTypographySchema = import_zod.z.object({
+var blogThemeTypographySchema = z.object({
   heading_family: fontFamilySchema,
   body_family: fontFamilySchema,
   heading_weight: fontWeightSchema,
@@ -184,17 +186,17 @@ var blogThemeTypographySchema = import_zod.z.object({
   // default center in the base CSS if unset.
   caption_align: alignValueSchema
 });
-var blogThemeSpacingSchema = import_zod.z.object({
+var blogThemeSpacingSchema = z.object({
   content_max_width: responsive(lengthValueSchema),
   block_gap: responsive(lengthValueSchema),
   section_gap: responsive(lengthValueSchema)
 });
-var blogThemeColorsPartialSchema = import_zod.z.object(
+var blogThemeColorsPartialSchema = z.object(
   Object.fromEntries(
     Object.keys(blogThemeColorsShape).map((key) => [key, nullishField(colorValueSchema)])
   )
 );
-var blogThemeSchema = import_zod.z.object({
+var blogThemeSchema = z.object({
   colors: blogThemeColorsSchema,
   colors_dark: nullishField(blogThemeColorsPartialSchema),
   typography: blogThemeTypographySchema,
@@ -204,23 +206,26 @@ var blogThemeSchema = import_zod.z.object({
 function dropInvalidFields(shape) {
   const out = {};
   for (const [key, schema] of Object.entries(shape)) {
-    out[key] = nullTolerant(schema).catch(void 0);
+    out[key] = z.catch(nullTolerant(schema), void 0);
   }
   return out;
 }
 function nullTolerant(schema) {
-  if (schema instanceof import_zod.z.ZodUnion) {
-    const options = schema.options;
-    return import_zod.z.union([...options, import_zod.z.null()]).optional().transform((v) => v ?? void 0);
+  if (schema instanceof z.ZodMiniUnion) {
+    const options = schema.def.options;
+    return z.pipe(
+      z.optional(z.union([...options, z.null()])),
+      z.transform((v) => v ?? void 0)
+    );
   }
   return nullishField(schema);
 }
-var blogThemeColorsOverrideSchema = import_zod.z.object(dropInvalidFields(blogThemeColorsShape));
-var blogThemeTypographyOverrideSchema = import_zod.z.object(
+var blogThemeColorsOverrideSchema = z.object(dropInvalidFields(blogThemeColorsShape));
+var blogThemeTypographyOverrideSchema = z.object(
   dropInvalidFields(blogThemeTypographySchema.shape)
 );
-var blogThemeSpacingOverrideSchema = import_zod.z.object(dropInvalidFields(blogThemeSpacingSchema.shape));
-var blogThemeOverrideSchema = import_zod.z.object(
+var blogThemeSpacingOverrideSchema = z.object(dropInvalidFields(blogThemeSpacingSchema.shape));
+var blogThemeOverrideSchema = z.object(
   dropInvalidFields({
     colors: blogThemeColorsOverrideSchema,
     colors_dark: blogThemeColorsOverrideSchema,
@@ -333,94 +338,112 @@ function blogThemeToCssVars(theme) {
 }
 
 // ../tracking-core/src/resources/blog/schema.ts
-var schemaVersionSchema = import_zod2.z.literal(1);
-var blogHeroImageSchema = import_zod2.z.object({
-  url: import_zod2.z.string(),
-  alt: import_zod2.z.string().catch(""),
-  width: import_zod2.z.number().int(),
-  height: import_zod2.z.number().int()
+var schemaVersionSchema = z2.literal(1);
+var blogHeroImageSchema = z2.object({
+  url: z2.string(),
+  alt: z2.catch(z2.string(), ""),
+  width: z2.int(),
+  height: z2.int()
 });
-var blogManifestEntrySchema = import_zod2.z.object({
-  slug: import_zod2.z.string(),
-  title: import_zod2.z.string(),
-  description: import_zod2.z.string().catch(""),
-  content_hash: import_zod2.z.string(),
-  content_key: import_zod2.z.string(),
-  published_at: import_zod2.z.string(),
-  updated_at: import_zod2.z.string(),
+var blogManifestEntrySchema = z2.object({
+  slug: z2.string(),
+  title: z2.string(),
+  description: z2.catch(z2.string(), ""),
+  content_hash: z2.string(),
+  content_key: z2.string(),
+  published_at: z2.string(),
+  updated_at: z2.string(),
   // Estimated read time in whole minutes (computed at publish from the post
   // body). 0 when unknown; index cards render "N min read".
-  reading_minutes: import_zod2.z.number().int().catch(0),
+  reading_minutes: z2.catch(z2.int(), 0),
   // A malformed tags array / hero_image degrades gracefully instead of
   // dropping the whole entry.
-  tags: import_zod2.z.array(import_zod2.z.string()).catch([]),
-  hero_image: blogHeroImageSchema.nullable().catch(null)
+  tags: z2.catch(z2.array(z2.string()), []),
+  hero_image: z2.catch(z2.nullable(blogHeroImageSchema), null)
 });
-var blogManifestWireSchema = import_zod2.z.object({
+var blogManifestWireSchema = z2.object({
   schema_version: schemaVersionSchema,
-  namespace: import_zod2.z.string(),
-  generated_at: import_zod2.z.string(),
-  posts: import_zod2.z.array(blogManifestEntrySchema).catch([])
+  namespace: z2.string(),
+  generated_at: z2.string(),
+  posts: z2.catch(z2.array(blogManifestEntrySchema), [])
 });
-var blogManifestSchema = blogManifestWireSchema.extend({
+var blogManifestSchema = z2.extend(blogManifestWireSchema, {
   // A single malformed entry is dropped; the rest of the manifest survives.
-  posts: import_zod2.z.array(blogManifestEntrySchema.nullable().catch(null)).transform((entries) => entries.filter((e) => e !== null)).catch([])
+  posts: z2.catch(
+    z2.pipe(
+      z2.array(z2.catch(z2.nullable(blogManifestEntrySchema), null)),
+      z2.transform((entries) => entries.filter((e) => e !== null))
+    ),
+    []
+  )
 });
-var blogImageSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  url: import_zod2.z.string(),
-  alt: import_zod2.z.string().catch(""),
-  caption: import_zod2.z.string().nullable().catch(null),
-  role: import_zod2.z.enum(["hero", "inline"]).catch("inline"),
-  width: import_zod2.z.number().int(),
-  height: import_zod2.z.number().int(),
-  mime: import_zod2.z.string().catch("")
+var blogImageSchema = z2.object({
+  id: z2.string(),
+  url: z2.string(),
+  alt: z2.catch(z2.string(), ""),
+  caption: z2.catch(z2.nullable(z2.string()), null),
+  role: z2.catch(z2.enum(["hero", "inline"]), "inline"),
+  width: z2.int(),
+  height: z2.int(),
+  mime: z2.catch(z2.string(), "")
 });
-var blogSeoSchema = import_zod2.z.object({
-  meta_title: import_zod2.z.string().catch(""),
-  meta_description: import_zod2.z.string().catch(""),
-  canonical_path: import_zod2.z.string().catch(""),
-  og_image: import_zod2.z.string().nullable().catch(null)
+var blogSeoSchema = z2.object({
+  meta_title: z2.catch(z2.string(), ""),
+  meta_description: z2.catch(z2.string(), ""),
+  canonical_path: z2.catch(z2.string(), ""),
+  og_image: z2.catch(z2.nullable(z2.string()), null)
 });
-var blogPostContentWireSchema = import_zod2.z.object({
+var blogPostContentWireSchema = z2.object({
   schema_version: schemaVersionSchema,
-  slug: import_zod2.z.string(),
-  title: import_zod2.z.string(),
-  description: import_zod2.z.string().catch(""),
-  mdx: import_zod2.z.string(),
-  images: import_zod2.z.array(blogImageSchema).catch([]),
+  slug: z2.string(),
+  title: z2.string(),
+  description: z2.catch(z2.string(), ""),
+  mdx: z2.string(),
+  images: z2.catch(z2.array(blogImageSchema), []),
   // Already schema-validated at publish time, but re-sanitized on read (and
   // again before rendering) — the override schema itself drops invalid values.
   // Nullish: the backend serializes an unset override as an explicit `null`
   // (Pydantic `model_dump()`); it folds into `undefined` for TS consumers.
-  theme_overrides: nullishField(blogThemeOverrideSchema).catch(void 0),
-  seo: blogSeoSchema.catch({
+  theme_overrides: z2.catch(nullishField(blogThemeOverrideSchema), void 0),
+  seo: z2.catch(blogSeoSchema, {
     meta_title: "",
     meta_description: "",
     canonical_path: "",
     og_image: null
   }),
-  jsonld: import_zod2.z.record(import_zod2.z.unknown()).catch({}),
-  published_at: import_zod2.z.string(),
+  jsonld: z2.catch(z2.record(z2.string(), z2.unknown()), {}),
+  published_at: z2.string(),
   // The applied_at of the version this content was published from; `null`
   // when the backend has no separate modified date. Nullish on the wire
   // (Pydantic `model_dump()` emits explicit `null`s), folded to `null` for a
   // single TS sentinel; a malformed value degrades to `null` instead of
   // dropping the post.
-  updated_at: import_zod2.z.string().nullish().transform((v) => v ?? null).catch(null),
-  version_number: import_zod2.z.number().int().catch(0),
-  content_hash: import_zod2.z.string()
+  updated_at: z2.catch(
+    z2.pipe(
+      z2.nullish(z2.string()),
+      z2.transform((v) => v ?? null)
+    ),
+    null
+  ),
+  version_number: z2.catch(z2.int(), 0),
+  content_hash: z2.string()
 });
-var blogPostContentSchema = blogPostContentWireSchema.extend({
+var blogPostContentSchema = z2.extend(blogPostContentWireSchema, {
   // A single malformed image record is dropped; the post survives.
-  images: import_zod2.z.array(blogImageSchema.nullable().catch(null)).transform((images) => images.filter((i) => i !== null)).catch([])
+  images: z2.catch(
+    z2.pipe(
+      z2.array(z2.catch(z2.nullable(blogImageSchema), null)),
+      z2.transform((images) => images.filter((i) => i !== null))
+    ),
+    []
+  )
 });
 function parseBlogManifest(raw) {
-  const parsed = blogManifestSchema.safeParse(raw);
+  const parsed = z2.safeParse(blogManifestSchema, raw);
   return parsed.success ? parsed.data : null;
 }
 function parseBlogPostContent(raw) {
-  const parsed = blogPostContentSchema.safeParse(raw);
+  const parsed = z2.safeParse(blogPostContentSchema, raw);
   return parsed.success ? parsed.data : null;
 }