@stndrds/schema 0.1.0-alpha.67 → 1.0.0-alpha.100

package/dist/chunk-H3VBSMVW.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var constants = require('@stndrds/constants');
+var zod = require('zod');
+var libphonenumberJs = require('libphonenumber-js');
+
+function digitsOnly(input) {
+  return input.replace(/\D/g, "");
+}
+function getIso2(iso3) {
+  const country = constants.getCountryByIso3(iso3);
+  return country?.iso2;
+}
+function normalizePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return "";
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) {
+    return digitsOnly(phoneNumber);
+  }
+  const parsed = libphonenumberJs.parsePhoneNumberFromString(phoneNumber, iso2);
+  if (parsed) {
+    return parsed.nationalNumber;
+  }
+  const country = constants.getCountryByIso3(countryIso3);
+  const digits = digitsOnly(phoneNumber);
+  if (country) {
+    const callingCode = country.phoneCode.replace("+", "");
+    const withoutCC = digits.startsWith(callingCode) ? digits.slice(callingCode.length) : digits;
+    return constants.stripTrunkPrefix(withoutCC, country.phoneTrunkPrefix ?? "");
+  }
+  return digits;
+}
+function validatePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return false;
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) return false;
+  const country = constants.getCountryByIso3(countryIso3);
+  if (!country) return false;
+  const trunkPrefix = country.phoneTrunkPrefix ?? "";
+  const digits = digitsOnly(phoneNumber);
+  const withTrunk = trunkPrefix + digits;
+  const parsed = libphonenumberJs.parsePhoneNumberFromString(withTrunk, iso2);
+  if (parsed?.isValid()) return true;
+  const parsedDirect = libphonenumberJs.parsePhoneNumberFromString(phoneNumber, iso2);
+  if (parsedDirect?.isValid()) return true;
+  const maxDigits = country.phoneMaxDigits ?? 15;
+  const expectedWithoutTrunk = maxDigits - trunkPrefix.length;
+  return digits.length === expectedWithoutTrunk || digits.length === maxDigits;
+}
+function formatPhoneForDisplay(phone) {
+  if (!phone.phoneNumber) return "";
+  const iso2 = getIso2(phone.countryCode);
+  const country = constants.getCountryByIso3(phone.countryCode);
+  const dial = country?.phoneCode ?? "";
+  if (!iso2) {
+    return `${dial} ${phone.phoneNumber}`.trim();
+  }
+  const e164 = `${dial}${digitsOnly(phone.phoneNumber)}`;
+  const parsed = libphonenumberJs.parsePhoneNumberFromString(e164);
+  if (parsed) {
+    return parsed.formatInternational();
+  }
+  return `${dial} ${phone.phoneNumber}`.trim();
+}
+function parseRawPhoneInput(rawInput, countryIso3) {
+  if (!rawInput || rawInput.trim() === "") {
+    return { success: false, error: "Phone number is empty" };
+  }
+  const normalized = normalizePhoneNumber(rawInput, countryIso3);
+  if (!normalized) {
+    return { success: false, error: "Could not extract digits from input" };
+  }
+  if (!validatePhoneNumber(normalized, countryIso3)) {
+    return { success: false, error: "Invalid phone number for country" };
+  }
+  return {
+    success: true,
+    phone: { countryCode: countryIso3, phoneNumber: normalized }
+  };
+}
+
+// src/validation/complex/phone.ts
+function createPhoneValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  return zod.z.object(
+    {
+      countryCode: zod.z.string().length(3),
+      phoneNumber: zod.z.string().min(1)
+    },
+    { message: messages.invalidPhone(attr) }
+  ).refine((val) => constants.isValidIso3(val.countryCode), {
+    message: "Invalid country code"
+  }).transform((val) => ({
+    countryCode: val.countryCode,
+    phoneNumber: normalizePhoneNumber(val.phoneNumber, val.countryCode)
+  })).refine((val) => validatePhoneNumber(val.phoneNumber, val.countryCode), {
+    message: messages.invalidPhone(attr)
+  });
+}
+
+exports.createPhoneValidator = createPhoneValidator;
+exports.formatPhoneForDisplay = formatPhoneForDisplay;
+exports.normalizePhoneNumber = normalizePhoneNumber;
+exports.parseRawPhoneInput = parseRawPhoneInput;
+exports.validatePhoneNumber = validatePhoneNumber;

