@kdtlabs/utils 0.0.8 → 0.0.10

package/dist/zod/index.js

@@ -0,0 +1,4 @@
+import{isDirectory,isFile,isHexString,isNumberString,isReadable,isStrictHexString,isTrueLike,isValidDate,isWritable,isWritableDirectory}from"../chunk-k250wjfj.js";import{z}from"zod";var PROTOCOL_PATTERNS={file:/^file$/u,ftp:/^ftps?$/u,http:/^https?$/u,ssh:/^ssh$/u,ws:/^wss?$/u};function url(...protocols){let patterns=protocols.flat().map((p)=>PROTOCOL_PATTERNS[p]),combined=new RegExp(`^(?:${patterns.map((r)=>r.source.slice(1,-1)).join("|")})$`);return z.url({protocol:combined})}var hexString=(length)=>z.string().refine((val)=>isHexString(val,length),{error:length?`Invalid hex string (expected ${length} bytes)`:"Invalid hex string"}),strictHexString=(length)=>z.string().refine((val)=>isStrictHexString(val,length),{error:length?`Invalid strict hex string (expected 0x prefix, ${length} bytes)`:"Invalid strict hex string (expected 0x prefix)"}),numberString=()=>z.string().refine((val)=>isNumberString(val),{error:"Invalid number string"}),validDate=()=>z.custom((val)=>isValidDate(val),{error:"Invalid date"}),trueLike=(options)=>z.unknown().transform((val)=>isTrueLike(val,options)),filePath=()=>z.string().refine((val)=>isFile(val),{error:"Path is not a file"}),directoryPath=()=>z.string().refine((val)=>isDirectory(val),{error:"Path is not a directory"}),readable=()=>z.string().refine((val)=>isReadable(val),{error:"Path is not readable"}),writable=()=>z.string().refine((val)=>isWritable(val),{error:"Path is not writable"}),writableDirectory=()=>z.string().refine((val)=>isWritableDirectory(val),{error:"Path is not a writable directory"});export{writableDirectory,writable,validDate,url,trueLike,strictHexString,readable,numberString,hexString,filePath,directoryPath,PROTOCOL_PATTERNS};
+
+//# debugId=CA2A82F81B89B66B64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/zod/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/zod/schemas.ts"],
+  "sourcesContent": [
+    "import type { IsTrueLikeOptions } from '../core'\nimport { z } from 'zod'\nimport { isTrueLike } from '../core'\nimport { isNumberString } from '../numbers'\nimport { isHexString, isStrictHexString } from '../strings'\nimport { isDirectory, isFile, isReadable, isWritable, isWritableDirectory } from '../system'\nimport { isValidDate } from '../times'\n\nexport const PROTOCOL_PATTERNS = <const>{\n    file: /^file$/u,\n    ftp: /^ftps?$/u,\n    http: /^https?$/u,\n    ssh: /^ssh$/u,\n    ws: /^wss?$/u,\n}\n\nexport type Protocol = keyof typeof PROTOCOL_PATTERNS\n\nexport function url(...protocols: Array<Protocol | Protocol[]>) {\n    const flat = protocols.flat()\n    const patterns = flat.map((p) => PROTOCOL_PATTERNS[p])\n    const combined = new RegExp(`^(?:${patterns.map((r) => r.source.slice(1, -1)).join('|')})$`)\n\n    return z.url({ protocol: combined })\n}\n\nexport const hexString = (length?: number) => (\n    z.string().refine((val) => isHexString(val, length), {\n        error: length ? `Invalid hex string (expected ${length} bytes)` : 'Invalid hex string',\n    })\n)\n\nexport const strictHexString = (length?: number) => (\n    z.string().refine((val) => isStrictHexString(val, length), {\n        error: length ? `Invalid strict hex string (expected 0x prefix, ${length} bytes)` : 'Invalid strict hex string (expected 0x prefix)',\n    })\n)\n\nexport const numberString = () => (\n    z.string().refine((val) => isNumberString(val), {\n        error: 'Invalid number string',\n    })\n)\n\nexport const validDate = () => (\n    z.custom<Date>((val) => isValidDate(val), { error: 'Invalid date' })\n)\n\nexport const trueLike = (options?: IsTrueLikeOptions) => z.unknown().transform((val) => isTrueLike(val, options))\n\nexport const filePath = () => z.string().refine((val) => isFile(val), {\n    error: 'Path is not a file',\n})\n\nexport const directoryPath = () => (\n    z.string().refine((val) => isDirectory(val), {\n        error: 'Path is not a directory',\n    })\n)\n\nexport const readable = () => (\n    z.string().refine((val) => isReadable(val), {\n        error: 'Path is not readable',\n    })\n)\n\nexport const writable = () => (\n    z.string().refine((val) => isWritable(val), {\n        error: 'Path is not writable',\n    })\n)\n\nexport const writableDirectory = () => (\n    z.string().refine((val) => isWritableDirectory(val), {\n        error: 'Path is not a writable directory',\n    })\n)\n"
+  ],
+  "mappings": "mKACA,mBAOO,IAAM,kBAA2B,CACpC,KAAM,UACN,IAAK,WACL,KAAM,YACN,IAAK,SACL,GAAI,SACR,EAIO,SAAS,GAAG,IAAI,UAAyC,CAE5D,IAAM,SADO,UAAU,KAAK,EACN,IAAI,CAAC,IAAM,kBAAkB,EAAE,EAC/C,SAAW,IAAI,OAAO,OAAO,SAAS,IAAI,CAAC,IAAM,EAAE,OAAO,MAAM,EAAG,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,EAE3F,OAAO,EAAE,IAAI,CAAE,SAAU,QAAS,CAAC,EAGhC,IAAM,UAAY,CAAC,SACtB,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,YAAY,IAAK,MAAM,EAAG,CACjD,MAAO,OAAS,gCAAgC,gBAAkB,oBACtE,CAAC,EAGQ,gBAAkB,CAAC,SAC5B,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,kBAAkB,IAAK,MAAM,EAAG,CACvD,MAAO,OAAS,kDAAkD,gBAAkB,gDACxF,CAAC,EAGQ,aAAe,IACxB,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,eAAe,GAAG,EAAG,CAC5C,MAAO,uBACX,CAAC,EAGQ,UAAY,IACrB,EAAE,OAAa,CAAC,MAAQ,YAAY,GAAG,EAAG,CAAE,MAAO,cAAe,CAAC,EAG1D,SAAW,CAAC,UAAgC,EAAE,QAAQ,EAAE,UAAU,CAAC,MAAQ,WAAW,IAAK,OAAO,CAAC,EAEnG,SAAW,IAAM,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,OAAO,GAAG,EAAG,CAClE,MAAO,oBACX,CAAC,EAEY,cAAgB,IACzB,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,YAAY,GAAG,EAAG,CACzC,MAAO,yBACX,CAAC,EAGQ,SAAW,IACpB,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,WAAW,GAAG,EAAG,CACxC,MAAO,sBACX,CAAC,EAGQ,SAAW,IACpB,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,WAAW,GAAG,EAAG,CACxC,MAAO,sBACX,CAAC,EAGQ,kBAAoB,IAC7B,EAAE,OAAO,EAAE,OAAO,CAAC,MAAQ,oBAAoB,GAAG,EAAG,CACjD,MAAO,kCACX,CAAC",
+  "debugId": "CA2A82F81B89B66B64756E2164756E21",
+  "names": []
+}

