@sinclair/typebox - npm Package Compare versions

Comparing version 0.31.29 to 0.31.30

compiler/compiler.d.ts

@@ -22,9 +22,2 @@ import { ValueErrorIterator } from '../errors/errors';
 }
-export declare namespace StringUtil {
-    /**
-     * Unquoted string values are embedded into single-quote string. This
-     * function ensures that embedded string cannot be escaped.
-     */
-    function EscapeSingleQuote(value: string): string;
-}
 export declare class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
@@ -31,0 +24,0 @@ readonly schema: Types.TSchema;

compiler/compiler.js

@@ -30,3 +30,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.Policy = exports.TypeCompilerTypeGuardError = exports.TypeCompilerUnknownTypeError = exports.StringUtil = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.Policy = exports.TypeCompilerTypeGuardError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
 const transform_1 = require("../value/transform");
@@ -99,46 +99,3 @@ const guard_1 = require("../value/guard");
 })(Character || (Character = {}));
-// ------------------------------------------------------------------
-// StringUtil
-// ------------------------------------------------------------------
-var StringUtil;
-(function (StringUtil) {
-    /**
-     * Unquoted string values are embedded into single-quote string. This
-     * function ensures that embedded string cannot be escaped.
-     */
-    function EscapeSingleQuote(value) {
-        return JSON.stringify(value).slice(1, -1).replace(/'/g, "\\'");
-    }
-    StringUtil.EscapeSingleQuote = EscapeSingleQuote;
-})(StringUtil || (exports.StringUtil = StringUtil = {}));
 // -------------------------------------------------------------------
-// MemberExpression
-// -------------------------------------------------------------------
-var MemberExpression;
-(function (MemberExpression) {
-    function IsFirstCharacterNumeric(value) {
-        if (value.length === 0)
-            return false;
-        return Character.IsNumeric(value.charCodeAt(0));
-    }
-    function IsAccessor(value) {
-        if (IsFirstCharacterNumeric(value))
-            return false;
-        for (let i = 0; i < value.length; i++) {
-            const code = value.charCodeAt(i);
-            const check = Character.IsAlpha(code) || Character.IsNumeric(code) || Character.DollarSign(code) || Character.IsUnderscore(code);
-            if (!check)
-                return false;
-        }
-        return true;
-    }
-    function EscapeHyphen(key) {
-        return StringUtil.EscapeSingleQuote(key);
-    }
-    function Encode(object, key) {
-        return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`;
-    }
-    MemberExpression.Encode = Encode;
-})(MemberExpression || (MemberExpression = {}));
-// -------------------------------------------------------------------
 // Identifier
@@ -163,13 +120,19 @@ // -------------------------------------------------------------------
 })(Identifier || (Identifier = {}));
+// ------------------------------------------------------------------
+// StringConstant
+// ------------------------------------------------------------------
+function StringConstant(value) {
+    if (!(0, guard_1.IsString)(value))
+        throw Error('ConstantString: Not a String');
+    const canonical = JSON.stringify(value).slice(1, -1);
+    const escaped = canonical.replace(/'/g, "\\'");
+    return `'${escaped}'`;
+}
+// ------------------------------------------------------------------
+// MemberExpression
+// ------------------------------------------------------------------
+function MemberExpression(value, key) {
+    return `${value}[${StringConstant(key)}]`;
+}
 // -------------------------------------------------------------------
-// LiteralString
-// -------------------------------------------------------------------
-var LiteralString;
-(function (LiteralString) {
-    function Escape(content) {
-        return StringUtil.EscapeSingleQuote(content);
-    }
-    LiteralString.Escape = Escape;
-})(LiteralString || (LiteralString = {}));
-// -------------------------------------------------------------------
 // Errors
@@ -197,3 +160,3 @@ // -------------------------------------------------------------------
     function IsExactOptionalProperty(value, key, expression) {
-        return index_1.TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
+        return index_1.TypeSystemPolicy.ExactOptionalPropertyTypes ? `(${StringConstant(key)} in ${value} ? ${expression} : true)` : `(${MemberExpression(value, key)} !== undefined ? ${expression} : true)`;
     }
@@ -333,4 +296,7 @@ Policy.IsExactOptionalProperty = IsExactOptionalProperty;
         }
+        else if (typeof schema.const === 'string') {
+            yield `(${value} === ${StringConstant(schema.const)})`;
+        }
         else {
-            yield `(${value} === '${LiteralString.Escape(schema.const)}')`;
+            throw Error('Invalid Literal Value');
         }
@@ -369,3 +335,3 @@ }
         for (const knownKey of knownKeys) {
-            const memberExpression = MemberExpression.Encode(value, knownKey);
+            const memberExpression = MemberExpression(value, knownKey);
             const property = schema.properties[knownKey];
@@ -375,3 +341,3 @@ if (schema.required && schema.required.includes(knownKey)) {
                 if (Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property))
-                    yield `('${knownKey}' in ${value})`;
+                    yield `(${StringConstant(knownKey)} in ${value})`;
             }
@@ -388,3 +354,3 @@ else {
             else {
-                const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
+                const keys = `[${knownKeys.map((key) => `${StringConstant(key)}`).join(', ')}]`;
                 yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
@@ -395,3 +361,3 @@ }
             const expression = CreateExpression(schema.additionalProperties, references, `${value}[key]`);
-            const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
+            const keys = `[${knownKeys.map((key) => `${StringConstant(key)}`).join(', ')}]`;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
@@ -435,3 +401,3 @@ }
         if (schema.format !== undefined) {
-            yield `format('${schema.format}', ${value})`;
+            yield `format(${StringConstant(schema.format)}, ${value})`;
         }
@@ -484,3 +450,3 @@ }
         state.instances.set(instance, schema);
-        yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`;
+        yield `kind(${StringConstant(schema[Types.Kind])}, ${instance}, ${value})`;
     }
@@ -487,0 +453,0 @@ function* Visit(schema, references, value, useHoisting = true) {

package.json

 {
   "name": "@sinclair/typebox",
-  "version": "0.31.29",
+  "version": "0.31.30",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
@@ -5,0 +5,0 @@ "keywords": [

No alert changes

Worsened metrics

Total package byte prevSize

533306

-0.28%

Lines of code

8499

-0.48%

No dependency changes