openclaw/helpyourneighbour
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(auth): implement user authentication system

Browse source
This commit is contained in:
J.A.R.V.I.S. 2026-03-19 23:10:50 +00:00
parent 4847ab793a
commit 25cea4fbe8
12051 changed files with 1462377 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

22
backend/node_modules/@jest/transform/LICENSE generated vendored Normal file
View file

@ -0,0 +1,22 @@
MIT License
Copyright (c) Meta Platforms, Inc. and affiliates.
Copyright Contributors to the Jest project.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

238
backend/node_modules/@jest/transform/build/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,238 @@
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
import {EncodedSourceMap} from '@jridgewell/trace-mapping';
import {Config, TransformTypes} from '@jest/types';
export declare interface AsyncTransformer<TransformerConfig = unknown> {
/**
* Indicates if the transformer is capable of instrumenting the code for code coverage.
*
* If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented.
* If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel.
*/
canInstrument?: boolean;
getCacheKey?: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => string;
getCacheKeyAsync?: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => Promise<string>;
process?: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => TransformedSource;
processAsync: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => Promise<TransformedSource>;
}
export declare interface CallerTransformOptions {
supportsDynamicImport: boolean;
supportsExportNamespaceFrom: boolean;
supportsStaticESM: boolean;
supportsTopLevelAwait: boolean;
}
export declare function createScriptTransformer(
config: Config.ProjectConfig,
cacheFS?: StringMap,
): Promise<ScriptTransformer>;
export declare function createTranspilingRequire(
config: Config.ProjectConfig,
): Promise<
<TModuleType = unknown>(
resolverPath: string,
applyInteropRequireDefault?: boolean,
) => Promise<TModuleType>
>;
declare interface ErrorWithCodeFrame extends Error {
codeFrame?: string;
}
declare interface FixedRawSourceMap extends Omit<EncodedSourceMap, 'version'> {
version: number;
}
export declare function handlePotentialSyntaxError(
e: ErrorWithCodeFrame,
): ErrorWithCodeFrame;
declare interface ReducedTransformOptions extends CallerTransformOptions {
instrument: boolean;
}
declare interface RequireAndTranspileModuleOptions extends ReducedTransformOptions {
applyInteropRequireDefault: boolean;
}
export declare type ScriptTransformer = ScriptTransformer_2;
declare class ScriptTransformer_2 {
private readonly _config;
private readonly _cacheFS;
private readonly _cache;
private readonly _transformCache;
private _transformsAreLoaded;
constructor(_config: Config.ProjectConfig, _cacheFS: StringMap);
private _buildCacheKeyFromFileInfo;
private _buildTransformCacheKey;
private _getCacheKey;
private _getCacheKeyAsync;
private _createCachedFilename;
private _getFileCachePath;
private _getFileCachePathAsync;
private _getTransformPatternAndPath;
private _getTransformPath;
loadTransformers(): Promise<void>;
private _getTransformer;
private _instrumentFile;
private _buildTransformResult;
transformSource(
filepath: string,
content: string,
options: ReducedTransformOptions,
): TransformResult;
transformSourceAsync(
filepath: string,
content: string,
options: ReducedTransformOptions,
): Promise<TransformResult>;
private _transformAndBuildScriptAsync;
private _transformAndBuildScript;
transformAsync(
filename: string,
options: TransformationOptions,
fileSource?: string,
): Promise<TransformResult>;
transform(
filename: string,
options: TransformationOptions,
fileSource?: string,
): TransformResult;
transformJson(
filename: string,
options: TransformationOptions,
fileSource: string,
): string;
requireAndTranspileModule<ModuleType = unknown>(
moduleName: string,
callback?: (module: ModuleType) => void | Promise<void>,
options?: RequireAndTranspileModuleOptions,
): Promise<ModuleType>;
shouldTransform(filename: string): boolean;
}
export declare function shouldInstrument(
filename: string,
options: ShouldInstrumentOptions,
config: Config.ProjectConfig,
loadedFilenames?: Array<string>,
): boolean;
export declare interface ShouldInstrumentOptions extends Pick<
Config.GlobalConfig,
'collectCoverage' | 'collectCoverageFrom' | 'coverageProvider'
> {
changedFiles?: Set<string>;
sourcesRelatedToTestsInChangedFiles?: Set<string>;
}
declare type StringMap = Map<string, string>;
export declare interface SyncTransformer<TransformerConfig = unknown> {
/**
* Indicates if the transformer is capable of instrumenting the code for code coverage.
*
* If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented.
* If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel.
*/
canInstrument?: boolean;
getCacheKey?: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => string;
getCacheKeyAsync?: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => Promise<string>;
process: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => TransformedSource;
processAsync?: (
sourceText: string,
sourcePath: string,
options: TransformOptions<TransformerConfig>,
) => Promise<TransformedSource>;
}
export declare interface TransformationOptions
extends ShouldInstrumentOptions, CallerTransformOptions {
isInternalModule?: boolean;
}
export declare type TransformedSource = {
code: string;
map?: FixedRawSourceMap | string | null;
};
/**
* We have both sync (`process`) and async (`processAsync`) code transformation, which both can be provided.
* `require` will always use `process`, and `import` will use `processAsync` if it exists, otherwise fall back to `process`.
* Meaning, if you use `import` exclusively you do not need `process`, but in most cases supplying both makes sense:
* Jest transpiles on demand rather than ahead of time, so the sync one needs to exist.
*
* For more info on the sync vs async model, see https://jestjs.io/docs/code-transformation#writing-custom-transformers
*/
declare type Transformer_2<TransformerConfig = unknown> =
| SyncTransformer<TransformerConfig>
| AsyncTransformer<TransformerConfig>;
export {Transformer_2 as Transformer};
export declare type TransformerCreator<
X extends Transformer_2<TransformerConfig>,
TransformerConfig = unknown,
> = (transformerConfig?: TransformerConfig) => X | Promise<X>;
/**
* Instead of having your custom transformer implement the Transformer interface
* directly, you can choose to export a factory function to dynamically create
* transformers. This is to allow having a transformer config in your jest config.
*/
export declare type TransformerFactory<X extends Transformer_2> = {
createTransformer: TransformerCreator<X>;
};
export declare interface TransformOptions<
TransformerConfig = unknown,
> extends ReducedTransformOptions {
/** Cached file system which is used by `jest-runtime` to improve performance. */
cacheFS: StringMap;
/** Jest configuration of currently running project. */
config: Config.ProjectConfig;
/** Stringified version of the `config` - useful in cache busting. */
configString: string;
/** Transformer configuration passed through `transform` option by the user. */
transformerConfig: TransformerConfig;
}
export declare type TransformResult = TransformTypes.TransformResult;
export {};

