can-type - npm Package Compare versions

Comparing version 1.0.0-pre.0 to 1.0.0-pre.1

can-type-test.js

@@ -0,1 +1,2 @@
+var canSymbol = require("can-symbol");
 var canReflect = require("can-reflect");
@@ -130,5 +131,69 @@ var type = require("../can-type");
 
-QUnit.test("types.Any works as an identity", function(assert) {
+QUnit.test("type.Any works as an identity", function(assert) {
 	var result = canReflect.convert(45, type.Any);
 	assert.equal(result, 45, "Acts as a identity");
 });
+
+QUnit.test("type.late(fn) takes a function to define the type later", function(assert) {
+	var theType = type.late(() => type.convert(Number));
+	var result = canReflect.convert("45", theType);
+	assert.equal(result, 45, "Defined late but then converted");
+});
+
+QUnit.test("type.late(fn) where the underlying type value is a builtin becomes a strict type", function(assert) {
+	var typeType = type.late(() => Number);
+	var result = canReflect.convert(45, typeType);
+	assert.equal(result, 45, "works with numbers");
+
+	try {
+		canReflect.convert("45", typeType);
+		assert.ok(false, "Should not have thrown");
+	} catch(err) {
+		assert.ok(err, "Got an error becomes it is strict");
+	}
+});
+
+QUnit.test("type.isTypeObject determines if an object is a TypeObject", function(assert) {
+	assert.equal(type.isTypeObject({}), false, "Plain objects are not");
+
+	var myTypeObject = {};
+	myTypeObject[canSymbol.for("can.new")] = function(){};
+	myTypeObject[canSymbol.for("can.isMember")] = function(){};
+	assert.equal(type.isTypeObject(myTypeObject), true, "With the symbols it is");
+
+	var myTypeFunction = function(){};
+	myTypeFunction[canSymbol.for("can.new")] = function(){};
+	myTypeFunction[canSymbol.for("can.isMember")] = function(){};
+	assert.equal(type.isTypeObject(myTypeFunction), true, "functions with the symbols are too");
+
+	assert.equal(type.isTypeObject(null), false, "primitives are not");
+	assert.equal(type.isTypeObject(undefined), false, "undefined is not");
+	assert.equal(type.isTypeObject(23), false, "number primitives too");
+	assert.equal(type.isTypeObject(String), false, "builtin constructors are not");
+});
+
+QUnit.test("type.normalize takes a Type and returns a TypeObject", function(assert) {
+	[String, type.check(String), Date].forEach(function(Type) {
+		var typeObject = type.normalize(Type);
+		var name = canReflect.getName(Type);
+		assert.equal(type.isTypeObject(typeObject), true, "Creates a typeobject for " + name);
+	});
+
+	[12, null, "foobar"].forEach(function(primitive) {
+		try {
+			type.normalize(primitive);
+		} catch(err) {
+			assert.ok(err, "Unable to normalize primitives");
+		}
+	});
+});
+
+QUnit.test("Should not be able to call new on a TypeObject", function(assert) {
+	var typeObject = type.convert(Number);
+	try {
+		new typeObject();
+		assert.ok(false, "Should not be able to call new");
+	} catch(err) {
+		assert.ok(err, "Got an error calling new");
+	}
+});

can-type.js

 var canReflect = require("can-reflect");
+var canSymbol = require("can-symbol");
 
+var isMemberSymbol = canSymbol.for("can.isMember");
+var newSymbol = canSymbol.for("can.new");
+
+var type = exports;
+
 var primitives = new Map();
@@ -44,15 +50,3 @@ [Number, String, Boolean].forEach(function(Type) {
 var createMaybe = makeTypeFactory(function createMaybe(Type, action, isMember) {
-	var createNewOfType = function(val) {
-		if (val == null) {
-			return val;
-		}
-		if (val instanceof Type || isMember(val)) {
-			return val;
-		}
-		// Convert `'false'` into `false`
-		if (Type === Boolean && (val === 'false' || val === '0')) {
-			return false;
-		}
-		return action(Type, val);
-	};
+	var typeObject = {};
 
@@ -64,4 +58,16 @@ var values = [Type, null, undefined];
 
-	return canReflect.assignSymbols(createNewOfType, {
-		"can.new": createNewOfType,
+	return canReflect.assignSymbols(typeObject, {
+		"can.new": function(val) {
+			if (val == null) {
+				return val;
+			}
+			if (val instanceof Type || isMember(val)) {
+				return val;
+			}
+			// Convert `'false'` into `false`
+			if (Type === Boolean && (val === 'false' || val === '0')) {
+				return false;
+			}
+			return action(Type, val);
+		},
 		"can.getSchema": makeSchema(values),
@@ -78,13 +84,3 @@ "can.getName": function(){
 var createNoMaybe = makeTypeFactory(function createNoMaybe(Type, action, isMember) {
-	var createNewOfType = function(val) {
-		if (val instanceof Type || isMember(val)) {
-			return val;
-		}
-		// Convert `'false'` into `false`
-		if (Type === Boolean && (val === 'false' || val === '0')) {
-			console.log('createNoMaybe', 'Boolean === "false"');
-			return false;
-		}
-		return action(Type, val);
-	};
+	var typeObject = {};
 
@@ -96,4 +92,13 @@ var values = [Type];
 
-	return canReflect.assignSymbols(createNewOfType, {
-		"can.new": createNewOfType,
+	return canReflect.assignSymbols(typeObject, {
+		"can.new": function(val) {
+			if (val instanceof Type || isMember(val)) {
+				return val;
+			}
+			// Convert `'false'` into `false`
+			if (Type === Boolean && (val === 'false' || val === '0')) {
+				return false;
+			}
+			return action(Type, val);
+		},
 		"can.getSchema": makeSchema(values),
@@ -117,2 +122,38 @@ "can.getName": function(){
 
+function isTypeObject(Type) {
+	if(canReflect.isPrimitive(Type)) {
+		return false;
+	}
+
+	return (newSymbol in Type) && (isMemberSymbol in Type);
+}
+
+function normalize(Type) {
+	if(canReflect.isPrimitive(Type)) {
+		throw new Error("can-type: Unable to normalize primitive values.");
+	} else if(isTypeObject(Type)) {
+		return Type;
+	} else {
+		return type.check(Type);
+	}
+}
+
+function late(fn) {
+	var lateType = {};
+	var underlyingType;
+	var unwrap = function() {
+		underlyingType = type.normalize(fn());
+		unwrap = function() { return underlyingType; };
+		return underlyingType;
+	};
+	return canReflect.assignSymbols(lateType, {
+		"can.new": function(val) {
+			return canReflect.new(unwrap(), val);
+		},
+		"can.isMember": function(val) {
+			return unwrap()[isMemberSymbol](val);
+		}
+	});
+}
+
 var Any = canReflect.assignSymbols({}, {
@@ -130,1 +171,4 @@ "can.new": function(val) { return val; },
 exports.Any = Any;
+exports.late = late;
+exports.isTypeObject = isTypeObject;
+exports.normalize = normalize;

package.json

 {
   "name": "can-type",
-  "version": "1.0.0-pre.0",
+  "version": "1.0.0-pre.1",
   "description": "Type definitions",
@@ -23,3 +23,4 @@ "homepage": "https://canjs.com/doc/can-type.html",
     "release:minor": "npm version minor && npm publish",
-    "release:major": "npm version major && npm publish"
+    "release:major": "npm version major && npm publish",
+    "release:pre": "npm version prerelease && npm publish"
   },
@@ -32,3 +33,4 @@ "main": "can-type.js",
   "dependencies": {
-    "can-reflect": "^1.17.10"
+    "can-reflect": "^1.17.10",
+    "can-symbol": "^1.6.5"
   },
@@ -35,0 +37,0 @@ "devDependencies": {

No alert changes

Improved metrics

Total package byte prevSize

31147

increased by25.64%

Number of package files

21

increased by16.67%

Lines of code

326

increased by39.91%

Worsened metrics

Dependency count

2

increased by100%

Dependency changes

• + Addedcan-symbol@^1.6.5