@formspec/build 0.1.0-alpha.10 → 0.1.0-alpha.11

package/dist/browser.d.ts

@@ -20,9 +20,11 @@ import { generateJsonSchema } from "./json-schema/generator.js";
 import { generateUiSchema } from "./ui-schema/generator.js";
 export type { JSONSchema7, JSONSchemaType, ExtendedJSONSchema7, FormSpecSchemaExtensions, } from "./json-schema/types.js";
 export { setSchemaExtension, getSchemaExtension } from "./json-schema/types.js";
-export type { UISchema, UISchemaElement, UISchemaElementBase, UISchemaElementType, ControlElement, VerticalLayout, HorizontalLayout, GroupLayout, Rule, RuleEffect, RuleConditionSchema, SchemaBasedCondition, } from "./ui-schema/types.js";
+export type { UISchema, UISchemaElement, UISchemaElementBase, UISchemaElementType, ControlElement, VerticalLayout, HorizontalLayout, GroupLayout, Categorization, Category, LabelElement, Rule, RuleEffect, RuleConditionSchema, SchemaBasedCondition, } from "./ui-schema/types.js";
+export { ruleEffectSchema, uiSchemaElementTypeSchema, ruleConditionSchema, schemaBasedConditionSchema, ruleSchema, controlSchema, verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema, categorySchema, labelElementSchema, uiSchemaElementSchema, uiSchema as uiSchemaSchema, } from "./ui-schema/schema.js";
+export { jsonSchemaTypeSchema, jsonSchema7Schema } from "./json-schema/schema.js";
 export { generateJsonSchema } from "./json-schema/generator.js";
-export { generateUiSchema } from "./ui-schema/generator.js";
+export { generateUiSchema, generateUiSchemaFromFields } from "./ui-schema/generator.js";
 /**
  * Result of building form schemas.
  */

package/dist/browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D,YAAY,EACV,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEhF,YAAY,EACV,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,IAAI,EACJ,UAAU,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC3D,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAKjG"}
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D,YAAY,EACV,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEhF,YAAY,EACV,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,mBAAmB,EACnB,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,IAAI,cAAc,GAC3B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAExF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC3D,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAKjG"}

package/dist/browser.js