1084
backend/node_modules/@jest/transform/build/index.js generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

6
backend/node_modules/@jest/transform/build/index.mjs generated vendored Normal file
View file

@ -0,0 +1,6 @@
import cjsModule from './index.js';
export const createScriptTransformer = cjsModule.createScriptTransformer;
export const createTranspilingRequire = cjsModule.createTranspilingRequire;
export const handlePotentialSyntaxError = cjsModule.handlePotentialSyntaxError;
export const shouldInstrument = cjsModule.shouldInstrument;

52
backend/node_modules/@jest/transform/package.json generated vendored Normal file
View file

@ -0,0 +1,52 @@
{
"name": "@jest/transform",
"version": "30.3.0",
"repository": {
"type": "git",
"url": "https://github.com/jestjs/jest.git",
"directory": "packages/jest-transform"
},
"license": "MIT",
"main": "./build/index.js",
"types": "./build/index.d.ts",
"exports": {
".": {
"types": "./build/index.d.ts",
"require": "./build/index.js",
"import": "./build/index.mjs",
"default": "./build/index.js"
},
"./package.json": "./package.json"
},
"dependencies": {
"@babel/core": "^7.27.4",
"@jest/types": "30.3.0",
"@jridgewell/trace-mapping": "^0.3.25",
"babel-plugin-istanbul": "^7.0.1",
"chalk": "^4.1.2",
"convert-source-map": "^2.0.0",
"fast-json-stable-stringify": "^2.1.0",
"graceful-fs": "^4.2.11",
"jest-haste-map": "30.3.0",
"jest-regex-util": "30.0.1",
"jest-util": "30.3.0",
"pirates": "^4.0.7",
"slash": "^3.0.0",
"write-file-atomic": "^5.0.1"
},
"devDependencies": {
"@jest/test-utils": "30.3.0",
"@types/babel__core": "^7.20.5",
"@types/convert-source-map": "^2.0.3",
"@types/graceful-fs": "^4.1.9",
"@types/write-file-atomic": "^4.0.3",
"dedent": "^1.6.0"
},
"engines": {
"node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
},
"publishConfig": {
"access": "public"
},
"gitHead": "efb59c2e81083f8dc941f20d6d20a3af2dc8d068"
}