package/dist/chunk-HJNLL34O.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createRichtextValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  return zod.z.string({
+    message: messages.invalidRichtext(attr)
+  });
+}
+
+exports.createRichtextValidator = createRichtextValidator;

package/dist/chunk-IMEPIVTR.js

@@ -0,0 +1,217 @@
+'use strict';
+
+var chunkBEN6TE7Y_js = require('./chunk-BEN6TE7Y.js');
+var zod = require('zod');
+
+var baseConfigSchema = zod.z.object({
+  disabled: zod.z.boolean().optional(),
+  placeholder: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  defaultValue: zod.z.unknown().optional(),
+  icon: zod.z.string().optional(),
+  order: zod.z.number().int().optional(),
+  hidden: zod.z.boolean().optional(),
+  archived: zod.z.boolean().optional(),
+  deprecated: zod.z.boolean().optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var optionSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  value: zod.z.string().min(1),
+  color: zod.z.string().optional(),
+  icon: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  group: zod.z.enum(["idle", "in_progress", "finished"]).optional(),
+  inverse: zod.z.string().optional()
+});
+var optionsArraySchema = zod.z.array(optionSchema).min(1).refine(
+  (options) => {
+    const values = options.map((o) => o.value);
+    return new Set(values).size === values.length;
+  },
+  { message: "Duplicate option values are not allowed" }
+);
+var relationTargetSchema = zod.z.object({
+  object: zod.z.string().min(1),
+  displayTemplate: zod.z.string().optional(),
+  filter: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var textConfigSchema = baseConfigSchema.extend({
+  minLength: zod.z.number().int().min(0).optional(),
+  maxLength: zod.z.number().int().min(1).optional(),
+  pattern: zod.z.string().optional()
+});
+var textareaConfigSchema = baseConfigSchema;
+var richtextConfigSchema = baseConfigSchema.extend({
+  features: zod.z.array(
+    zod.z.enum(["headings", "bold", "italic", "lists", "links", "images", "codeBlocks", "tables"])
+  ).optional()
+});
+var numberConfigSchema = baseConfigSchema.extend({
+  min: zod.z.number().optional(),
+  max: zod.z.number().optional(),
+  unit: zod.z.enum(["integer", "decimal", "percentage"]).optional(),
+  decimals: zod.z.number().int().min(0).optional()
+});
+var checkboxConfigSchema = baseConfigSchema;
+var dateConfigSchema = baseConfigSchema.extend({
+  dateFormat: zod.z.enum(["short", "long", "full", "relative"]).optional(),
+  minDate: zod.z.string().optional(),
+  maxDate: zod.z.string().optional()
+});
+var phoneConfigSchema = baseConfigSchema.extend({
+  defaultCountryCode: zod.z.string().length(3).optional()
+});
+var currencyConfigSchema = baseConfigSchema.extend({
+  defaultCurrency: zod.z.string().length(3).optional(),
+  allowedCurrencies: zod.z.array(zod.z.string().length(3)).optional()
+});
+var statusConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var locationConfigSchema = baseConfigSchema.extend({
+  granularity: zod.z.enum(["full", "address", "city", "state", "country", "coordinates"]),
+  enableAutocomplete: zod.z.boolean().optional(),
+  enableMap: zod.z.boolean().optional(),
+  defaultCountry: zod.z.string().length(3).optional(),
+  allowedCountries: zod.z.array(zod.z.string().length(3)).optional(),
+  displayFormat: zod.z.enum(["single_line", "multi_line", "compact"]).optional()
+});
+var selectConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var multiselectConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var fileConfigSchema = baseConfigSchema.extend({
+  maxFiles: zod.z.number().int().min(1).optional(),
+  maxSize: zod.z.number().int().min(1).optional(),
+  allowedTypes: zod.z.array(zod.z.string()).optional(),
+  multiple: zod.z.boolean().optional()
+});
+var userConfigSchema = baseConfigSchema.extend({
+  allowedRoles: zod.z.array(zod.z.string()).optional(),
+  multiple: zod.z.boolean().optional()
+});
+var relationConfigSchema = baseConfigSchema.extend({
+  targets: zod.z.array(relationTargetSchema).min(1),
+  cardinality: zod.z.enum(["one", "many"]),
+  minItems: zod.z.number().int().min(0).optional(),
+  maxItems: zod.z.number().int().min(1).optional()
+});
+var ratingConfigSchema = baseConfigSchema.extend({
+  max: zod.z.number().int().min(1).optional(),
+  iconType: zod.z.enum(["star", "heart", "thumbs", "number"]).optional()
+});
+var formulaConfigSchema = baseConfigSchema.extend({
+  expression: zod.z.string().min(1),
+  returnType: zod.z.enum(["text", "number", "boolean", "date"]),
+  decimals: zod.z.number().int().min(0).max(10).optional(),
+  allowRelations: zod.z.boolean().optional()
+});
+var rollupConfigSchema = baseConfigSchema.extend({
+  relationAttribute: zod.z.string().min(1).optional(),
+  relationPath: zod.z.string().optional(),
+  targetAttribute: zod.z.string().min(1),
+  function: zod.z.enum([
+    "sum",
+    "avg",
+    "earliest",
+    "latest",
+    "count",
+    "countValues",
+    "countUniqueValues",
+    "countEmpty",
+    "percentEmpty",
+    "percentNotEmpty",
+    "original"
+  ]),
+  decimals: zod.z.number().int().min(0).max(10).optional(),
+  targetAttributeType: zod.z.string().optional(),
+  targetAttributeOptions: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      label: zod.z.string(),
+      value: zod.z.string(),
+      color: zod.z.string().optional(),
+      icon: zod.z.string().optional(),
+      description: zod.z.string().optional(),
+      group: zod.z.enum(["idle", "in_progress", "finished"]).optional()
+    })
+  ).optional()
+});
+var documentConfigSchema = baseConfigSchema.extend({
+  multiple: zod.z.boolean().optional(),
+  maxDocuments: zod.z.number().int().min(1).optional(),
+  autoProcess: zod.z.boolean().optional()
+});
+var attributeConfigSchemas = {
+  text: textConfigSchema,
+  textarea: textareaConfigSchema,
+  richtext: richtextConfigSchema,
+  number: numberConfigSchema,
+  checkbox: checkboxConfigSchema,
+  date: dateConfigSchema,
+  phone: phoneConfigSchema,
+  currency: currencyConfigSchema,
+  status: statusConfigSchema,
+  location: locationConfigSchema,
+  select: selectConfigSchema,
+  multiselect: multiselectConfigSchema,
+  file: fileConfigSchema,
+  user: userConfigSchema,
+  relation: relationConfigSchema,
+  rating: ratingConfigSchema,
+  formula: formulaConfigSchema,
+  rollup: rollupConfigSchema,
+  document: documentConfigSchema
+};
+function getAttributeConfigSchema(type) {
+  return attributeConfigSchemas[type];
+}
+function validateAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  const result = schema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: chunkBEN6TE7Y_js.formatZodErrors(result.error).map((err) => `${err.path.join(".")}: ${err.message}`)
+  };
+}
+function parseAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  return schema.strip().parse(config);
+}
+function safeParseAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  const result = schema.strip().safeParse(config);
+  return result.success ? result.data : void 0;
+}
+
+exports.attributeConfigSchemas = attributeConfigSchemas;
+exports.checkboxConfigSchema = checkboxConfigSchema;
+exports.currencyConfigSchema = currencyConfigSchema;
+exports.dateConfigSchema = dateConfigSchema;
+exports.documentConfigSchema = documentConfigSchema;
+exports.fileConfigSchema = fileConfigSchema;
+exports.formulaConfigSchema = formulaConfigSchema;
+exports.getAttributeConfigSchema = getAttributeConfigSchema;
+exports.locationConfigSchema = locationConfigSchema;
+exports.multiselectConfigSchema = multiselectConfigSchema;
+exports.numberConfigSchema = numberConfigSchema;
+exports.parseAttributeConfig = parseAttributeConfig;
+exports.phoneConfigSchema = phoneConfigSchema;
+exports.ratingConfigSchema = ratingConfigSchema;
+exports.relationConfigSchema = relationConfigSchema;
+exports.richtextConfigSchema = richtextConfigSchema;
+exports.rollupConfigSchema = rollupConfigSchema;
+exports.safeParseAttributeConfig = safeParseAttributeConfig;
+exports.selectConfigSchema = selectConfigSchema;
+exports.statusConfigSchema = statusConfigSchema;
+exports.textConfigSchema = textConfigSchema;
+exports.textareaConfigSchema = textareaConfigSchema;
+exports.userConfigSchema = userConfigSchema;
+exports.validateAttributeConfig = validateAttributeConfig;

