@ember-home/unbound-styleguide 0.0.14 → 0.0.16

package/dist/chunk-TQJLZ37G.js

@@ -0,0 +1,429 @@
+// src/@styleguide/forms/schema/define-form-schema.ts
+function defineFormSchema() {
+  return function define(config) {
+    const sortedFields = [...config.fields].sort((a, b) => {
+      const orderA = a.ui?.order ?? Number.MAX_SAFE_INTEGER;
+      const orderB = b.ui?.order ?? Number.MAX_SAFE_INTEGER;
+      return orderA - orderB;
+    });
+    const sortedSections = config.sections ? [...config.sections].sort((a, b) => {
+      const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+      const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+      return orderA - orderB;
+    }) : void 0;
+    return {
+      fields: sortedFields,
+      sections: sortedSections,
+      crossFieldValidation: config.crossFieldValidation
+    };
+  };
+}
+function field() {
+  return function defineField(name, kind, config) {
+    return {
+      name,
+      kind,
+      ...config
+    };
+  };
+}
+function textField() {
+  return function defineTextField(name, config) {
+    return { name, kind: "text", ...config };
+  };
+}
+function selectField() {
+  return function defineSelectField(name, options, config) {
+    return {
+      name,
+      kind: "select",
+      ...config,
+      ui: { ...config?.ui, options }
+    };
+  };
+}
+function checkboxField() {
+  return function defineCheckboxField(name, config) {
+    return { name, kind: "checkbox", ...config };
+  };
+}
+function arrayField() {
+  return function defineArrayField(name, itemSchema, config) {
+    const { config: arrayConfig, ...rest } = config ?? {};
+    return {
+      name,
+      kind: "array",
+      arrayItemSchema: itemSchema,
+      arrayConfig,
+      ...rest
+    };
+  };
+}
+function getFieldsForSection(schema, sectionId) {
+  return schema.fields.filter((field2) => field2.ui?.section === sectionId);
+}
+function getUnsectionedFields(schema) {
+  return schema.fields.filter((field2) => !field2.ui?.section);
+}
+function getFieldByName(schema, name) {
+  return schema.fields.find((field2) => field2.name === name);
+}
+function getArrayItemFieldByName(schema, name) {
+  const normalizedName = name.replace(/\.\d+\./g, ".0.");
+  for (const field2 of schema.fields) {
+    if (field2.kind === "array" && field2.arrayItemSchema) {
+      const match = field2.arrayItemSchema.find(
+        (item) => item.name === normalizedName
+      );
+      if (match) {
+        return { ...match, name };
+      }
+    }
+  }
+  return void 0;
+}
+function buildDefaultValues(schema) {
+  const defaults = {};
+  for (const field2 of schema.fields) {
+    if (field2.defaultValue !== void 0) {
+      setNestedValue(defaults, field2.name, field2.defaultValue);
+    }
+  }
+  return defaults;
+}
+function isArrayIndex(key) {
+  return /^\d+$/.test(key);
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const nextKey = keys[i + 1];
+    const nextNeedsArray = isArrayIndex(nextKey);
+    if (isArrayIndex(key)) {
+      const index = parseInt(key, 10);
+      const arr = current;
+      while (arr.length <= index) {
+        arr.push(void 0);
+      }
+      if (arr[index] === void 0 || typeof arr[index] !== "object") {
+        arr[index] = nextNeedsArray ? [] : {};
+      }
+      current = arr[index];
+    } else {
+      const record = current;
+      if (!(key in record) || typeof record[key] !== "object" || record[key] === null) {
+        record[key] = nextNeedsArray ? [] : {};
+      }
+      current = record[key];
+    }
+  }
+  const finalKey = keys[keys.length - 1];
+  if (isArrayIndex(finalKey)) {
+    const arr = current;
+    const index = parseInt(finalKey, 10);
+    while (arr.length <= index) {
+      arr.push(void 0);
+    }
+    arr[index] = value;
+  } else {
+    current[finalKey] = value;
+  }
+}
+function mergeSchemas(base, override) {
+  const fieldMap = new Map(base.fields.map((f) => [f.name, f]));
+  if (override.fields) {
+    for (const field2 of override.fields) {
+      fieldMap.set(field2.name, field2);
+    }
+  }
+  const sectionMap = new Map(
+    (base.sections ?? []).map((s) => [s.id, s])
+  );
+  if (override.sections) {
+    for (const section of override.sections) {
+      sectionMap.set(section.id, section);
+    }
+  }
+  const crossFieldRules = [
+    ...base.crossFieldValidation ?? [],
+    ...override.crossFieldValidation ?? []
+  ];
+  return {
+    fields: Array.from(fieldMap.values()),
+    sections: sectionMap.size > 0 ? Array.from(sectionMap.values()) : void 0,
+    crossFieldValidation: crossFieldRules.length > 0 ? crossFieldRules : void 0
+  };
+}
+
+// src/@styleguide/forms/server/server-schema-validator.ts
+import { z } from "zod";
+var validationRuleWithMessage = z.union([
+  z.number(),
+  z.object({
+    value: z.number(),
+    message: z.string()
+  })
+]);
+var patternRule = z.union([
+  z.string(),
+  z.object({
+    value: z.string(),
+    message: z.string()
+  })
+]);
+var serverFieldValidationSchema = z.object({
+  required: z.union([z.boolean(), z.string()]).optional(),
+  min: validationRuleWithMessage.optional(),
+  max: validationRuleWithMessage.optional(),
+  minLength: validationRuleWithMessage.optional(),
+  maxLength: validationRuleWithMessage.optional(),
+  pattern: patternRule.optional(),
+  asyncValidatorUrl: z.string().optional(),
+  asyncDebounceMs: z.number().optional()
+}).optional();
+var fieldOptionSchema = z.object({
+  value: z.string(),
+  label: z.string(),
+  disabled: z.boolean().optional()
+});
+var serverFieldUISchema = z.object({
+  label: z.string().optional(),
+  placeholder: z.string().optional(),
+  description: z.string().optional(),
+  tooltip: z.string().optional(),
+  order: z.number().optional(),
+  section: z.string().optional(),
+  width: z.enum(["full", "half", "third", "quarter"]).optional(),
+  className: z.string().optional(),
+  options: z.array(fieldOptionSchema).optional(),
+  allowCreate: z.boolean().optional(),
+  searchable: z.boolean().optional(),
+  inputType: z.string().optional(),
+  autoCapitalize: z.string().optional(),
+  autoComplete: z.string().optional(),
+  maxRows: z.number().optional(),
+  minRows: z.number().optional()
+}).optional();
+var serverFieldVisibilitySchema = z.object({
+  dependsOn: z.array(z.string()).optional(),
+  showWhen: z.record(z.string(), z.unknown()).optional(),
+  hideWhen: z.record(z.string(), z.unknown()).optional(),
+  requiredWhen: z.record(z.string(), z.unknown()).optional(),
+  disabledWhen: z.record(z.string(), z.unknown()).optional()
+}).optional();
+var arrayConfigSchema = z.object({
+  minItems: z.number().optional(),
+  maxItems: z.number().optional(),
+  defaultItem: z.record(z.string(), z.unknown()).optional(),
+  allowReorder: z.boolean().optional(),
+  addButtonLabel: z.string().optional(),
+  removeButtonLabel: z.string().optional(),
+  showItemNumber: z.boolean().optional(),
+  itemHeaderTemplate: z.string().optional(),
+  removeConfirmMessage: z.string().optional(),
+  collapsible: z.boolean().optional(),
+  defaultCollapsed: z.boolean().optional()
+}).optional();
+var baseServerFieldSchema = z.object({
+  name: z.string().min(1, "Field name is required"),
+  kind: z.string().min(1, "Field kind is required"),
+  ui: serverFieldUISchema,
+  validation: serverFieldValidationSchema,
+  visibility: serverFieldVisibilitySchema,
+  defaultValue: z.unknown().optional(),
+  readOnly: z.boolean().optional(),
+  arrayConfig: arrayConfigSchema,
+  meta: z.record(z.string(), z.unknown()).optional()
+});
+var serverFieldSchema = baseServerFieldSchema.extend({
+  arrayItemSchema: z.lazy(() => z.array(serverFieldSchema)).optional()
+});
+var sectionSchema = z.object({
+  id: z.string().min(1, "Section id is required"),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  collapsible: z.boolean().optional(),
+  defaultCollapsed: z.boolean().optional(),
+  order: z.number().optional()
+});
+var serverFormSchema = z.object({
+  fields: z.array(serverFieldSchema).min(1, "At least one field is required"),
+  sections: z.array(sectionSchema).optional()
+});
+function validateServerSchema(data) {
+  const result = serverFormSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const issues = result.error.issues.map((issue) => {
+    const path = issue.path.join(".");
+    return `  - ${path || "root"}: ${issue.message}`;
+  });
+  const message = `Invalid server schema:
+${issues.join("\n")}`;
+  return {
+    success: false,
+    error: result.error,
+    message
+  };
+}
+function assertServerSchema(data) {
+  const result = validateServerSchema(data);
+  if (!result.success) {
+    throw new Error(result.message);
+  }
+}
+
+// src/@styleguide/forms/server/fetchServerSchema.ts
+function parseServerField(serverField) {
+  const field2 = {
+    name: serverField.name,
+    kind: serverField.kind
+  };
+  if (serverField.ui) {
+    field2.ui = { ...serverField.ui };
+  }
+  if (serverField.defaultValue !== void 0) {
+    field2.defaultValue = serverField.defaultValue;
+  }
+  if (serverField.readOnly !== void 0) {
+    field2.readOnly = serverField.readOnly;
+  }
+  if (serverField.meta) {
+    field2.meta = serverField.meta;
+  }
+  if (serverField.validation) {
+    const validation = serverField.validation;
+    field2.validation = {};
+    if (validation.required !== void 0) {
+      field2.validation.required = validation.required;
+    }
+    if (validation.min !== void 0) {
+      field2.validation.min = validation.min;
+    }
+    if (validation.max !== void 0) {
+      field2.validation.max = validation.max;
+    }
+    if (validation.minLength !== void 0) {
+      field2.validation.minLength = validation.minLength;
+    }
+    if (validation.maxLength !== void 0) {
+      field2.validation.maxLength = validation.maxLength;
+    }
+    if (validation.pattern !== void 0) {
+      try {
+        if (typeof validation.pattern === "string") {
+          field2.validation.pattern = new RegExp(validation.pattern);
+        } else if (typeof validation.pattern === "object") {
+          field2.validation.pattern = {
+            value: new RegExp(validation.pattern.value),
+            message: validation.pattern.message
+          };
+        }
+      } catch (error) {
+        console.error(
+          `Invalid regex pattern for field "${serverField.name}": ${typeof validation.pattern === "string" ? validation.pattern : validation.pattern.value}`
+        );
+      }
+    }
+    if (validation.asyncValidatorUrl) {
+      field2.validation.asyncValidatorUrl = validation.asyncValidatorUrl;
+    }
+    if (validation.asyncDebounceMs !== void 0) {
+      field2.validation.asyncDebounceMs = validation.asyncDebounceMs;
+    }
+  }
+  if (serverField.visibility) {
+    const visibility = serverField.visibility;
+    field2.visibility = {
+      dependsOn: visibility.dependsOn,
+      showWhen: visibility.showWhen,
+      hideWhen: visibility.hideWhen,
+      requiredWhen: visibility.requiredWhen,
+      disabledWhen: visibility.disabledWhen
+    };
+  }
+  if (serverField.arrayItemSchema) {
+    field2.arrayItemSchema = serverField.arrayItemSchema.map(
+      (item) => parseServerField(item)
+    );
+  }
+  if (serverField.arrayConfig) {
+    field2.arrayConfig = serverField.arrayConfig;
+  }
+  return field2;
+}
+function parseServerSchema(serverSchema, options) {
+  if (options?.strict) {
+    const validationResult = validateServerSchema(serverSchema);
+    if (!validationResult.success) {
+      throw new Error(validationResult.message);
+    }
+  }
+  return {
+    fields: serverSchema.fields.map((field2) => parseServerField(field2)),
+    sections: serverSchema.sections
+  };
+}
+function parseServerSchemaSafe(data) {
+  const validationResult = validateServerSchema(data);
+  if (!validationResult.success) {
+    return {
+      success: false,
+      error: validationResult
+    };
+  }
+  const schema = parseServerSchema(
+    validationResult.data
+  );
+  return { success: true, schema };
+}
+async function fetchServerSchema(url, options) {
+  const response = await fetch(url, {
+    ...options?.fetchOptions,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.fetchOptions?.headers
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to load schema: ${response.status}`);
+  }
+  let data = await response.json();
+  if (options?.transformResponse) {
+    data = options.transformResponse(data);
+  }
+  const serverSchema = parseServerSchema(data);
+  return options?.baseSchema ? mergeSchemas(options.baseSchema, serverSchema) : serverSchema;
+}
+function buildSchemaResponse(schema) {
+  return {
+    fields: schema.fields,
+    sections: schema.sections
+  };
+}
+
+export {
+  defineFormSchema,
+  field,
+  textField,
+  selectField,
+  checkboxField,
+  arrayField,
+  getFieldsForSection,
+  getUnsectionedFields,
+  getFieldByName,
+  getArrayItemFieldByName,
+  buildDefaultValues,
+  mergeSchemas,
+  serverFieldSchema,
+  serverFormSchema,
+  validateServerSchema,
+  assertServerSchema,
+  parseServerSchema,
+  parseServerSchemaSafe,
+  fetchServerSchema,
+  buildSchemaResponse
+};