package/dist/zod/schemas.d.ts

@@ -0,0 +1,22 @@
+import type { IsTrueLikeOptions } from '../core';
+import { z } from 'zod';
+export declare const PROTOCOL_PATTERNS: {
+    readonly file: RegExp;
+    readonly ftp: RegExp;
+    readonly http: RegExp;
+    readonly ssh: RegExp;
+    readonly ws: RegExp;
+};
+export type Protocol = keyof typeof PROTOCOL_PATTERNS;
+export declare function url(...protocols: Array<Protocol | Protocol[]>): z.ZodURL;
+export declare const hexString: (length?: number) => z.ZodString;
+export declare const strictHexString: (length?: number) => z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+export declare const numberString: () => z.ZodString & z.ZodType<import("..").NumberString<true>, string, z.core.$ZodTypeInternals<import("..").NumberString<true>, string>>;
+export declare const validDate: () => z.ZodCustom<Date, Date>;
+export declare const trueLike: (options?: IsTrueLikeOptions) => z.ZodPipe<z.ZodUnknown, z.ZodTransform<boolean, unknown>>;
+export declare const filePath: () => z.ZodString;
+export declare const directoryPath: () => z.ZodString;
+export declare const readable: () => z.ZodString;
+export declare const writable: () => z.ZodString;
+export declare const writableDirectory: () => z.ZodString;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/zod/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/zod/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAChD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,eAAO,MAAM,iBAAiB;;;;;;CAM7B,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,iBAAiB,CAAA;AAErD,wBAAgB,GAAG,CAAC,GAAG,SAAS,EAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,YAM7D;AAED,eAAO,MAAM,SAAS,GAAI,SAAS,MAAM,gBAIxC,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,oGAI9C,CAAA;AAED,eAAO,MAAM,YAAY,2IAIxB,CAAA;AAED,eAAO,MAAM,SAAS,+BAErB,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,UAAU,iBAAiB,8DAA6D,CAAA;AAEjH,eAAO,MAAM,QAAQ,mBAEnB,CAAA;AAEF,eAAO,MAAM,aAAa,mBAIzB,CAAA;AAED,eAAO,MAAM,QAAQ,mBAIpB,CAAA;AAED,eAAO,MAAM,QAAQ,mBAIpB,CAAA;AAED,eAAO,MAAM,iBAAiB,mBAI7B,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@kdtlabs/utils",
     "type": "module",
