Merge pull request #2 from axhxrx/1-cannot-publish-due-to-jsr-compati…

…bility-issues

1 cannot publish due to jsr compatibility issues

AlphabeticOrUnderscoreOrHyphenString.ts

@@ -1,11 +1,17 @@
 import { ValidatedString } from './ValidatedString.ts';
-
 const isAlphabeticOrUnderscoreOrHyphen = (s: string) => /^[a-zA-Z_-]+$/.test(s);
 
-const { factory, type } = ValidatedString.create(isAlphabeticOrUnderscoreOrHyphen, {
-  name: 'AlphabeticOrUnderscoreOrHyphenString',
-  description: 'must contain only letters (A-Z, a-z), underscores, or hyphens',
-});
+// Why JSRCompatibleFactory? See https://github.com/axhxrx/validated-string/issues/1
+const JSRCompatibleFactory = ValidatedString.create(
+  isAlphabeticOrUnderscoreOrHyphen,
+  {
+    name: 'AlphabeticOrUnderscoreOrHyphenString',
+    description: 'must contain only letters (A-Z, a-z), underscores, or hyphens',
+  },
+);
+
+const type = JSRCompatibleFactory.type;
+const factory = JSRCompatibleFactory.factory;
 
 export type AlphabeticOrUnderscoreOrHyphenString = typeof type;
 export const AlphabeticOrUnderscoreOrHyphenString = factory;

AlphabeticOrUnderscoreString.ts

@@ -1,11 +1,11 @@
 import { ValidatedString } from './ValidatedString.ts';
 
-const isAlphabeticOrUnderscore = (s: string) => /^[a-zA-Z_]+$/.test(s);
+const isAlphabeticOrUnderscore = (s: string): boolean => /^[a-zA-Z_]+$/.test(s);
 