package/dist/chunk-JEDANRCG.mjs

@@ -0,0 +1,74 @@
+// src/validation/core/messages.ts
+var DEFAULT_VALIDATION_MESSAGES = {
+  required: (attr) => `${attr.label} is required`,
+  invalidType: (attr, expected) => `${attr.label} must be a ${expected}`,
+  minLength: (attr, min) => `${attr.label} must be at least ${min} characters`,
+  maxLength: (attr, max) => `${attr.label} must be at most ${max} characters`,
+  invalidPattern: (attr) => `${attr.label} format is invalid`,
+  minValue: (attr, min) => `${attr.label} must be at least ${min}`,
+  maxValue: (attr, max) => `${attr.label} must be at most ${max}`,
+  mustBeInteger: (attr) => `${attr.label} must be an integer`,
+  invalidDate: (attr) => `${attr.label} must be a valid date`,
+  invalidOption: (attr, options) => `${attr.label} must be one of: ${options.join(", ")}`,
+  invalidId: (attr) => `${attr.label} must be a valid ID`,
+  minItems: (attr, min) => `${attr.label} must have at least ${min} item${min > 1 ? "s" : ""}`,
+  maxItems: (attr, max) => `${attr.label} must have at most ${max} item${max > 1 ? "s" : ""}`,
+  invalidRichtext: (attr) => `${attr.label} must be valid rich text content`,
+  invalidPhone: (attr) => `${attr.label} must be a valid phone number`,
+  invalidCurrency: (attr) => `${attr.label} must be a valid currency value`,
+  invalidLocation: (attr) => `${attr.label} must be a valid location`
+};
+
+// src/lib/lru-cache.ts
+var LRUCache = class {
+  constructor(capacity) {
+    if (capacity <= 0) {
+      throw new Error("LRU cache capacity must be greater than 0");
+    }
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+
+// src/validation/core/regex-cache.ts
+function createRegexCache(capacity = 100) {
+  return new LRUCache(capacity);
+}
+function getCachedRegex(cache, pattern) {
+  let cached = cache.get(pattern);
+  if (!cached) {
+    cached = new RegExp(pattern);
+    cache.set(pattern, cached);
+  }
+  return cached;
+}
+
+export { DEFAULT_VALIDATION_MESSAGES, createRegexCache, getCachedRegex };

package/dist/chunk-KC2FFNL4.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createUserValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const uuidSchema = zod.z.uuid({
+    message: messages.invalidId(attr)
+  });
+  if (attr.multiple) {
+    return zod.z.array(uuidSchema);
+  }
+  return uuidSchema;
+}
+
+exports.createUserValidator = createUserValidator;

package/dist/chunk-OO2LJ6GP.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var chunk5SQEKHPW_js = require('./chunk-5SQEKHPW.js');
+var zod = require('zod');
+
+function createSelectValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const validValues = attr.options.map((opt) => opt.value);
+  const validLabels = attr.options.map((opt) => opt.label);
+  return zod.z.enum(validValues, {
+    message: messages.invalidOption(attr, validLabels)
+  });
+}
+function createMultiselectValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const validValues = attr.options.map((opt) => opt.value);
+  const validLabels = attr.options.map((opt) => opt.label);
+  return zod.z.array(
+    zod.z.enum(validValues, {
+      message: messages.invalidOption(attr, validLabels)
+    })
+  );
+}
+function createStatusValidator(attr, messages = chunk5SQEKHPW_js.DEFAULT_VALIDATION_MESSAGES) {
+  const validValues = attr.options.map((opt) => opt.value);
+  const validLabels = attr.options.map((opt) => opt.label);
+  return zod.z.enum(validValues, {
+    message: messages.invalidOption(attr, validLabels)
+  });
+}
+
+exports.createMultiselectValidator = createMultiselectValidator;
+exports.createSelectValidator = createSelectValidator;
+exports.createStatusValidator = createStatusValidator;

package/dist/chunk-P4NGPF5L.mjs

@@ -0,0 +1,99 @@
+import { DEFAULT_VALIDATION_MESSAGES } from './chunk-JEDANRCG.mjs';
+import { getCountryByIso3, stripTrunkPrefix, isValidIso3 } from '@stndrds/constants';
+import { z } from 'zod';
+import { parsePhoneNumberFromString } from 'libphonenumber-js';
+
+function digitsOnly(input) {
+  return input.replace(/\D/g, "");
+}
+function getIso2(iso3) {
+  const country = getCountryByIso3(iso3);
+  return country?.iso2;
+}
+function normalizePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return "";
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) {
+    return digitsOnly(phoneNumber);
+  }
+  const parsed = parsePhoneNumberFromString(phoneNumber, iso2);
+  if (parsed) {
+    return parsed.nationalNumber;
+  }
+  const country = getCountryByIso3(countryIso3);
+  const digits = digitsOnly(phoneNumber);
+  if (country) {
+    const callingCode = country.phoneCode.replace("+", "");
+    const withoutCC = digits.startsWith(callingCode) ? digits.slice(callingCode.length) : digits;
+    return stripTrunkPrefix(withoutCC, country.phoneTrunkPrefix ?? "");
+  }
+  return digits;
+}
+function validatePhoneNumber(phoneNumber, countryIso3) {
+  if (!phoneNumber) return false;
+  const iso2 = getIso2(countryIso3);
+  if (!iso2) return false;
+  const country = getCountryByIso3(countryIso3);
+  if (!country) return false;
+  const trunkPrefix = country.phoneTrunkPrefix ?? "";
+  const digits = digitsOnly(phoneNumber);
+  const withTrunk = trunkPrefix + digits;
+  const parsed = parsePhoneNumberFromString(withTrunk, iso2);
+  if (parsed?.isValid()) return true;
+  const parsedDirect = parsePhoneNumberFromString(phoneNumber, iso2);
+  if (parsedDirect?.isValid()) return true;
+  const maxDigits = country.phoneMaxDigits ?? 15;
+  const expectedWithoutTrunk = maxDigits - trunkPrefix.length;
+  return digits.length === expectedWithoutTrunk || digits.length === maxDigits;
+}
+function formatPhoneForDisplay(phone) {
+  if (!phone.phoneNumber) return "";
+  const iso2 = getIso2(phone.countryCode);
+  const country = getCountryByIso3(phone.countryCode);
+  const dial = country?.phoneCode ?? "";
+  if (!iso2) {
+    return `${dial} ${phone.phoneNumber}`.trim();
+  }
+  const e164 = `${dial}${digitsOnly(phone.phoneNumber)}`;
+  const parsed = parsePhoneNumberFromString(e164);
+  if (parsed) {
+    return parsed.formatInternational();
+  }
+  return `${dial} ${phone.phoneNumber}`.trim();
+}
+function parseRawPhoneInput(rawInput, countryIso3) {
+  if (!rawInput || rawInput.trim() === "") {
+    return { success: false, error: "Phone number is empty" };
+  }
+  const normalized = normalizePhoneNumber(rawInput, countryIso3);
+  if (!normalized) {
+    return { success: false, error: "Could not extract digits from input" };
+  }
+  if (!validatePhoneNumber(normalized, countryIso3)) {
+    return { success: false, error: "Invalid phone number for country" };
+  }
+  return {
+    success: true,
+    phone: { countryCode: countryIso3, phoneNumber: normalized }
+  };
+}
+
+// src/validation/complex/phone.ts
+function createPhoneValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
+  return z.object(
+    {
+      countryCode: z.string().length(3),
+      phoneNumber: z.string().min(1)
+    },
+    { message: messages.invalidPhone(attr) }
+  ).refine((val) => isValidIso3(val.countryCode), {
+    message: "Invalid country code"
+  }).transform((val) => ({
+    countryCode: val.countryCode,
+    phoneNumber: normalizePhoneNumber(val.phoneNumber, val.countryCode)
+  })).refine((val) => validatePhoneNumber(val.phoneNumber, val.countryCode), {
+    message: messages.invalidPhone(attr)
+  });
+}
+
+export { createPhoneValidator, formatPhoneForDisplay, normalizePhoneNumber, parseRawPhoneInput, validatePhoneNumber };