poe-code 3.0.187 → 3.0.189

package/packages/cmdkit-schema/dist/index.js

@@ -1,175 +0,0 @@
-function withMetadata(schema, jsonSchema) {
-    if (schema.description !== undefined) {
-        jsonSchema.description = schema.description;
-    }
-    if (schema.default !== undefined) {
-        jsonSchema.default = schema.default;
-    }
-    if (schema.nullable === true) {
-        jsonSchema.nullable = true;
-    }
-    return jsonSchema;
-}
-function withStringMetadata(schema, jsonSchema) {
-    if (schema.minLength !== undefined) {
-        jsonSchema.minLength = schema.minLength;
-    }
-    if (schema.maxLength !== undefined) {
-        jsonSchema.maxLength = schema.maxLength;
-    }
-    if (schema.pattern !== undefined) {
-        jsonSchema.pattern = schema.pattern;
-    }
-    if (schema.format !== undefined) {
-        jsonSchema.format = schema.format;
-    }
-    return withMetadata(schema, jsonSchema);
-}
-function withNumberMetadata(schema, jsonSchema) {
-    if (schema.minimum !== undefined) {
-        jsonSchema.minimum = schema.minimum;
-    }
-    if (schema.maximum !== undefined) {
-        jsonSchema.maximum = schema.maximum;
-    }
-    return withMetadata(schema, jsonSchema);
-}
-function withArrayMetadata(schema, jsonSchema) {
-    if (schema.minItems !== undefined) {
-        jsonSchema.minItems = schema.minItems;
-    }
-    if (schema.maxItems !== undefined) {
-        jsonSchema.maxItems = schema.maxItems;
-    }
-    return withMetadata(schema, jsonSchema);
-}
-function withObjectMetadata(schema, jsonSchema) {
-    if (schema.additionalProperties !== undefined) {
-        jsonSchema.additionalProperties = schema.additionalProperties;
-    }
-    return withMetadata(schema, jsonSchema);
-}
-function getEnumJsonType(values) {
-    const [firstValue] = values;
-    if (firstValue === undefined) {
-        return undefined;
-    }
-    const firstType = typeof firstValue;
-    const isSinglePrimitiveType = values.every((value) => typeof value === firstType);
-    if (!isSinglePrimitiveType) {
-        return undefined;
-    }
-    if (firstType === "string" || firstType === "number" || firstType === "boolean") {
-        return firstType;
-    }
-    return undefined;
-}
-function isOptionalSchema(schema) {
-    return schema.kind === "optional";
-}
-function assertValidEnumValues(values) {
-    if (values.length === 0) {
-        throw new Error("Enum schema requires at least one value");
-    }
-    const uniqueValues = new Set(values);
-    if (uniqueValues.size !== values.length) {
-        throw new Error("Enum schema values must be unique");
-    }
-}
-function unwrapOptional(schema) {
-    if (isOptionalSchema(schema)) {
-        return unwrapOptional(schema.inner);
-    }
-    return schema;
-}
-export const S = {
-    String(options = {}) {
-        return {
-            kind: "string",
-            ...options,
-        };
-    },
-    Number(options = {}) {
-        return {
-            kind: "number",
-            ...options,
-        };
-    },
-    Boolean(options = {}) {
-        return {
-            kind: "boolean",
-            ...options,
-        };
-    },
-    Enum(values, options = {}) {
-        assertValidEnumValues(values);
-        return {
-            kind: "enum",
-            values,
-            ...options,
-        };
-    },
-    Array(item, options = {}) {
-        return {
-            kind: "array",
-            item,
-            ...options,
-        };
-    },
-    Object(shape, options = {}) {
-        return {
-            kind: "object",
-            shape,
-            ...options,
-        };
-    },
-    Optional(inner) {
-        return {
-            kind: "optional",
-            inner,
-        };
-    },
-};
-export function toJsonSchema(schema) {
-    const unwrappedSchema = unwrapOptional(schema);
-    switch (unwrappedSchema.kind) {
-        case "string":
-            return withStringMetadata(unwrappedSchema, { type: "string" });
-        case "number":
-            return withNumberMetadata(unwrappedSchema, { type: unwrappedSchema.jsonType ?? "number" });
-        case "boolean":
-            return withMetadata(unwrappedSchema, { type: "boolean" });
-        case "enum": {
-            const jsonSchema = {
-                enum: unwrappedSchema.nullable === true
-                    ? [...unwrappedSchema.values, null]
-                    : [...unwrappedSchema.values],
-            };
-            const enumType = unwrappedSchema.jsonType ?? getEnumJsonType(unwrappedSchema.values);
-            if (enumType !== undefined) {
-                jsonSchema.type = enumType;
-            }
-            return withMetadata(unwrappedSchema, jsonSchema);
-        }
-        case "array":
-            return withArrayMetadata(unwrappedSchema, {
-                type: "array",
-                items: toJsonSchema(unwrappedSchema.item),
-            });
-        case "object": {
-            const properties = {};
-            const required = [];
-            for (const [key, propertySchema] of Object.entries(unwrappedSchema.shape)) {
-                properties[key] = toJsonSchema(propertySchema);
-                if (!isOptionalSchema(propertySchema)) {
-                    required.push(key);
-                }
-            }
-            return withObjectMetadata(unwrappedSchema, {
-                type: "object",
-                properties,
-                required,
-            });
-        }
-    }
-}