-const { factory, type } = ValidatedString.create(isAlphabeticOrUnderscore, {
+const JSRCompatibleFactory = ValidatedString.create(isAlphabeticOrUnderscore, {
   name: 'AlphabeticOrUnderscoreString',
   description: 'must contain only letters (A-Z, a-z) or underscores',
 });
 
-export type AlphabeticOrUnderscoreString = typeof type;
-export const AlphabeticOrUnderscoreString = factory;
+export type AlphabeticOrUnderscoreString = typeof JSRCompatibleFactory.type;
+export const AlphabeticOrUnderscoreString = JSRCompatibleFactory.factory;

AlphabeticString.ts

@@ -1,11 +1,11 @@
 import { ValidatedString } from './ValidatedString.ts';
 
-const isAlphabetic = (s: string) => /^[a-zA-Z]+$/.test(s);
+const isAlphabetic = (s: string): boolean => /^[a-zA-Z]+$/.test(s);
 
-const { factory, type } = ValidatedString.create(isAlphabetic, {
+const JSRCompatibleFactory = ValidatedString.create(isAlphabetic, {
   name: 'AlphabeticString',
   description: 'must contain only letters (A-Z, a-z)',
 });
 
-export type AlphabeticString = typeof type;
-export const AlphabeticString = factory;
+export type AlphabeticString = typeof JSRCompatibleFactory.type;
+export const AlphabeticString = JSRCompatibleFactory.factory;

AwesomeString.ts

@@ -1,10 +1,11 @@
 import { ValidatedString } from './ValidatedString.ts';
 
-const isAwesome = (s: string) => s === 'awesome';
+const isAwesome = (s: string): boolean => s === 'awesome';
 
-const { factory, type } = ValidatedString.create(isAwesome);
-export type AwesomeString = typeof type;
-export const AwesomeString = factory;
+const JSRCompatibleFactory = ValidatedString.create(isAwesome);
+
+export type AwesomeString = typeof JSRCompatibleFactory.type;
+export const AwesomeString = JSRCompatibleFactory.factory;
 
 // Usage:
 const x = AwesomeString.try('awesome'); // AwesomeString | undefined

LowercaseAlphabeticString.test.ts

@@ -33,7 +33,7 @@ Deno.test('LowercaseAlphabeticString - assert throws with descriptive message',
   assertThrows(
     () => LowercaseAlphabeticString.assert('Hello123!'),
     Error,
-    'Invalid string did not pass validation: Supplied value "Hello123!" is not valid for validator "LowercaseAlphabeticString" (must contain only lowercase letters a-z).',
+    'Invalid string did not pass validation: Supplied value "Hello123!" is not valid for validator "LowercaseAlphabeticString" (must contain only lowercase letters (a-z)).',
   );
 });
 

LowercaseAlphabeticString.ts

@@ -1,11 +1,11 @@
 import { ValidatedString } from './ValidatedString.ts';
 
-const isLowercaseAlpha = (s: string) => /^[a-z]+$/.test(s);
+const isLowercaseAlpha = (s: string): boolean => /^[a-z]+$/.test(s);
 
-const { factory, type } = ValidatedString.create(isLowercaseAlpha, {
+const JSRCompatibleFactory = ValidatedString.create(isLowercaseAlpha, {
   name: 'LowercaseAlphabeticString',
-  description: 'must contain only lowercase letters a-z',
+  description: 'must contain only lowercase letters (a-z)',
 });
 
-export type LowercaseAlphabeticString = typeof type;
-export const LowercaseAlphabeticString = factory;
+export type LowercaseAlphabeticString = typeof JSRCompatibleFactory.type;
+export const LowercaseAlphabeticString = JSRCompatibleFactory.factory;

PrometheusMetricName.ts

@@ -1,14 +1,14 @@
 import { ValidatedString } from './ValidatedString.ts';
 
-const isPrometheusMetricName = (s: string) => /^[a-zA-Z_:][a-zA-Z0-9_:]*$/.test(s);
+const isPrometheusMetricName = (s: string): boolean => /^[a-zA-Z_:][a-zA-Z0-9_:]*$/.test(s);
 
-const { factory, type } = ValidatedString.create(isPrometheusMetricName, {
+const JSRCompatibleFactory = ValidatedString.create(isPrometheusMetricName, {
   name: 'PrometheusMetricName',
   description: 'must start with a letter, underscore, or colon, followed by letters, digits, underscores, or colons',
 });
 
 /**
  A validated string that represents a Prometheus metric name. See {@link ValidatedString} for more information. Note that this might not really exactly match the rules for Prometheus metric names, but it's close enough for our purposes; namely, generating metrics — don't rely on this to *validate* Prometheus metric names, as it is based on a quick skim of the Prometheus docs.
  */
-export type PrometheusMetricName = typeof type;
-export const PrometheusMetricName = factory;
+export type PrometheusMetricName = typeof JSRCompatibleFactory.type;
+export const PrometheusMetricName = JSRCompatibleFactory.factory;

PrometheusMetricNameWithoutColon.ts

@@ -1,11 +1,14 @@
 import { ValidatedString } from './ValidatedString.ts';
 
-const isPrometheusMetricNameWithoutColon = (s: string) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s);
+const isPrometheusMetricNameWithoutColon = (s: string): boolean => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s);
 
-const { factory, type } = ValidatedString.create(isPrometheusMetricNameWithoutColon, {
-  name: 'PrometheusMetricNameWithoutColon',
-  description: 'must start with a letter or underscore, followed by letters, digits, or underscores',
-});
+const JSRCompatibleFactory = ValidatedString.create(
+  isPrometheusMetricNameWithoutColon,
+  {
+    name: 'PrometheusMetricNameWithoutColon',
+    description: 'must start with a letter or underscore, followed by letters, digits, or underscores',
+  },
+);
 
-export type PrometheusMetricNameWithoutColon = typeof type;
-export const PrometheusMetricNameWithoutColon = factory;
+export type PrometheusMetricNameWithoutColon = typeof JSRCompatibleFactory.type;
+export const PrometheusMetricNameWithoutColon = JSRCompatibleFactory.factory;

README.md

@@ -1,6 +1,8 @@
 # @axhxrx/validated-strings
 
-A library to help make runtime-validated strings, while still preserving a modicum of type-safety at build-time. Intended for specialized string types that are too complex to be modeled within the type system itself, e.g. "starts with an alphanumeric character and less than 1000 characters long, with at least three swear words", or "three words in German, separated by spaces", etc.
+A library to help make runtime-validated strings, but using branded types to preserve a modicum of type-safety and convenience at build-time.
+
+Intended for specialized string types that are too complex to be modeled within the type system itself, e.g. "starts with an alphanumeric character and less than 1000 characters long, with at least three swear words", or "three words in German, separated by spaces", etc.
 
 Example:
 
@@ -23,7 +25,7 @@ export type CowName = typeof type;
 const x = CowName.try('Bessie'); // x is 'Bessie'
 const y: CowName | undefined = CowName.try('not a cow name'); // y is undefined
 const z: CowName = CowName.assert('Bessie'); // z is 'Bessie'
-const ohFuck: never = CowName.assert('not a cow name'); // throws an error
+const ohFuck = CowName.assert('not a cow name'); // throws an error
 ```
 
 That's useful when you want to worry about the validation only in one spot, and lean on the type system elsewhere. E.g.: