apeframework 0.0.0-dev.21 → 0.0.0-dev.23

package/{mailer → dist/mailer}/validateEventGeolocation.js

@@ -1,5 +1,5 @@
-import { isValidGeolocation } from 'utils/isValidGeolocation';
-import { EventGeolocationError } from './errors/EventGeolocationError';
+import { isValidGeolocation } from '../utils/isValidGeolocation.js';
+import { EventGeolocationError } from './errors/EventGeolocationError.js';
 const validateEventGeolocation = (latitude, longitude) => {
     if (!isValidGeolocation(latitude, longitude)) {
         throw new EventGeolocationError(latitude, longitude);

package/{mailer → dist/mailer}/validateEventUrl.js

@@ -1,5 +1,5 @@
-import { isValidUrl } from 'utils/isValidUrl';
-import { EventUrlError } from './errors/EventUrlError';
+import { isValidUrl } from '../utils/isValidUrl.js';
+import { EventUrlError } from './errors/EventUrlError.js';
 const validateEventUrl = (url) => {
     if (!isValidUrl(url)) {
         throw new EventUrlError(url);

package/{mailer → dist/mailer}/validateListUrl.js

@@ -1,5 +1,5 @@
-import { isValidUrl } from 'utils/isValidUrl';
-import { ListUrlError } from './errors/ListUrlError';
+import { isValidUrl } from '../utils/isValidUrl.js';
+import { ListUrlError } from './errors/ListUrlError.js';
 const validateListUrl = (property, url) => {
     if (!isValidUrl(url)) {
         throw new ListUrlError(property, url);

package/{parser → dist/parser}/errors/ParseError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class ParseError extends BaseError {
     constructor(type: string);
 }

package/{parser → dist/parser}/errors/ParseError.js

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 class ParseError extends BaseError {
     constructor(type) {
         super(`failed parsing ${type}`);

package/dist/parser/factories/enum/createEnumParser.d.ts

@@ -0,0 +1,6 @@
+import type { Parser } from '../../Parser.js';
+declare const createEnumParser: <Enum extends Record<string, string | number>>(params: {
+    type: string;
+    enum: Enum;
+}) => Parser<Enum[keyof Enum]>;
+export { createEnumParser, };

package/{parser → dist/parser}/factories/enum/createEnumParser.js

@@ -1,4 +1,4 @@
-import { ParseError } from '../../errors/ParseError';
+import { ParseError } from '../../errors/ParseError.js';
 const createEnumParser = (params) => {
     return (input) => {
         if (!Object.values(params.enum).includes(input)) {

package/{parser → dist/parser}/factories/unit/createUnitParser.d.ts

@@ -1,5 +1,5 @@
-import type { Unit } from './Unit';
-import type { Parser } from '../../Parser';
+import type { Unit } from './Unit.js';
+import type { Parser } from '../../Parser.js';
 declare const createUnitParser: (params: {
     type: string;
     units: Unit[];

package/{parser → dist/parser}/factories/unit/createUnitParser.js

@@ -1,6 +1,6 @@
-import { ParseError } from '../../errors/ParseError';
-import { parseNumber } from '../../parseNumber';
-import { parseString } from '../../parseString';
+import { ParseError } from '../../errors/ParseError.js';
+import { parseNumber } from '../../parseNumber.js';
+import { parseString } from '../../parseString.js';
 const createUnitParser = (params) => {
     return (input) => {
         let string;

package/{parser → dist/parser}/parseBoolean.d.ts

@@ -1,3 +1,3 @@
-import type { Parser } from './Parser';
+import type { Parser } from './Parser.js';
 declare const parseBoolean: Parser<boolean>;
 export { parseBoolean, };

package/{parser → dist/parser}/parseBoolean.js

@@ -1,4 +1,4 @@
-import { ParseError } from './errors/ParseError';
+import { ParseError } from './errors/ParseError.js';
 const parseBoolean = (input) => {
     if ([
         true,

package/dist/parser/parseBytes.d.ts

@@ -0,0 +1,2 @@
+declare const parseBytes: import("./Parser.js").Parser<number>;
+export { parseBytes, };

package/{parser → dist/parser}/parseBytes.js

@@ -1,4 +1,4 @@
-import { createUnitParser } from './factories/unit/createUnitParser';
+import { createUnitParser } from './factories/unit/createUnitParser.js';
 const parseBytes = createUnitParser({
     type: 'bytes',
     units: [

package/{parser → dist/parser}/parseInteger.d.ts

@@ -1,3 +1,3 @@
-import type { Parser } from './Parser';
+import type { Parser } from './Parser.js';
 declare const parseInteger: Parser<number>;
 export { parseInteger, };

package/{parser → dist/parser}/parseInteger.js

@@ -1,5 +1,5 @@
-import { ParseError } from './errors/ParseError';
-import { parseNumber } from './parseNumber';
+import { ParseError } from './errors/ParseError.js';
+import { parseNumber } from './parseNumber.js';
 const parseInteger = (input) => {
     let number;
     try {

package/dist/parser/parseMilliseconds.d.ts

@@ -0,0 +1,2 @@
+declare const parseMilliseconds: import("./Parser.js").Parser<number>;
+export { parseMilliseconds, };

package/{parser → dist/parser}/parseMilliseconds.js

@@ -1,4 +1,4 @@
-import { createUnitParser } from './factories/unit/createUnitParser';
+import { createUnitParser } from './factories/unit/createUnitParser.js';
 const parseMilliseconds = createUnitParser({
     type: 'milliseconds',
     units: [

package/{parser → dist/parser}/parseNumber.d.ts

@@ -1,3 +1,3 @@
-import type { Parser } from './Parser';
+import type { Parser } from './Parser.js';
 declare const parseNumber: Parser<number>;
 export { parseNumber, };

package/{parser → dist/parser}/parseNumber.js

@@ -1,4 +1,4 @@
-import { ParseError } from './errors/ParseError';
+import { ParseError } from './errors/ParseError.js';
 const parseNumber = (input) => {
     if ([undefined, null].includes(input)) {
         return 0;

package/{parser → dist/parser}/parseString.d.ts

@@ -1,3 +1,3 @@
-import type { Parser } from './Parser';
+import type { Parser } from './Parser.js';
 declare const parseString: Parser<string>;
 export { parseString, };

package/{parser → dist/parser}/parseString.js

@@ -1,4 +1,4 @@
-import { ParseError } from './errors/ParseError';
+import { ParseError } from './errors/ParseError.js';
 const parseString = (input) => {
     if ([undefined, null].includes(input)) {
         return '';

package/{pwd → dist/pwd}/Pwd.js

@@ -1,5 +1,5 @@
 import bcrypt from 'bcryptjs';
-import { validateHashRounds } from './validateHashRounds';
+import { validateHashRounds } from './validateHashRounds.js';
 class Pwd {
     hashRounds;
     constructor(params) {

package/{pwd → dist/pwd}/errors/HashRoundsError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class HashRoundsError extends BaseError {
     constructor(hashRounds: number);
 }

package/{pwd → dist/pwd}/errors/HashRoundsError.js

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 class HashRoundsError extends BaseError {
     constructor(hashRounds) {
         super(`invalid hash rounds "${hashRounds}"`);

package/{pwd → dist/pwd}/validateHashRounds.js

@@ -1,4 +1,4 @@
-import { HashRoundsError } from './errors/HashRoundsError';
+import { HashRoundsError } from './errors/HashRoundsError.js';
 const validateHashRounds = (hashRounds) => {
     if (hashRounds < 1) {
         throw new HashRoundsError(hashRounds);

package/{server → dist/server}/Route.d.ts

@@ -1,6 +1,6 @@
-import type { Handler } from './Handler';
-import type { Method } from './Method';
-import type { Schema } from './Schema';
+import type { Handler } from './Handler.js';
+import type { Method } from './Method.js';
+import type { Schema } from './Schema.js';
 interface Route {
     path: string;
     method: Method;

package/{server → dist/server}/Server.d.ts

@@ -1,8 +1,8 @@
-import { OpenApiFormat } from './OpenApiFormat';
-import type { ErrorHandler } from './ErrorHandler';
-import type { Format } from './Format';
-import type { Handler } from './Handler';
-import type { Route } from './Route';
+import { OpenApiFormat } from './OpenApiFormat.js';
+import type { ErrorHandler } from './ErrorHandler.js';
+import type { Format } from './Format.js';
+import type { Handler } from './Handler.js';
+import type { Route } from './Route.js';
 import type { OpenAPIV3 } from 'openapi-types';
 declare class Server {
     private readonly server;

package/{server → dist/server}/Server.js

@@ -3,8 +3,8 @@ import cors from '@fastify/cors';
 import responseValidation from '@fastify/response-validation';
 import swagger from '@fastify/swagger';
 import fastify from 'fastify';
-import { OpenApiFormat } from './OpenApiFormat';
-import { getAjv } from './getAjv';
+import { OpenApiFormat } from './OpenApiFormat.js';
+import { getAjv } from './getAjv.js';
 class Server {
     server;
     host;

package/{server → dist/server}/getAjv.d.ts

@@ -1,4 +1,4 @@
 import { Ajv } from 'ajv';
-import type { Format } from './Format';
+import type { Format } from './Format.js';
 declare const getAjv: (formats?: Format[]) => Ajv;
 export { getAjv, };

package/{tls → dist/tls}/errors/FileReadError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class FileReadError extends BaseError {
     constructor(path: string, message: string);
 }

package/{env → dist/tls}/errors/FileReadError.js

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 class FileReadError extends BaseError {
     constructor(path, message) {
         super(`failed reading file "${path}": ${message}`);

package/{tls → dist/tls}/getTls.d.ts

@@ -1,4 +1,4 @@
-import type { Tls } from './Tls';
+import type { Tls } from './Tls.js';
 declare const getTls: (tls?: Tls) => {
     key?: string;
     cert?: string;

package/{tls → dist/tls}/getTls.js

@@ -1,4 +1,4 @@
-import { readFile } from './readFile';
+import { readFile } from './readFile.js';
 const getTls = (tls) => {
     return tls
         ? {

package/{tls → dist/tls}/readFile.js

@@ -1,5 +1,5 @@
 import fs from 'fs-extra';
-import { FileReadError } from './errors/FileReadError';
+import { FileReadError } from './errors/FileReadError.js';
 const readFile = (path) => {
     try {
         if (fs.existsSync(path)) {