@atproto/syntax 0.4.2 → 0.4.3

package/src/did.ts

@@ -14,19 +14,29 @@
 
 export type DidString<M extends string = string> = `did:${M}:${string}`
 
-export function ensureValidDid(did: string): asserts did is DidString {
-  if (!did.startsWith('did:')) {
+export function ensureValidDid<I extends string>(
+  input: I,
+): asserts input is I & DidString {
+  if (!input.startsWith('did:')) {
     throw new InvalidDidError('DID requires "did:" prefix')
   }
 
+  if (input.length > 2048) {
+    throw new InvalidDidError('DID is too long (2048 chars max)')
+  }
+
+  if (input.endsWith(':') || input.endsWith('%')) {
+    throw new InvalidDidError('DID can not end with ":" or "%"')
+  }
+
   // check that all chars are boring ASCII
-  if (!/^[a-zA-Z0-9._:%-]*$/.test(did)) {
+  if (!/^[a-zA-Z0-9._:%-]*$/.test(input)) {
     throw new InvalidDidError(
       'Disallowed characters in DID (ASCII letters, digits, and a couple other characters only)',
     )
   }
 
-  const { length, 1: method } = did.split(':')
+  const { length, 1: method } = input.split(':')
   if (length < 3) {
     throw new InvalidDidError(
       'DID requires prefix, method, and method-specific content',
@@ -36,26 +46,26 @@ export function ensureValidDid(did: string): asserts did is DidString {
   if (!/^[a-z]+$/.test(method)) {
     throw new InvalidDidError('DID method must be lower-case letters')
   }
-
-  if (did.endsWith(':') || did.endsWith('%')) {
-    throw new InvalidDidError('DID can not end with ":" or "%"')
-  }
-
-  if (did.length > 2 * 1024) {
-    throw new InvalidDidError('DID is too long (2048 chars max)')
-  }
 }
 
-export function ensureValidDidRegex(did: string): asserts did is DidString {
+const DID_REGEX = /^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/
+
+export function ensureValidDidRegex<I extends string>(
+  input: I,
+): asserts input is I & DidString {
   // simple regex to enforce most constraints via just regex and length.
   // hand wrote this regex based on above constraints
-  if (!/^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/.test(did)) {
+  if (!DID_REGEX.test(input)) {
     throw new InvalidDidError("DID didn't validate via regex")
   }
 
-  if (did.length > 2 * 1024) {
+  if (input.length > 2048) {
     throw new InvalidDidError('DID is too long (2048 chars max)')
   }
 }
 
+export function isValidDid<I extends string>(input: I): input is I & DidString {
+  return input.length <= 2048 && DID_REGEX.test(input)
+}
+
 export class InvalidDidError extends Error {}

package/src/handle.ts

@@ -39,20 +39,20 @@ export const DISALLOWED_TLDS = [
 //  - does not validate whether domain or TLD exists, or is a reserved or
 //    special TLD (eg, .onion or .local)
 //  - does not validate punycode
-export function ensureValidHandle(
-  handle: string,
-): asserts handle is HandleString {
+export function ensureValidHandle<I extends string>(
+  input: I,
+): asserts input is I & HandleString {
   // check that all chars are boring ASCII
-  if (!/^[a-zA-Z0-9.-]*$/.test(handle)) {
+  if (!/^[a-zA-Z0-9.-]*$/.test(input)) {
     throw new InvalidHandleError(
       'Disallowed characters in handle (ASCII letters, digits, dashes, periods only)',
     )
   }
 
-  if (handle.length > 253) {
+  if (input.length > 253) {
     throw new InvalidHandleError('Handle is too long (253 chars max)')
   }
-  const labels = handle.split('.')
+  const labels = input.split('.')
   if (labels.length < 2) {
     throw new InvalidHandleError('Handle domain needs at least two parts')
   }
@@ -81,13 +81,13 @@ export function ensureValidHandle(
 const HANDLE_REGEX =
   /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/
 
-export function ensureValidHandleRegex(
-  handle: string,
-): asserts handle is HandleString {
-  if (handle.length > 253) {
+export function ensureValidHandleRegex<I extends string>(
+  input: I,
+): asserts input is I & HandleString {
+  if (input.length > 253) {
     throw new InvalidHandleError('Handle is too long (253 chars max)')
   }
-  if (!HANDLE_REGEX.test(handle)) {
+  if (!HANDLE_REGEX.test(input)) {
     throw new InvalidHandleError("Handle didn't validate via regex")
   }
 }
@@ -102,8 +102,10 @@ export function normalizeAndEnsureValidHandle(handle: string): HandleString {
   return normalized
 }
 
-export function isValidHandle(handle: string): handle is HandleString {
-  return handle.length <= 253 && HANDLE_REGEX.test(handle)
+export function isValidHandle<I extends string>(
+  input: I,
+): input is I & HandleString {
+  return input.length <= 253 && HANDLE_REGEX.test(input)
 }
 
 export function isValidTld(handle: string): boolean {

package/src/index.ts

@@ -1,8 +1,10 @@
-export * from './handle.js'
+export * from './at-identifier.js'
+export * from './aturi.js'
+export * from './datetime.js'
 export * from './did.js'
+export * from './handle.js'
 export * from './nsid.js'
-export * from './aturi.js'
-export * from './at-identifier.js'
-export * from './tid.js'
+export * from './language.js'
 export * from './recordkey.js'
-export * from './datetime.js'
+export * from './tid.js'
+export * from './uri.js'

package/src/language.ts

@@ -0,0 +1,39 @@
+const BCP47_REGEXP =
+  /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/
+
+export type LanguageTag = {
+  grandfathered?: string
+  language?: string
+  extlang?: string
+  script?: string
+  region?: string
+  variant?: string
+  extension?: string
+  privateUse?: string
+}
+
+export function parseLanguageString(input: string): LanguageTag | null {
+  const parsed = input.match(BCP47_REGEXP)
+  if (!parsed?.groups) return null
+
+  const { groups } = parsed
+  return {
+    grandfathered: groups.grandfathered,
+    language: groups.language,
+    extlang: groups.extlang,
+    script: groups.script,
+    region: groups.region,
+    variant: groups.variant,
+    extension: groups.extension,
+    privateUse: groups.privateUseA || groups.privateUseB,
+  }
+}
+
+/**
+ * Validates well-formed BCP 47 syntax
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}
+ */
+export function isValidLanguage(input: string): boolean {
+  return BCP47_REGEXP.test(input)
+}

package/src/nsid.ts

@@ -60,8 +60,10 @@ export class NSID {
   }
 }
 
-export function ensureValidNsid(nsid: string): asserts nsid is NsidString {
-  const result = validateNsid(nsid)
+export function ensureValidNsid<I extends string>(
+  input: I,
+): asserts input is I & NsidString {
+  const result = validateNsid(input)
   if (!result.success) throw new InvalidNsidError(result.message)
 }
 
@@ -71,10 +73,12 @@ export function parseNsid(nsid: string): string[] {
   return result.value
 }
 
-export function isValidNsid(nsid: string): nsid is NsidString {
+export function isValidNsid<I extends string>(
+  input: I,
+): input is I & NsidString {
   // Since the regex version is more performant for valid NSIDs, we use it when
   // we don't care about error details.
-  return validateNsidRegex(nsid).success
+  return validateNsidRegex(input).success
 }
 
 type ValidateResult<T> =

package/src/recordkey.ts

@@ -17,32 +17,34 @@ const RECORD_KEY_REGEX = /^[a-zA-Z0-9_~.:-]{1,512}$/
 //   RFC-3986, section 3.3). The above constraints satisfy this condition, by
 //   matching the "unreserved" characters allowed in generic URI paths.
 
-export function ensureValidRecordKey(
-  rkey: string,
-): asserts rkey is RecordKeyString {
+export function ensureValidRecordKey<I extends string>(
+  input: I,
+): asserts input is I & RecordKeyString {
   if (
-    rkey.length > RECORD_KEY_MAX_LENGTH ||
-    rkey.length < RECORD_KEY_MIN_LENGTH
+    input.length > RECORD_KEY_MAX_LENGTH ||
+    input.length < RECORD_KEY_MIN_LENGTH
   ) {
     throw new InvalidRecordKeyError(
       `record key must be ${RECORD_KEY_MIN_LENGTH} to ${RECORD_KEY_MAX_LENGTH} characters`,
     )
   }
-  if (RECORD_KEY_INVALID_VALUES.has(rkey)) {
+  if (RECORD_KEY_INVALID_VALUES.has(input)) {
     throw new InvalidRecordKeyError('record key can not be "." or ".."')
   }
   // simple regex to enforce most constraints via just regex and length.
-  if (!RECORD_KEY_REGEX.test(rkey)) {
+  if (!RECORD_KEY_REGEX.test(input)) {
     throw new InvalidRecordKeyError('record key syntax not valid (regex)')
   }
 }
 
-export function isValidRecordKey(rkey: string): rkey is RecordKeyString {
+export function isValidRecordKey<I extends string>(
+  input: I,
+): input is I & RecordKeyString {
   return (
-    rkey.length >= RECORD_KEY_MIN_LENGTH &&
-    rkey.length <= RECORD_KEY_MAX_LENGTH &&
-    RECORD_KEY_REGEX.test(rkey) &&
-    !RECORD_KEY_INVALID_VALUES.has(rkey)
+    input.length >= RECORD_KEY_MIN_LENGTH &&
+    input.length <= RECORD_KEY_MAX_LENGTH &&
+    RECORD_KEY_REGEX.test(input) &&
+    !RECORD_KEY_INVALID_VALUES.has(input)
   )
 }
 

package/src/tid.ts

@@ -3,18 +3,20 @@ export type TidString = string
 const TID_LENGTH = 13
 const TID_REGEX = /^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$/
 
-export function ensureValidTid(tid: string): asserts tid is TidString {
-  if (tid.length !== TID_LENGTH) {
+export function ensureValidTid<I extends string>(
+  input: I,
+): asserts input is I & TidString {
+  if (input.length !== TID_LENGTH) {
     throw new InvalidTidError(`TID must be ${TID_LENGTH} characters`)
   }
   // simple regex to enforce most constraints via just regex and length.
-  if (!TID_REGEX.test(tid)) {
+  if (!TID_REGEX.test(input)) {
     throw new InvalidTidError('TID syntax not valid (regex)')
   }
 }
 
-export function isValidTid(tid: string): tid is TidString {
-  return tid.length === TID_LENGTH && TID_REGEX.test(tid)
+export function isValidTid<I extends string>(input: I): input is I & TidString {
+  return input.length === TID_LENGTH && TID_REGEX.test(input)
 }
 
 export class InvalidTidError extends Error {}

package/src/uri.ts

@@ -0,0 +1,5 @@
+export type UriString = `${string}:${string}`
+
+export function isValidUri<I extends string>(input: I): input is I & UriString {
+  return /^\w+:(?:\/\/)?[^\s/][^\s]*$/.test(input)
+}

package/tests/aturi.test.ts

@@ -1,8 +1,9 @@
 import * as fs from 'node:fs'
 import * as readline from 'node:readline'
-import { AtUri, ensureValidAtUri, ensureValidAtUriRegex } from '../src/index'
+import { describe, expect, it } from 'vitest'
+import { AtUri, ensureValidAtUri, ensureValidAtUriRegex } from '../src'
 
-describe('At Uris', () => {
+describe(AtUri, () => {
   it('parses valid at uris', () => {
     //                 input   host    path    query   hash
     type AtUriTest = [string, string, string, string, string]

package/tests/datetime.test.ts

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs'
 import * as readline from 'node:readline'
+import { describe, expect, it } from 'vitest'
 import {
   InvalidDatetimeError,
   ensureValidDatetime,

package/tests/did.test.ts

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs'
 import * as readline from 'node:readline'
+import { describe, expect, it } from 'vitest'
 import { InvalidDidError, ensureValidDid, ensureValidDidRegex } from '../src'
 
 describe('DID permissive validation', () => {

package/tests/handle.test.ts

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs'
 import * as readline from 'node:readline'
+import { describe, expect, it } from 'vitest'
 import {
   InvalidHandleError,
   ensureValidHandle,

package/tests/language.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest'
+import { isValidLanguage, parseLanguageString } from '../src'
+
+describe(isValidLanguage, () => {
+  it('validates BCP 47', () => {
+    // valid
+    expect(isValidLanguage('de')).toEqual(true)
+    expect(isValidLanguage('de-CH')).toEqual(true)
+    expect(isValidLanguage('de-DE-1901')).toEqual(true)
+    expect(isValidLanguage('es-419')).toEqual(true)
+    expect(isValidLanguage('sl-IT-nedis')).toEqual(true)
+    expect(isValidLanguage('mn-Cyrl-MN')).toEqual(true)
+    expect(isValidLanguage('x-fr-CH')).toEqual(true)
+    expect(
+      isValidLanguage('en-GB-boont-r-extended-sequence-x-private'),
+    ).toEqual(true)
+    expect(isValidLanguage('sr-Cyrl')).toEqual(true)
+    expect(isValidLanguage('hy-Latn-IT-arevela')).toEqual(true)
+    expect(isValidLanguage('i-klingon')).toEqual(true)
+    // invalid
+    expect(isValidLanguage('')).toEqual(false)
+    expect(isValidLanguage('x')).toEqual(false)
+    expect(isValidLanguage('de-CH-')).toEqual(false)
+    expect(isValidLanguage('i-bad-grandfathered')).toEqual(false)
+  })
+})
+
+describe(parseLanguageString, () => {
+  it('parses BCP 47', () => {
+    // valid
+    expect(parseLanguageString('de')).toEqual({
+      language: 'de',
+    })
+    expect(parseLanguageString('de-CH')).toEqual({
+      language: 'de',
+      region: 'CH',
+    })
+    expect(parseLanguageString('de-DE-1901')).toEqual({
+      language: 'de',
+      region: 'DE',
+      variant: '1901',
+    })
+    expect(parseLanguageString('es-419')).toEqual({
+      language: 'es',
+      region: '419',
+    })
+    expect(parseLanguageString('sl-IT-nedis')).toEqual({
+      language: 'sl',
+      region: 'IT',
+      variant: 'nedis',
+    })
+    expect(parseLanguageString('mn-Cyrl-MN')).toEqual({
+      language: 'mn',
+      script: 'Cyrl',
+      region: 'MN',
+    })
+    expect(parseLanguageString('x-fr-CH')).toEqual({
+      privateUse: 'x-fr-CH',
+    })
+    expect(
+      parseLanguageString('en-GB-boont-r-extended-sequence-x-private'),
+    ).toEqual({
+      language: 'en',
+      region: 'GB',
+      variant: 'boont',
+      extension: 'r-extended-sequence',
+      privateUse: 'x-private',
+    })
+    expect(parseLanguageString('sr-Cyrl')).toEqual({
+      language: 'sr',
+      script: 'Cyrl',
+    })
+    expect(parseLanguageString('hy-Latn-IT-arevela')).toEqual({
+      language: 'hy',
+      script: 'Latn',
+      region: 'IT',
+      variant: 'arevela',
+    })
+    expect(parseLanguageString('i-klingon')).toEqual({
+      grandfathered: 'i-klingon',
+    })
+    // invalid
+    expect(parseLanguageString('')).toEqual(null)
+    expect(parseLanguageString('x')).toEqual(null)
+    expect(parseLanguageString('de-CH-')).toEqual(null)
+    expect(parseLanguageString('i-bad-grandfathered')).toEqual(null)
+  })
+})

package/tests/nsid.test.ts

@@ -1,4 +1,5 @@
 import * as fs from 'node:fs'
+import { describe, expect, it } from 'vitest'
 import {
   InvalidNsidError,
   NSID,

package/tests/recordkey.test.ts

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs'
 import * as readline from 'node:readline'
+import { describe, expect, it } from 'vitest'
 import { InvalidRecordKeyError, ensureValidRecordKey } from '../src'
 
 describe('recordkey validation', () => {

package/tests/tid.test.ts

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs'
 import * as readline from 'node:readline'
+import { describe, expect, it } from 'vitest'
 import { InvalidTidError, ensureValidTid } from '../src'
 
 describe('tid validation', () => {

package/tsconfig.build.json

@@ -1,9 +1,12 @@
 {
   "extends": "../../tsconfig/isomorphic.json",
+  "include": ["./src"],
+  "exclude": ["**/*.test.ts"],
   "compilerOptions": {
     "noImplicitAny": true,
+    "importHelpers": true,
+    "target": "ES2023",
     "rootDir": "./src",
     "outDir": "./dist"
-  },
-  "include": ["./src"]
+  }
 }

package/tsconfig.build.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/at-identifier.ts","./src/aturi.ts","./src/aturi_validation.ts","./src/datetime.ts","./src/did.ts","./src/handle.ts","./src/index.ts","./src/nsid.ts","./src/recordkey.ts","./src/tid.ts"],"version":"5.8.2"}
+{"root":["./src/at-identifier.ts","./src/aturi.ts","./src/aturi_validation.ts","./src/datetime.ts","./src/did.ts","./src/handle.ts","./src/index.ts","./src/language.ts","./src/nsid.ts","./src/recordkey.ts","./src/tid.ts","./src/uri.ts"],"version":"5.8.2"}

package/tsconfig.tests.json

@@ -1,7 +1,9 @@
 {
-  "extends": "../../tsconfig/tests.json",
+  "extends": "../../tsconfig/vitest.json",
+  "include": ["./tests", "./src/**/*.test.ts"],
   "compilerOptions": {
-    "rootDir": "."
-  },
-  "include": ["./tests"]
+    "noImplicitAny": true,
+    "rootDir": "./",
+    "baseUrl": "./"
+  }
 }

package/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineProject } from 'vitest/config'
+
+export default defineProject({
+  test: {},
+})

package/jest.config.js

@@ -1,7 +0,0 @@
-/** @type {import('jest').Config} */
-module.exports = {
-  displayName: 'Syntax',
-  transform: { '^.+\\.(t|j)s$': '@swc/jest' },
-  setupFiles: ['<rootDir>/../../jest.setup.ts'],
-  moduleNameMapper: { '^(\\.\\.?\\/.+)\\.js$': ['$1.ts', '$1.js'] },
-}

package/tsconfig.tests.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./tests/aturi.test.ts","./tests/datetime.test.ts","./tests/did.test.ts","./tests/handle.test.ts","./tests/nsid.test.ts","./tests/recordkey.test.ts","./tests/tid.test.ts"],"version":"5.8.3"}