@@ -1,48 +1,501 @@
-/**
- * Browser-safe exports for `@formspec/build`.
- *
- * This entry point excludes Node.js-specific functions like `writeSchemas`
- * that use `node:fs` and `node:path`, making it suitable for browser environments.
- *
- * @example
- * ```typescript
- * // In browser code (e.g., playground)
- * import { buildFormSchemas, generateJsonSchema, generateUiSchema } from "@formspec/build/browser";
- *
- * const form = formspec(field.text("name"));
- * const { jsonSchema, uiSchema } = buildFormSchemas(form);
- * ```
- *
- * @packageDocumentation
- */
-import { generateJsonSchema } from "./json-schema/generator.js";
-import { generateUiSchema } from "./ui-schema/generator.js";
-export { setSchemaExtension, getSchemaExtension } from "./json-schema/types.js";
-// Re-export individual generators
-export { generateJsonSchema } from "./json-schema/generator.js";
-export { generateUiSchema } from "./ui-schema/generator.js";
-/**
- * Builds both JSON Schema and UI Schema from a FormSpec.
- *
- * This is a browser-safe version that does not include file system operations.
- *
- * @example
- * ```typescript
- * const form = formspec(
- *   field.text("name", { required: true }),
- *   field.number("age", { min: 0 }),
- * );
- *
- * const { jsonSchema, uiSchema } = buildFormSchemas(form);
- * ```
- *
- * @param form - The FormSpec to build schemas from
- * @returns Object containing both jsonSchema and uiSchema
- */
-export function buildFormSchemas(form) {
-    return {
-        jsonSchema: generateJsonSchema(form),
-        uiSchema: generateUiSchema(form),
+// src/json-schema/schema.ts
+import { z } from "zod";
+var jsonSchemaTypeSchema = z.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+var jsonSchema7Schema = z.lazy(
+  () => z.object({
+    $schema: z.string().optional(),
+    $id: z.string().optional(),
+    $ref: z.string().optional(),
+    // Metadata
+    title: z.string().optional(),
+    description: z.string().optional(),
+    deprecated: z.boolean().optional(),
+    // Type
+    type: z.union([jsonSchemaTypeSchema, z.array(jsonSchemaTypeSchema)]).optional(),
+    // String validation
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    pattern: z.string().optional(),
+    // Number validation
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    exclusiveMinimum: z.number().optional(),
+    exclusiveMaximum: z.number().optional(),
+    // Enum
+    enum: z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])).readonly().optional(),
+    const: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
+    // Object
+    properties: z.record(z.string(), jsonSchema7Schema).optional(),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.union([z.boolean(), jsonSchema7Schema]).optional(),
+    // Array
+    items: z.union([jsonSchema7Schema, z.array(jsonSchema7Schema)]).optional(),
+    minItems: z.number().optional(),
+    maxItems: z.number().optional(),
+    // Composition
+    allOf: z.array(jsonSchema7Schema).optional(),
+    anyOf: z.array(jsonSchema7Schema).optional(),
+    oneOf: z.array(jsonSchema7Schema).optional(),
+    not: jsonSchema7Schema.optional(),
+    // Conditional
+    if: jsonSchema7Schema.optional(),
+    then: jsonSchema7Schema.optional(),
+    else: jsonSchema7Schema.optional(),
+    // Format
+    format: z.string().optional(),
+    // Default
+    default: z.unknown().optional(),
+    // FormSpec extensions
+    "x-formspec-source": z.string().optional(),
+    "x-formspec-params": z.array(z.string()).readonly().optional(),
+    "x-formspec-schemaSource": z.string().optional()
+  }).passthrough()
+);
+
+// src/json-schema/generator.ts
+import { z as z2 } from "zod";
+function parseOrThrow(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof z2.ZodError) {
+      throw new Error(
+        `Generated ${label} failed validation:
+${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+      );
+    }
+    throw error;
+  }
+}
+function generateNestedSchema(elements) {
+  const properties = {};
+  const required = [];
+  collectFields(elements, properties, required);
+  const uniqueRequired = [...new Set(required)];
+  return {
+    type: "object",
+    properties,
+    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+  };
+}
+function fieldToJsonSchema(field) {
+  const base = {};
+  if (field.label !== void 0) {
+    base.title = field.label;
+  }
+  switch (field._field) {
+    case "text":
+      return { ...base, type: "string" };
+    case "number":
+      return {
+        ...base,
+        type: "number",
+        ...field.min !== void 0 && { minimum: field.min },
+        ...field.max !== void 0 && { maximum: field.max }
+      };
+    case "boolean":
+      return { ...base, type: "boolean" };
+    case "enum": {
+      const opts = field.options;
+      const isObjectOptions = opts.length > 0 && opts.every(
+        (opt) => typeof opt === "object" && "id" in opt && "label" in opt
+      );
+      if (isObjectOptions) {
+        return {
+          ...base,
+          type: "string",
+          oneOf: opts.map((o) => ({
+            const: o.id,
+            title: o.label
+          }))
+        };
+      }
+      return { ...base, type: "string", enum: opts };
+    }
+    case "dynamic_enum":
+      return {
+        ...base,
+        type: "string",
+        "x-formspec-source": field.source,
+        ...field.params !== void 0 && field.params.length > 0 && { "x-formspec-params": field.params }
+      };
+    case "dynamic_schema":
+      return {
+        ...base,
+        type: "object",
+        additionalProperties: true,
+        "x-formspec-schemaSource": field.schemaSource
+      };
+    case "array": {
+      const arrayField = field;
+      return {
+        ...base,
+        type: "array",
+        items: generateNestedSchema(arrayField.items),
+        ...arrayField.minItems !== void 0 && { minItems: arrayField.minItems },
+        ...arrayField.maxItems !== void 0 && { maxItems: arrayField.maxItems }
+      };
+    }
+    case "object": {
+      const objectField = field;
+      const nestedSchema = generateNestedSchema(objectField.properties);
+      return {
+        ...base,
+        ...nestedSchema
+      };
+    }
+    default: {
+      const _exhaustive = field;
+      return _exhaustive;
+    }
+  }
+}
+function collectFields(elements, properties, required) {
+  for (const element of elements) {
+    switch (element._type) {
+      case "field":
+        properties[element.name] = fieldToJsonSchema(element);
+        if (element.required === true) {
+          required.push(element.name);
+        }
+        break;
+      case "group":
+        collectFields(element.elements, properties, required);
+        break;
+      case "conditional":
+        collectFields(
+          element.elements,
+          properties,
+          required
+        );
+        break;
+    }
+  }
+}
+function generateJsonSchema(form) {
+  const properties = {};
+  const required = [];
+  collectFields(form.elements, properties, required);
+  const uniqueRequired = [...new Set(required)];
+  const result = {
+    $schema: "https://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties,
+    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+  };
+  return parseOrThrow(jsonSchema7Schema, result, "JSON Schema");
+}
+
+// src/ui-schema/schema.ts
+import { z as z3 } from "zod";
+var jsonPointerSchema = z3.string();
+var ruleEffectSchema = z3.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+var uiSchemaElementTypeSchema = z3.enum([
+  "Control",
+  "VerticalLayout",
+  "HorizontalLayout",
+  "Group",
+  "Categorization",
+  "Category",
+  "Label"
+]);
+var ruleConditionSchema = z3.lazy(
+  () => z3.object({
+    const: z3.unknown().optional(),
+    enum: z3.array(z3.unknown()).readonly().optional(),
+    type: z3.string().optional(),
+    not: ruleConditionSchema.optional(),
+    minimum: z3.number().optional(),
+    maximum: z3.number().optional(),
+    exclusiveMinimum: z3.number().optional(),
+    exclusiveMaximum: z3.number().optional(),
+    minLength: z3.number().optional(),
+    properties: z3.record(z3.string(), ruleConditionSchema).optional(),
+    required: z3.array(z3.string()).optional(),
+    allOf: z3.array(ruleConditionSchema).optional()
+  }).strict()
+);
+var schemaBasedConditionSchema = z3.object({
+  scope: jsonPointerSchema,
+  schema: ruleConditionSchema
+}).strict();
+var ruleSchema = z3.object({
+  effect: ruleEffectSchema,
+  condition: schemaBasedConditionSchema
+}).strict();
+var uiSchemaElementSchema = z3.lazy(
+  () => z3.union([
+    controlSchema,
+    verticalLayoutSchema,
+    horizontalLayoutSchema,
+    groupLayoutSchema,
+    categorizationSchema,
+    categorySchema,
+    labelElementSchema
+  ])
+);
+var controlSchema = z3.object({
+  type: z3.literal("Control"),
+  scope: jsonPointerSchema,
+  label: z3.union([z3.string(), z3.literal(false)]).optional(),
+  rule: ruleSchema.optional(),
+  options: z3.record(z3.string(), z3.unknown()).optional()
+}).passthrough();
+var verticalLayoutSchema = z3.lazy(
+  () => z3.object({
+    type: z3.literal("VerticalLayout"),
+    elements: z3.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z3.record(z3.string(), z3.unknown()).optional()
+  }).passthrough()
+);
+var horizontalLayoutSchema = z3.lazy(
+  () => z3.object({
+    type: z3.literal("HorizontalLayout"),
+    elements: z3.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z3.record(z3.string(), z3.unknown()).optional()
+  }).passthrough()
+);
+var groupLayoutSchema = z3.lazy(
+  () => z3.object({
+    type: z3.literal("Group"),
+    label: z3.string(),
+    elements: z3.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z3.record(z3.string(), z3.unknown()).optional()
+  }).passthrough()
+);
+var categorySchema = z3.lazy(
+  () => z3.object({
+    type: z3.literal("Category"),
+    label: z3.string(),
+    elements: z3.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z3.record(z3.string(), z3.unknown()).optional()
+  }).passthrough()
+);
+var categorizationSchema = z3.lazy(
+  () => z3.object({
+    type: z3.literal("Categorization"),
+    elements: z3.array(categorySchema),
+    label: z3.string().optional(),
+    rule: ruleSchema.optional(),
+    options: z3.record(z3.string(), z3.unknown()).optional()
+  }).passthrough()
+);
+var labelElementSchema = z3.object({
+  type: z3.literal("Label"),
+  text: z3.string(),
+  rule: ruleSchema.optional(),
+  options: z3.record(z3.string(), z3.unknown()).optional()
+}).passthrough();
+var uiSchema = z3.lazy(
+  () => z3.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+);
+
+// src/ui-schema/generator.ts
+import { z as z4 } from "zod";
+function parseOrThrow2(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof z4.ZodError) {
+      throw new Error(
+        `Generated ${label} failed validation:
+${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+      );
+    }
+    throw error;
+  }
+}
+function fieldToScope(fieldName) {
+  return `#/properties/${fieldName}`;
+}
+function createShowRule(fieldName, value) {
+  return {
+    effect: "SHOW",
+    condition: {
+      scope: fieldToScope(fieldName),
+      schema: { const: value }
+    }
+  };
+}
+function combineRules(parentRule, childRule) {
+  const parentCondition = parentRule.condition;
+  const childCondition = childRule.condition;
+  return {
+    effect: "SHOW",
+    condition: {
+      scope: "#",
+      schema: {
+        allOf: [
+          {
+            properties: {
+              [parentCondition.scope.replace("#/properties/", "")]: parentCondition.schema
+            }
+          },
+          {
+            properties: {
+              [childCondition.scope.replace("#/properties/", "")]: childCondition.schema
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+function elementsToUiSchema(elements, parentRule) {
+  const result = [];
+  for (const element of elements) {
+    switch (element._type) {
+      case "field": {
+        const control = {
+          type: "Control",
+          scope: fieldToScope(element.name),
+          ...element.label !== void 0 && { label: element.label },
+          ...parentRule !== void 0 && { rule: parentRule }
+        };
+        result.push(control);
+        break;
+      }
+      case "group": {
+        const groupElement = element;
+        const group = {
+          type: "Group",
+          label: groupElement.label,
+          elements: elementsToUiSchema(groupElement.elements, parentRule),
+          ...parentRule !== void 0 && { rule: parentRule }
+        };
+        result.push(group);
+        break;
+      }
+      case "conditional": {
+        const conditionalElement = element;
+        const newRule = createShowRule(conditionalElement.field, conditionalElement.value);
+        const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
+        const childElements = elementsToUiSchema(conditionalElement.elements, combinedRule);
+        result.push(...childElements);
+        break;
+      }
+    }
+  }
+  return result;
+}
+function formSpecFieldToElement(field, scopePrefix = "#/properties") {
+  const control = {
+    type: "Control",
+    scope: `${scopePrefix}/${field.id}`
+  };
+  if (field.label !== void 0) {
+    control.label = field.label;
+  }
+  if (field.showWhen !== void 0 && typeof field.showWhen === "object" && "field" in field.showWhen && "value" in field.showWhen) {
+    const sw = field.showWhen;
+    control.rule = {
+      effect: "SHOW",
+      condition: {
+        scope: `#/properties/${sw.field}`,
+        schema: { const: sw.value }
+      }
     };
+  }
+  return control;
+}
+function generateUiSchemaFromFields(fields) {
+  const groupMap = /* @__PURE__ */ new Map();
+  const orderedKeys = [];
+  const ungrouped = [];
+  for (const field of fields) {
+    const element = formSpecFieldToElement(field);
+    if (field.group !== void 0) {
+      if (!groupMap.has(field.group)) {
+        groupMap.set(field.group, []);
+        orderedKeys.push(field.group);
+      }
+      groupMap.get(field.group).push(element);
+    } else {
+      orderedKeys.push(null);
+      ungrouped.push(element);
+    }
+  }
+  const elements = [];
+  let ungroupedIndex = 0;
+  for (const key of orderedKeys) {
+    if (key === null) {
+      const el = ungrouped[ungroupedIndex++];
+      if (el !== void 0) {
+        elements.push(el);
+      }
+    } else {
+      const groupElements = groupMap.get(key) ?? [];
+      const groupLayout = {
+        type: "Group",
+        label: key,
+        elements: groupElements
+      };
+      elements.push(groupLayout);
+    }
+  }
+  const result = {
+    type: "VerticalLayout",
+    elements
+  };
+  return parseOrThrow2(uiSchema, result, "UI Schema");
+}
+function generateUiSchema(form) {
+  const result = {
+    type: "VerticalLayout",
+    elements: elementsToUiSchema(form.elements)
+  };
+  return parseOrThrow2(uiSchema, result, "UI Schema");
+}
+
+// src/json-schema/types.ts
+function setSchemaExtension(schema, key, value) {
+  schema[key] = value;
+}
+function getSchemaExtension(schema, key) {
+  return schema[key];
+}
+
+// src/browser.ts
+function buildFormSchemas(form) {
+  return {
+    jsonSchema: generateJsonSchema(form),
+    uiSchema: generateUiSchema(form)
+  };
 }
+export {
+  buildFormSchemas,
+  categorizationSchema,
+  categorySchema,
+  controlSchema,
+  generateJsonSchema,
+  generateUiSchema,
+  generateUiSchemaFromFields,
+  getSchemaExtension,
+  groupLayoutSchema,
+  horizontalLayoutSchema,
+  jsonSchema7Schema,
+  jsonSchemaTypeSchema,
+  labelElementSchema,
+  ruleConditionSchema,
+  ruleEffectSchema,
+  ruleSchema,
+  schemaBasedConditionSchema,
+  setSchemaExtension,
+  uiSchemaElementSchema,
+  uiSchemaElementTypeSchema,
+  uiSchema as uiSchemaSchema,
+  verticalLayoutSchema
+};
 //# sourceMappingURL=browser.js.map