@lucania/schema 1.0.0 → 1.0.2

package/build/index.d.ts

@@ -64,7 +64,7 @@ export declare namespace Schema {
     function registerPrimitive<TypeName extends keyof Map>(typeName: TypeName): void;
     function isSchemaPrimitive(value: any): value is Schema.Primitive;
     function isSchemaOrCompound(value: any): value is Schema.OrCompound;
-    function isSchemaAndCompound(value: any): value is Schema.OrCompound;
+    function isSchemaAndCompound(value: any): value is Schema.AndCompound;
     function isSchemaMeta(value: any): value is Schema.Meta;
     function isSchemaDynamic(value: any): value is Schema.Dynamic;
     function isSchemaArray(value: any): value is Schema.Array;
@@ -73,6 +73,7 @@ export declare namespace Schema {
     function getType(value: any): string;
     function build<Schema extends Schema.Any>(schema: Schema): Schema;
     function validate<Schema extends Any>(schema: Schema, source: Source<Schema>): Model<Schema>;
+    function clone<Schema extends Schema.Any>(schema: Schema): Schema;
     function assert(condition: boolean, message?: string): asserts condition;
     type ValidationErrorType = "missing" | "incorrectType" | "invalidSchema" | "failedCustomValidator";
     class Error extends globalThis.Error {

package/build/index.js

@@ -218,6 +218,49 @@
                 return new ValidationError("invalidSchema", schema, source, path, originalSchema, originalSource);
             }
         }
+        function clone(schema) {
+            if (isSchemaPrimitive(schema)) {
+                return schema;
+            }
+            else if (isSchemaOrCompound(schema)) {
+                const [a, _, b] = schema;
+                return [clone(a), "or", clone(b)];
+            }
+            else if (isSchemaAndCompound(schema)) {
+                const [a, _, b] = schema;
+                return [clone(a), "and", clone(b)];
+            }
+            else if (isSchemaMeta(schema)) {
+                const meta = {
+                    type: clone(schema.type),
+                    required: schema.required,
+                };
+                if ("default" in schema) {
+                    meta.default = schema.default;
+                }
+                if ("validate" in schema) {
+                    meta.validate = schema.validate;
+                }
+                return meta;
+            }
+            else if (isSchemaDynamic(schema)) {
+                return { $: clone(schema.$) };
+            }
+            else if (isSchemaArray(schema)) {
+                return [schema.map(clone)];
+            }
+            else if (isSchemaHierarchy(schema)) {
+                const hierarchy = {};
+                for (const key in schema) {
+                    hierarchy[key] = clone(schema[key]);
+                }
+                return hierarchy;
+            }
+            else {
+                throw new Error("Invalid Schema.");
+            }
+        }
+        Schema.clone = clone;
         function assert(condition, message) {
             if (!condition) {
                 throw new Schema.Error(message);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lucania/schema",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -37,4 +37,4 @@
         "tslib": "^2.6.0",
         "typescript": "^5.1.6"
     }
-}
+}