@innet/server 1.7.0 → 2.0.0-alpha.0

package/hooks/useCookies/useCookies.js

@@ -2,10 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+require('../useAction/index.js');
 var useAction = require('../useAction/useAction.js');
 
-function useCookies() {
-    return useAction.useAction().cookies;
+function useCookies() {
+    return useAction.useAction().cookies;
 }
 
 exports.useCookies = useCookies;

package/hooks/useEndpoint/index.d.ts

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

package/hooks/useEndpoint/index.es6.js

@@ -0,0 +1 @@
+export { endpointContext, useEndpoint } from './useEndpoint.es6.js';

package/hooks/useEndpoint/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useEndpoint = require('./useEndpoint.js');
+
+
+
+exports.endpointContext = useEndpoint.endpointContext;
+exports.useEndpoint = useEndpoint.useEndpoint;

package/hooks/useEndpoint/useEndpoint.d.ts

@@ -0,0 +1,10 @@
+import { Context } from '@innet/jsx';
+import { type EndpointProps } from '../../plugins';
+import type { Endpoint, OperationObject } from '../../types';
+export interface EndpointContext {
+    operation: OperationObject;
+    props: EndpointProps;
+    endpoint: Endpoint;
+}
+export declare const endpointContext: Context<EndpointContext, EndpointContext | undefined>;
+export declare function useEndpoint(): EndpointContext;

package/hooks/useEndpoint/useEndpoint.es6.js

@@ -0,0 +1,12 @@
+import { Context, useContext } from '@innet/jsx';
+
+const endpointContext = new Context();
+function useEndpoint() {
+    const endpoint = useContext(endpointContext);
+    if (!endpoint) {
+        throw Error('useEndpoint MUST be used in <endpoint>');
+    }
+    return endpoint;
+}
+
+export { endpointContext, useEndpoint };

package/hooks/useEndpoint/useEndpoint.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+
+const endpointContext = new jsx.Context();
+function useEndpoint() {
+    const endpoint = jsx.useContext(endpointContext);
+    if (!endpoint) {
+        throw Error('useEndpoint MUST be used in <endpoint>');
+    }
+    return endpoint;
+}
+
+exports.endpointContext = endpointContext;
+exports.useEndpoint = useEndpoint;

package/hooks/useHeaders/index.d.ts

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

package/hooks/useHeaders/index.es6.js

@@ -0,0 +1 @@
+export { useHeaders } from './useHeaders.es6.js';

package/hooks/useHeaders/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useHeaders = require('./useHeaders.js');
+
+
+
+exports.useHeaders = useHeaders.useHeaders;

package/hooks/useHeaders/useHeaders.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { type IncomingHttpHeaders } from 'http';
+export declare function useHeaders<D extends IncomingHttpHeaders>(): D;

package/hooks/useHeaders/useHeaders.es6.js

@@ -0,0 +1,8 @@
+import '../useAction/index.es6.js';
+import { useAction } from '../useAction/useAction.es6.js';
+
+function useHeaders() {
+    return useAction().headers;
+}
+
+export { useHeaders };

package/hooks/useHeaders/useHeaders.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../useAction/index.js');
+var useAction = require('../useAction/useAction.js');
+
+function useHeaders() {
+    return useAction.useAction().headers;
+}
+
+exports.useHeaders = useHeaders;

package/hooks/useHost/index.d.ts

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

package/hooks/useHost/index.es6.js

@@ -0,0 +1 @@
+export { hostContext, useHost } from './useHost.es6.js';

package/hooks/useHost/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useHost = require('./useHost.js');
+
+
+
+exports.hostContext = useHost.hostContext;
+exports.useHost = useHost.useHost;

package/hooks/useHost/useHost.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '@innet/jsx';
+import { type ServerObject } from '../../types';
+export interface HostContext {
+    server: ServerObject;
+}
+export declare const hostContext: Context<HostContext, HostContext | undefined>;
+export declare function useHost(): HostContext;

package/hooks/useHost/useHost.es6.js

@@ -0,0 +1,12 @@
+import { Context, useContext } from '@innet/jsx';
+
+const hostContext = new Context();
+function useHost() {
+    const host = useContext(hostContext);
+    if (!host) {
+        throw Error('Use `useHost` in <host>');
+    }
+    return host;
+}
+
+export { hostContext, useHost };

package/hooks/useHost/useHost.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+
+const hostContext = new jsx.Context();
+function useHost() {
+    const host = jsx.useContext(hostContext);
+    if (!host) {
+        throw Error('Use `useHost` in <host>');
+    }
+    return host;
+}
+
+exports.hostContext = hostContext;
+exports.useHost = useHost;

package/hooks/useNewSchema/index.d.ts

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

package/hooks/useNewSchema/index.es6.js

@@ -0,0 +1 @@
+export { useNewSchema } from './useNewSchema.es6.js';

package/hooks/useNewSchema/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useNewSchema = require('./useNewSchema.js');
+
+
+
+exports.useNewSchema = useNewSchema.useNewSchema;

package/hooks/useNewSchema/useNewSchema.d.ts

@@ -0,0 +1,2 @@
+import { type RefSchemaObject, type SchemaObject } from '../../types';
+export declare function useNewSchema<T extends RefSchemaObject = SchemaObject>(schema?: T): T;

package/hooks/useNewSchema/useNewSchema.es6.js

@@ -0,0 +1,32 @@
+import '../useSchemaContext/index.es6.js';
+import '../useThrow/index.es6.js';
+import { useSchemaContext } from '../useSchemaContext/useSchemaContext.es6.js';
+import { useThrow } from '../useThrow/useThrow.es6.js';
+
+function useNewSchema(schema = Object.create(null)) {
+    const parentSchema = useSchemaContext();
+    if (!parentSchema) {
+        useThrow('Use <{type}> inside one of <response>, <param> or <body>');
+    }
+    if (Array.isArray(parentSchema)) {
+        parentSchema.push(schema);
+    }
+    else if (parentSchema.oneOf) {
+        parentSchema.oneOf.push(schema);
+    }
+    else if (parentSchema.type) {
+        const oldSchema = Object.assign({}, parentSchema);
+        for (const key in parentSchema) {
+            // @ts-expect-error: FIXME
+            delete parentSchema[key];
+        }
+        parentSchema.oneOf = [oldSchema, schema];
+    }
+    else {
+        Object.assign(parentSchema, schema);
+        return parentSchema;
+    }
+    return schema;
+}
+
+export { useNewSchema };

package/hooks/useNewSchema/useNewSchema.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../useSchemaContext/index.js');
+require('../useThrow/index.js');
+var useSchemaContext = require('../useSchemaContext/useSchemaContext.js');
+var useThrow = require('../useThrow/useThrow.js');
+
+function useNewSchema(schema = Object.create(null)) {
+    const parentSchema = useSchemaContext.useSchemaContext();
+    if (!parentSchema) {
+        useThrow.useThrow('Use <{type}> inside one of <response>, <param> or <body>');
+    }
+    if (Array.isArray(parentSchema)) {
+        parentSchema.push(schema);
+    }
+    else if (parentSchema.oneOf) {
+        parentSchema.oneOf.push(schema);
+    }
+    else if (parentSchema.type) {
+        const oldSchema = Object.assign({}, parentSchema);
+        for (const key in parentSchema) {
+            // @ts-expect-error: FIXME
+            delete parentSchema[key];
+        }
+        parentSchema.oneOf = [oldSchema, schema];
+    }
+    else {
+        Object.assign(parentSchema, schema);
+        return parentSchema;
+    }
+    return schema;
+}
+
+exports.useNewSchema = useNewSchema;

package/hooks/useObjectRule/index.d.ts

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

package/hooks/useObjectRule/index.es6.js

@@ -0,0 +1 @@
+export { objectRuleContext, useObjectRule } from './useObjectRule.es6.js';

package/hooks/useObjectRule/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useObjectRule = require('./useObjectRule.js');
+
+
+
+exports.objectRuleContext = useObjectRule.objectRuleContext;
+exports.useObjectRule = useObjectRule.useObjectRule;

package/hooks/useObjectRule/useObjectRule.d.ts

@@ -0,0 +1,4 @@
+import { Context } from '@innet/jsx';
+import { type ObjectOf } from '../../utils/rules';
+export declare const objectRuleContext: Context<ObjectOf, null>;
+export declare function useObjectRule(): ObjectOf;

package/hooks/useObjectRule/useObjectRule.es6.js

@@ -0,0 +1,14 @@
+import { Context, useContext } from '@innet/jsx';
+import '../useThrow/index.es6.js';
+import { useThrow } from '../useThrow/useThrow.es6.js';
+
+const objectRuleContext = new Context(null);
+function useObjectRule() {
+    const map = useContext(objectRuleContext);
+    if (!map) {
+        useThrow('Use <{type}> inside <object>');
+    }
+    return map;
+}
+
+export { objectRuleContext, useObjectRule };

package/hooks/useObjectRule/useObjectRule.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../useThrow/index.js');
+var useThrow = require('../useThrow/useThrow.js');
+
+const objectRuleContext = new jsx.Context(null);
+function useObjectRule() {
+    const map = jsx.useContext(objectRuleContext);
+    if (!map) {
+        useThrow.useThrow('Use <{type}> inside <object>');
+    }
+    return map;
+}
+
+exports.objectRuleContext = objectRuleContext;
+exports.useObjectRule = useObjectRule;

package/hooks/useOneElementError/index.d.ts

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

package/hooks/useOneElementError/index.es6.js

@@ -0,0 +1 @@
+export { useOneElementError } from './useOneElementError.es6.js';

package/hooks/useOneElementError/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useOneElementError = require('./useOneElementError.js');
+
+
+
+exports.useOneElementError = useOneElementError.useOneElementError;

package/hooks/useOneElementError/useOneElementError.d.ts

@@ -0,0 +1 @@
+export declare function useOneElementError(): void;

package/hooks/useOneElementError/useOneElementError.es6.js

@@ -0,0 +1,8 @@
+import { useApp } from 'innet';
+
+function useOneElementError() {
+    const { type } = useApp();
+    throw Error(`You can use only one <${type}> in <api>`);
+}
+
+export { useOneElementError };

package/hooks/useOneElementError/useOneElementError.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+
+function useOneElementError() {
+    const { type } = innet.useApp();
+    throw Error(`You can use only one <${type}> in <api>`);
+}
+
+exports.useOneElementError = useOneElementError;

package/hooks/useParam/index.d.ts

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

package/hooks/useParam/index.es6.js

@@ -0,0 +1 @@
+export { paramContext, useParam } from './useParam.es6.js';

package/hooks/useParam/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useParam = require('./useParam.js');
+
+
+
+exports.paramContext = useParam.paramContext;
+exports.useParam = useParam.useParam;

package/hooks/useParam/useParam.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '@innet/jsx';
+import { type ParamProps } from '../../plugins';
+export interface ParamContext {
+    props: ParamProps;
+}
+export declare const paramContext: Context<ParamContext, ParamContext | undefined>;
+export declare function useParam(): ParamContext;

package/hooks/useParam/useParam.es6.js

@@ -0,0 +1,12 @@
+import { Context, useContext } from '@innet/jsx';
+
+const paramContext = new Context();
+function useParam() {
+    const param = useContext(paramContext);
+    if (!param) {
+        throw Error('`useParam` MUST be used in <param>');
+    }
+    return param;
+}
+
+export { paramContext, useParam };

package/hooks/useParam/useParam.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+
+const paramContext = new jsx.Context();
+function useParam() {
+    const param = jsx.useContext(paramContext);
+    if (!param) {
+        throw Error('`useParam` MUST be used in <param>');
+    }
+    return param;
+}
+
+exports.paramContext = paramContext;
+exports.useParam = useParam;

package/hooks/useParams/index.d.ts

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

package/hooks/useParams/index.es6.js

@@ -0,0 +1 @@
+export { paramsContext, useParams } from './useParams.es6.js';

package/hooks/useParams/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useParams = require('./useParams.js');
+
+
+
+exports.paramsContext = useParams.paramsContext;
+exports.useParams = useParams.useParams;

package/hooks/useParams/useParams.d.ts

@@ -0,0 +1,3 @@
+import { Context } from '@innet/jsx';
+export declare const paramsContext: Context<any, {}>;
+export declare function useParams<D>(): D;

package/hooks/useParams/useParams.es6.js

@@ -0,0 +1,8 @@
+import { Context, useContext } from '@innet/jsx';
+
+const paramsContext = new Context({});
+function useParams() {
+    return useContext(paramsContext);
+}
+
+export { paramsContext, useParams };

package/hooks/useParams/useParams.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+
+const paramsContext = new jsx.Context({});
+function useParams() {
+    return jsx.useContext(paramsContext);
+}
+
+exports.paramsContext = paramsContext;
+exports.useParams = useParams;

package/hooks/useParentRule/index.d.ts

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

package/hooks/useParentRule/index.es6.js

@@ -0,0 +1 @@
+export { parentRuleContext, useParentRule } from './useParentRule.es6.js';

package/hooks/useParentRule/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useParentRule = require('./useParentRule.js');
+
+
+
+exports.parentRuleContext = useParentRule.parentRuleContext;
+exports.useParentRule = useParentRule.useParentRule;

package/hooks/useParentRule/useParentRule.d.ts

@@ -0,0 +1,4 @@
+import { Context } from '@innet/jsx';
+import { type SetRule } from '../../utils';
+export declare const parentRuleContext: Context<SetRule, SetRule>;
+export declare function useParentRule(): SetRule;

package/hooks/useParentRule/useParentRule.es6.js

@@ -0,0 +1,10 @@
+import { Context, useContext } from '@innet/jsx';
+import '../../utils/index.es6.js';
+import { optional } from '../../utils/rules/optional/optional.es6.js';
+
+const parentRuleContext = new Context(rule => optional(rule));
+function useParentRule() {
+    return useContext(parentRuleContext);
+}
+
+export { parentRuleContext, useParentRule };

package/hooks/useParentRule/useParentRule.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../../utils/index.js');
+var optional = require('../../utils/rules/optional/optional.js');
+
+const parentRuleContext = new jsx.Context(rule => optional.optional(rule));
+function useParentRule() {
+    return jsx.useContext(parentRuleContext);
+}
+
+exports.parentRuleContext = parentRuleContext;
+exports.useParentRule = useParentRule;

package/hooks/usePath/index.d.ts

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

package/hooks/usePath/index.es6.js

@@ -0,0 +1 @@
+export { usePath } from './usePath.es6.js';

package/hooks/usePath/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var usePath = require('./usePath.js');
+
+
+
+exports.usePath = usePath.usePath;

package/hooks/usePath/usePath.d.ts

@@ -0,0 +1 @@
+export declare function usePath(): string;

package/hooks/usePath/usePath.es6.js

@@ -0,0 +1,8 @@
+import '../useAction/index.es6.js';
+import { useAction } from '../useAction/useAction.es6.js';
+
+function usePath() {
+    return useAction().path;
+}
+
+export { usePath };

package/hooks/{useFiles/useFiles.js → usePath/usePath.js}

@@ -2,10 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+require('../useAction/index.js');
 var useAction = require('../useAction/useAction.js');
 
-function useFiles() {
-    return useAction.useAction().files;
+function usePath() {
+    return useAction.useAction().path;
 }
 
-exports.useFiles = useFiles;
+exports.usePath = usePath;

package/hooks/useRequest/index.d.ts

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

package/hooks/useRequest/index.es6.js

@@ -0,0 +1 @@
+export { requestContext, useRequest } from './useRequest.es6.js';

package/hooks/useRequest/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useRequest = require('./useRequest.js');
+
+
+
+exports.requestContext = useRequest.requestContext;
+exports.useRequest = useRequest.useRequest;

package/hooks/useRequest/useRequest.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { Context } from '@innet/jsx';
+import { type IncomingMessage } from 'http';
+export declare const requestContext: Context<IncomingMessage, IncomingMessage | undefined>;
+export declare function useRequest(): IncomingMessage | undefined;

package/hooks/useRequest/useRequest.es6.js

@@ -0,0 +1,8 @@
+import { Context, useContext } from '@innet/jsx';
+
+const requestContext = new Context();
+function useRequest() {
+    return useContext(requestContext);
+}
+
+export { requestContext, useRequest };

package/hooks/useRequest/useRequest.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+
+const requestContext = new jsx.Context();
+function useRequest() {
+    return jsx.useContext(requestContext);
+}
+
+exports.requestContext = requestContext;
+exports.useRequest = useRequest;

package/hooks/useResponse/index.d.ts

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