@wener/utils 1.1.27 → 1.1.29

package/lib/schema/typebox/gen/codegen/expression/expression.js

@@ -1,200 +1,384 @@
-var Expression;
-((Expression2) => {
-  function And(expressions, options = {}) {
-    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];
-    if (expr.length === 0)
-      return Expression2.False();
-    if (expr.length === 1)
-      return expr[0];
-    return { ...options, type: "And", expr };
-  }
-  Expression2.And = And;
-  function Call(target, parameters, expression, options = {}) {
-    return { ...options, type: "Call", target, parameters, expr: expression };
-  }
-  Expression2.Call = Call;
-  function Equals(value, options = {}) {
-    return { ...options, type: "Equals", value };
-  }
-  Expression2.Equals = Equals;
-  function Function(callback, options = {}) {
-    return { ...options, type: "Function", callback };
-  }
-  Expression2.Function = Function;
-  function ElementsDistinct(options = {}) {
-    return { ...options, type: "ElementsDistinct" };
-  }
-  Expression2.ElementsDistinct = ElementsDistinct;
-  function Elements(expression, options = {}) {
-    return { ...options, type: "Elements", expr: expression };
-  }
-  Expression2.Elements = Elements;
-  function False(options = {}) {
-    return { ...options, type: "False" };
-  }
-  Expression2.False = False;
-  function GreaterThanEqual(value, options = {}) {
-    return { ...options, type: "GreaterThanEqual", value };
-  }
-  Expression2.GreaterThanEqual = GreaterThanEqual;
-  function GreaterThan(value, options = {}) {
-    return { ...options, type: "GreaterThan", value };
-  }
-  Expression2.GreaterThan = GreaterThan;
-  function IfThenElse($if, $then, $else, options = {}) {
-    return { ...options, type: "IfThenElse", if: $if, then: $then, else: $else };
-  }
-  Expression2.IfThenElse = IfThenElse;
-  function Index(index, expression, options = {}) {
-    return { ...options, type: "Index", index, expr: expression };
-  }
-  Expression2.Index = Index;
-  function InstanceOf(value, options = {}) {
-    return { ...options, type: "InstanceOf", value };
-  }
-  Expression2.InstanceOf = InstanceOf;
-  function IsArray(options = {}) {
-    return { ...options, type: "IsArray" };
-  }
-  Expression2.IsArray = IsArray;
-  function IsNaN(options = {}) {
-    return { ...options, type: "IsNaN" };
-  }
-  Expression2.IsNaN = IsNaN;
-  function IsInteger(options = {}) {
-    return { ...options, type: "IsInteger" };
-  }
-  Expression2.IsInteger = IsInteger;
-  function IsObject(options = {}) {
-    return Expression2.TypeOf("object", options);
-  }
-  Expression2.IsObject = IsObject;
-  function IsBigInt(options = {}) {
-    return Expression2.TypeOf("bigint", options);
-  }
-  Expression2.IsBigInt = IsBigInt;
-  function IsBoolean(options = {}) {
-    return Expression2.TypeOf("boolean", options);
-  }
-  Expression2.IsBoolean = IsBoolean;
-  function IsFinite(options = {}) {
-    return { ...options, type: "IsFinite" };
-  }
-  Expression2.IsFinite = IsFinite;
-  function IsFunction(options = {}) {
-    return Expression2.TypeOf("function", options);
-  }
-  Expression2.IsFunction = IsFunction;
-  function IsNumber(options = {}) {
-    return Expression2.TypeOf("number", options);
-  }
-  Expression2.IsNumber = IsNumber;
-  function IsSafeInteger(options = {}) {
-    return { ...options, type: "IsSafeInteger" };
-  }
-  Expression2.IsSafeInteger = IsSafeInteger;
-  function IsString(options = {}) {
-    return Expression2.TypeOf("string", options);
-  }
-  Expression2.IsString = IsString;
-  function IsSymbol(options = {}) {
-    return Expression2.TypeOf("symbol", options);
-  }
-  Expression2.IsSymbol = IsSymbol;
-  function IsUndefined(options = {}) {
-    return { ...options, type: "IsUndefined" };
-  }
-  Expression2.IsUndefined = IsUndefined;
-  function IsNull(options = {}) {
-    return Expression2.Equals(null, options);
-  }
-  Expression2.IsNull = IsNull;
-  function IsPattern(pattern, options = {}) {
-    return { ...options, type: "IsPattern", pattern };
-  }
-  Expression2.IsPattern = IsPattern;
-  function KeyIn(value, options = {}) {
-    return { ...options, type: "KeyIn", value };
-  }
-  Expression2.KeyIn = KeyIn;
-  function LessThanEqual(value, options = {}) {
-    return { ...options, type: "LessThanEqual", value };
-  }
-  Expression2.LessThanEqual = LessThanEqual;
-  function LessThan(value, options = {}) {
-    return { ...options, type: "LessThan", value };
-  }
-  Expression2.LessThan = LessThan;
-  function MultipleOf(value, options = {}) {
-    return { ...options, type: "MultipleOf", value };
-  }
-  Expression2.MultipleOf = MultipleOf;
-  function Not(expression, options = {}) {
-    return { ...options, type: "Not", expr: expression };
-  }
-  Expression2.Not = Not;
-  function Or(expressions, options = {}) {
-    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];
-    if (expr.length === 0)
-      return Expression2.False();
-    if (expr.length === 1)
-      return expr[0];
-    return { ...options, type: "Or", expr };
-  }
-  Expression2.Or = Or;
-  function PropertiesExcludePattern(pattern, expression, options = {}) {
-    return { ...options, type: "PropertiesExcludePattern", expr: expression, pattern };
-  }
-  Expression2.PropertiesExcludePattern = PropertiesExcludePattern;
-  function PropertiesExclude(keys, expression, options = {}) {
-    return { ...options, type: "PropertiesExclude", expr: expression, keys };
-  }
-  Expression2.PropertiesExclude = PropertiesExclude;
-  function PropertiesIncludePattern(pattern, expression, options = {}) {
-    return { ...options, type: "PropertiesIncludePattern", expr: expression, pattern };
-  }
-  Expression2.PropertiesIncludePattern = PropertiesIncludePattern;
-  function PropertiesInclude(keys, expression, options = {}) {
-    return { ...options, type: "PropertiesInclude", expr: expression, keys };
-  }
-  Expression2.PropertiesInclude = PropertiesInclude;
-  function PropertiesLength(value, options = {}) {
-    return { ...options, type: "PropertiesLength", value };
-  }
-  Expression2.PropertiesLength = PropertiesLength;
-  function PropertiesMaximum(value, options = {}) {
-    return { ...options, type: "PropertiesMaximum", value };
-  }
-  Expression2.PropertiesMaximum = PropertiesMaximum;
-  function PropertiesMinimum(value, options = {}) {
-    return { ...options, type: "PropertiesMinimum", value };
-  }
-  Expression2.PropertiesMinimum = PropertiesMinimum;
-  function Properties(expression, options = {}) {
-    return { ...options, type: "Properties", expr: expression };
-  }
-  Expression2.Properties = Properties;
-  function PropertyKeys(keys, options = {}) {
-    return { ...options, type: "PropertyKeys", keys };
-  }
-  Expression2.PropertyKeys = PropertyKeys;
-  function Property(key, expression, options = {}) {
-    return { ...options, type: "Property", key, expr: expression };
-  }
-  Expression2.Property = Property;
-  function Ref(value, options = {}) {
-    return { ...options, type: "Ref", $ref: value };
-  }
-  Expression2.Ref = Ref;
-  function True(options = {}) {
-    return { ...options, type: "True" };
-  }
-  Expression2.True = True;
-  function TypeOf(value, options = {}) {
-    return { ...options, type: "TypeOf", value };
-  }
-  Expression2.TypeOf = TypeOf;
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox-expression
+
+The MIT License (MIT)
+
+Copyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/ // -------------------------------------------------------------------------
+// Expression: Error
+// -------------------------------------------------------------------------
+// ---------------------------------------------------------------
+// Expression: Builder
+// ---------------------------------------------------------------
+/** Type Expressions builder used to assert JavaScript values */ export var Expression;
+(function(Expression1) {
+    function And(expressions, options = {}) {
+        const expr = globalThis.Array.isArray(expressions) ? expressions : [
+            ...expressions()
+        ];
+        if (expr.length === 0) return Expression.False();
+        if (expr.length === 1) return expr[0];
+        return {
+            ...options,
+            type: 'And',
+            expr
+        };
+    }
+    Expression1.And = And;
+    function Call(target, parameters, expression, options = {}) {
+        return {
+            ...options,
+            type: 'Call',
+            target,
+            parameters,
+            expr: expression
+        };
+    }
+    Expression1.Call = Call;
+    function Equals(value, options = {}) {
+        return {
+            ...options,
+            type: 'Equals',
+            value
+        };
+    }
+    Expression1.Equals = Equals;
+    function Function(callback, options = {}) {
+        return {
+            ...options,
+            type: 'Function',
+            callback
+        };
+    }
+    Expression1.Function = Function;
+    function ElementsDistinct(options = {}) {
+        return {
+            ...options,
+            type: 'ElementsDistinct'
+        };
+    }
+    Expression1.ElementsDistinct = ElementsDistinct;
+    function Elements(expression, options = {}) {
+        return {
+            ...options,
+            type: 'Elements',
+            expr: expression
+        };
+    }
+    Expression1.Elements = Elements;
+    function False(options = {}) {
+        return {
+            ...options,
+            type: 'False'
+        };
+    }
+    Expression1.False = False;
+    function GreaterThanEqual(value, options = {}) {
+        return {
+            ...options,
+            type: 'GreaterThanEqual',
+            value
+        };
+    }
+    Expression1.GreaterThanEqual = GreaterThanEqual;
+    function GreaterThan(value, options = {}) {
+        return {
+            ...options,
+            type: 'GreaterThan',
+            value
+        };
+    }
+    Expression1.GreaterThan = GreaterThan;
+    function IfThenElse($if, $then, $else, options = {}) {
+        return {
+            ...options,
+            type: 'IfThenElse',
+            if: $if,
+            then: $then,
+            else: $else
+        };
+    }
+    Expression1.IfThenElse = IfThenElse;
+    function Index(index, expression, options = {}) {
+        return {
+            ...options,
+            type: 'Index',
+            index,
+            expr: expression
+        };
+    }
+    Expression1.Index = Index;
+    function InstanceOf(value, options = {}) {
+        return {
+            ...options,
+            type: 'InstanceOf',
+            value
+        };
+    }
+    Expression1.InstanceOf = InstanceOf;
+    function IsArray(options = {}) {
+        return {
+            ...options,
+            type: 'IsArray'
+        };
+    }
+    Expression1.IsArray = IsArray;
+    function IsNaN(options = {}) {
+        return {
+            ...options,
+            type: 'IsNaN'
+        };
+    }
+    Expression1.IsNaN = IsNaN;
+    function IsInteger(options = {}) {
+        return {
+            ...options,
+            type: 'IsInteger'
+        };
+    }
+    Expression1.IsInteger = IsInteger;
+    function IsObject(options = {}) {
+        return Expression.TypeOf('object', options);
+    }
+    Expression1.IsObject = IsObject;
+    function IsBigInt(options = {}) {
+        return Expression.TypeOf('bigint', options);
+    }
+    Expression1.IsBigInt = IsBigInt;
+    function IsBoolean(options = {}) {
+        return Expression.TypeOf('boolean', options);
+    }
+    Expression1.IsBoolean = IsBoolean;
+    function IsFinite(options = {}) {
+        return {
+            ...options,
+            type: 'IsFinite'
+        };
+    }
+    Expression1.IsFinite = IsFinite;
+    function IsFunction(options = {}) {
+        return Expression.TypeOf('function', options);
+    }
+    Expression1.IsFunction = IsFunction;
+    function IsNumber(options = {}) {
+        return Expression.TypeOf('number', options);
+    }
+    Expression1.IsNumber = IsNumber;
+    function IsSafeInteger(options = {}) {
+        return {
+            ...options,
+            type: 'IsSafeInteger'
+        };
+    }
+    Expression1.IsSafeInteger = IsSafeInteger;
+    function IsString(options = {}) {
+        return Expression.TypeOf('string', options);
+    }
+    Expression1.IsString = IsString;
+    function IsSymbol(options = {}) {
+        return Expression.TypeOf('symbol', options);
+    }
+    Expression1.IsSymbol = IsSymbol;
+    function IsUndefined(options = {}) {
+        return {
+            ...options,
+            type: 'IsUndefined'
+        };
+    }
+    Expression1.IsUndefined = IsUndefined;
+    function IsNull(options = {}) {
+        return Expression.Equals(null, options);
+    }
+    Expression1.IsNull = IsNull;
+    function IsPattern(pattern, options = {}) {
+        return {
+            ...options,
+            type: 'IsPattern',
+            pattern
+        };
+    }
+    Expression1.IsPattern = IsPattern;
+    function KeyIn(value, options = {}) {
+        return {
+            ...options,
+            type: 'KeyIn',
+            value
+        };
+    }
+    Expression1.KeyIn = KeyIn;
+    function LessThanEqual(value, options = {}) {
+        return {
+            ...options,
+            type: 'LessThanEqual',
+            value
+        };
+    }
+    Expression1.LessThanEqual = LessThanEqual;
+    function LessThan(value, options = {}) {
+        return {
+            ...options,
+            type: 'LessThan',
+            value
+        };
+    }
+    Expression1.LessThan = LessThan;
+    function MultipleOf(value, options = {}) {
+        return {
+            ...options,
+            type: 'MultipleOf',
+            value
+        };
+    }
+    Expression1.MultipleOf = MultipleOf;
+    function Not(expression, options = {}) {
+        return {
+            ...options,
+            type: 'Not',
+            expr: expression
+        };
+    }
+    Expression1.Not = Not;
+    function Or(expressions, options = {}) {
+        const expr = globalThis.Array.isArray(expressions) ? expressions : [
+            ...expressions()
+        ];
+        if (expr.length === 0) return Expression.False();
+        if (expr.length === 1) return expr[0];
+        return {
+            ...options,
+            type: 'Or',
+            expr
+        };
+    }
+    Expression1.Or = Or;
+    function PropertiesExcludePattern(pattern, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesExcludePattern',
+            expr: expression,
+            pattern
+        };
+    }
+    Expression1.PropertiesExcludePattern = PropertiesExcludePattern;
+    function PropertiesExclude(keys, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesExclude',
+            expr: expression,
+            keys
+        };
+    }
+    Expression1.PropertiesExclude = PropertiesExclude;
+    function PropertiesIncludePattern(pattern, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesIncludePattern',
+            expr: expression,
+            pattern
+        };
+    }
+    Expression1.PropertiesIncludePattern = PropertiesIncludePattern;
+    function PropertiesInclude(keys, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesInclude',
+            expr: expression,
+            keys
+        };
+    }
+    Expression1.PropertiesInclude = PropertiesInclude;
+    function PropertiesLength(value, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesLength',
+            value
+        };
+    }
+    Expression1.PropertiesLength = PropertiesLength;
+    function PropertiesMaximum(value, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesMaximum',
+            value
+        };
+    }
+    Expression1.PropertiesMaximum = PropertiesMaximum;
+    function PropertiesMinimum(value, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesMinimum',
+            value
+        };
+    }
+    Expression1.PropertiesMinimum = PropertiesMinimum;
+    function Properties(expression, options = {}) {
+        return {
+            ...options,
+            type: 'Properties',
+            expr: expression
+        };
+    }
+    Expression1.Properties = Properties;
+    function PropertyKeys(keys, options = {}) {
+        return {
+            ...options,
+            type: 'PropertyKeys',
+            keys
+        };
+    }
+    Expression1.PropertyKeys = PropertyKeys;
+    function Property(key, expression, options = {}) {
+        return {
+            ...options,
+            type: 'Property',
+            key,
+            expr: expression
+        };
+    }
+    Expression1.Property = Property;
+    function Ref(value, options = {}) {
+        return {
+            ...options,
+            type: 'Ref',
+            $ref: value
+        };
+    }
+    Expression1.Ref = Ref;
+    function True(options = {}) {
+        return {
+            ...options,
+            type: 'True'
+        };
+    }
+    Expression1.True = True;
+    function TypeOf(value, options = {}) {
+        return {
+            ...options,
+            type: 'TypeOf',
+            value
+        };
+    }
+    Expression1.TypeOf = TypeOf;
 })(Expression || (Expression = {}));
 
-export { Expression };
-//# sourceMappingURL=expression.js.map
+//# sourceMappingURL=expression.js.map