-    "version": "0.0.8",
+    "version": "0.0.10",
     "description": "A comprehensive TypeScript utility library",
     "author": "Diep Dang <kdt310722@gmail.com>",
     "license": "MIT",
@@ -16,6 +16,10 @@
         ".": {
             "types": "./dist/index.d.ts",
             "default": "./dist/index.js"
+        },
+        "./zod": {
+            "types": "./dist/zod/index.d.ts",
+            "default": "./dist/zod/index.js"
         }
     },
     "main": "dist/index.js",
@@ -38,6 +42,14 @@
         "up": "taze -I --group --force --peer",
         "preinstall": "only-allow bun && ([ -d .git ] && simple-git-hooks || true)"
     },
+    "peerDependencies": {
+        "zod": "^4.0.0"
+    },
+    "peerDependenciesMeta": {
+        "zod": {
+            "optional": true
+        }
+    },
     "devDependencies": {
         "@commitlint/cli": "^20.5.0",
         "@commitlint/config-conventional": "^20.5.0",
@@ -52,7 +64,8 @@
         "rimraf": "^6.1.3",
         "simple-git-hooks": "^2.13.1",
         "taze": "^19.10.0",
-        "typescript": "^6.0.2"
+        "typescript": "^6.0.2",
+        "zod": "^4.3.6"
     },
     "simple-git-hooks": {
         "commit-msg": "bunx --no -- commitlint --edit ${1}",

package/src/errors/guards.ts

@@ -10,3 +10,9 @@ export const isBaseError = (value: unknown): value is BaseError => value instanc
 export const isAbortError = (error: unknown): error is DOMException => error instanceof DOMException && error.name === 'AbortError'
 
 export const isErrorLike = (value: unknown): value is ErrorLike => isObject(value) && isKeysOf(value, 'name') && isString(value.name)
+
+export const isErrnoException = (value: unknown): value is NodeJS.ErrnoException => (
+    value instanceof Error && 'code' in value && 'errno' in value
+)
+
+export const isMissingDirectoryError = (error: NodeJS.ErrnoException) => error.code === 'ENOENT'

package/src/system/fs.ts

@@ -0,0 +1,65 @@
+import type { PathLike } from './types'
+import { accessSync, constants, existsSync, type MakeDirectoryOptions, mkdirSync, statSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { isErrnoException, isMissingDirectoryError } from '../errors'
+import { pathToString } from './path'
+
+export function hasAccess(path: PathLike, mode?: number) {
+    try {
+        accessSync(pathToString(path), mode)
+
+        return true
+    } catch {
+        return false
+    }
+}
+
+export const isReadable = (path: PathLike) => hasAccess(path, constants.R_OK)
+
+export const isWritable = (path: PathLike) => hasAccess(path, constants.W_OK)
+
+export function isFile(path: PathLike) {
+    try {
+        return statSync(pathToString(path)).isFile()
+    } catch {
+        return false
+    }
+}
+
+export function isDirectory(path: PathLike) {
+    try {
+        return statSync(pathToString(path)).isDirectory()
+    } catch {
+        return false
+    }
+}
+
+export function isWritableDirectory(dirPath: PathLike): boolean {
+    const resolved = resolve(pathToString(dirPath))
+
+    try {
+        accessSync(resolved, constants.W_OK)
+
+        return true
+    } catch (error) {
+        if (isErrnoException(error) && isMissingDirectoryError(error)) {
+            const parent = dirname(resolved)
+
+            if (parent === resolved) {
+                return false
+            }
+
+            return isWritableDirectory(parent)
+        }
+
+        return false
+    }
+}
+
+export function ensureDirectory(path: PathLike, options: MakeDirectoryOptions = {}) {
+    const resolved = pathToString(path)
+
+    if (!existsSync(resolved)) {
+        mkdirSync(resolved, { recursive: true, ...options })
+    }
+}

package/src/system/hash.ts

@@ -0,0 +1,22 @@
+import type { BinaryLike, BinaryToTextEncoding, HashOptions } from 'node:crypto'
+import type { PathLike } from './types'
+import { createHash } from 'node:crypto'
+import { createReadStream, readFileSync } from 'node:fs'
+import { pathToString } from './path'
+
+export const computeHash = (data: BinaryLike, algorithm: string, encoding: BinaryToTextEncoding = 'hex', options: HashOptions = {}) => (
+    createHash(algorithm, options).update(data).digest(encoding)
+)
+
+export const getFileHash = (path: PathLike, algorithm: string, options: HashOptions = {}) => (
+    computeHash(readFileSync(pathToString(path)), algorithm, 'hex', options)
+)
+
+export const getLargeFileHash = (path: PathLike, algorithm: string, options: HashOptions = {}) => new Promise<string>((resolve, reject) => {
+    const hash = createHash(algorithm, options)
+    const stream = createReadStream(pathToString(path))
+
+    stream.on('data', (chunk) => hash.update(chunk))
+    stream.on('end', () => resolve(hash.digest('hex')))
+    stream.on('error', reject)
+})

package/src/system/index.ts

@@ -1,6 +1,8 @@
 export * from './env'
 export * from './fetch'
+export * from './fs'
 export * from './graceful-exit'
+export * from './hash'
 export * from './path'
 
 export type * from './types'

package/src/system/path.ts

@@ -1,5 +1,6 @@
 import type { PathLike } from './types'
-import { dirname, join } from 'node:path'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { bufferToString, isBufferLike } from '../buffers'
 
@@ -10,3 +11,13 @@ export const pathToString = (path: PathLike) => (
 export const pwd = (importMeta: ImportMeta, ...path: PathLike[]) => (
     join(dirname(fileURLToPath(importMeta.url)), ...path.map(pathToString))
 )
+
+export function resolvePath(path: PathLike) {
+    const str = pathToString(path)
+
+    if (str.startsWith('~/')) {
+        return resolve(homedir(), str.slice(2))
+    }
+
+    return resolve(str)
+}

package/src/times/operations.ts

@@ -82,3 +82,27 @@ const END_RESOLVERS: Record<TimeInterval, (date: DateLike, options: WeekOptions)
 export const resolveInterval = (interval: TimeInterval, type: 'end' | 'start' = 'start', { now = new Date(), ...weekOptions }: ResolveIntervalOptions = {}) => (
     (type === 'start' ? START_RESOLVERS : END_RESOLVERS)[interval](now, weekOptions)
 )
+
+const INTERVAL_SHIFTERS: Record<TimeInterval, (date: Date, amount: number) => void> = {
+    daily: (d, n) => d.setDate(d.getDate() + n),
+    hourly: (d, n) => d.setHours(d.getHours() + n),
+    monthly: (d, n) => d.setMonth(d.getMonth() + n),
+    weekly: (d, n) => d.setDate(d.getDate() + n * 7),
+    yearly: (d, n) => d.setFullYear(d.getFullYear() + n),
+}
+
+function shiftInterval(interval: TimeInterval, amount: number, type: 'end' | 'start' = 'start', { now = new Date(), ...weekOptions }: ResolveIntervalOptions = {}) {
+    const shifted = new Date(now)
+
+    INTERVAL_SHIFTERS[interval](shifted, amount)
+
+    return (type === 'start' ? START_RESOLVERS : END_RESOLVERS)[interval](shifted, weekOptions)
+}
+
+export const addInterval = (interval: TimeInterval, amount: number, type: 'end' | 'start' = 'start', options?: ResolveIntervalOptions) => (
+    shiftInterval(interval, amount, type, options)
+)
+
+export const subtractInterval = (interval: TimeInterval, amount: number, type: 'end' | 'start' = 'start', options?: ResolveIntervalOptions) => (
+    shiftInterval(interval, -amount, type, options)
+)

package/src/zod/index.ts

@@ -0,0 +1 @@
+export * from './schemas'

package/src/zod/schemas.ts

@@ -0,0 +1,77 @@
+import type { IsTrueLikeOptions } from '../core'
+import { z } from 'zod'
+import { isTrueLike } from '../core'
+import { isNumberString } from '../numbers'
+import { isHexString, isStrictHexString } from '../strings'
+import { isDirectory, isFile, isReadable, isWritable, isWritableDirectory } from '../system'
+import { isValidDate } from '../times'
+
+export const PROTOCOL_PATTERNS = <const>{
+    file: /^file$/u,
+    ftp: /^ftps?$/u,
+    http: /^https?$/u,
+    ssh: /^ssh$/u,
+    ws: /^wss?$/u,
+}
+
+export type Protocol = keyof typeof PROTOCOL_PATTERNS
+
+export function url(...protocols: Array<Protocol | Protocol[]>) {
+    const flat = protocols.flat()
+    const patterns = flat.map((p) => PROTOCOL_PATTERNS[p])
+    const combined = new RegExp(`^(?:${patterns.map((r) => r.source.slice(1, -1)).join('|')})$`)
+
+    return z.url({ protocol: combined })
+}
+
+export const hexString = (length?: number) => (
+    z.string().refine((val) => isHexString(val, length), {
+        error: length ? `Invalid hex string (expected ${length} bytes)` : 'Invalid hex string',
+    })
+)
+
+export const strictHexString = (length?: number) => (
+    z.string().refine((val) => isStrictHexString(val, length), {
+        error: length ? `Invalid strict hex string (expected 0x prefix, ${length} bytes)` : 'Invalid strict hex string (expected 0x prefix)',
+    })
+)
+
+export const numberString = () => (
+    z.string().refine((val) => isNumberString(val), {
+        error: 'Invalid number string',
+    })
+)
+
+export const validDate = () => (
+    z.custom<Date>((val) => isValidDate(val), { error: 'Invalid date' })
+)
+
+export const trueLike = (options?: IsTrueLikeOptions) => z.unknown().transform((val) => isTrueLike(val, options))
+
+export const filePath = () => z.string().refine((val) => isFile(val), {
+    error: 'Path is not a file',
+})
+
+export const directoryPath = () => (
+    z.string().refine((val) => isDirectory(val), {
+        error: 'Path is not a directory',
+    })
+)
+
+export const readable = () => (
+    z.string().refine((val) => isReadable(val), {
+        error: 'Path is not readable',
+    })
+)
+
+export const writable = () => (
+    z.string().refine((val) => isWritable(val), {
+        error: 'Path is not writable',
+    })
+)
+
+export const writableDirectory = () => (
+    z.string().refine((val) => isWritableDirectory(val), {
+        error: 'Path is not a writable directory',
+    })
+)