repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
joscha/fast-glob
|
src/utils/pattern.spec.ts
|
import * as assert from 'assert';
import { Pattern } from '../types';
import * as util from './pattern';
describe('Utils → Pattern', () => {
describe('.isStaticPattern', () => {
it('should return true for static pattern', () => {
const actual = util.isStaticPattern('dir');
assert.ok(actual);
});
it('should return false for dynamic pattern', () => {
const actual = util.isStaticPattern('*');
assert.ok(!actual);
});
});
describe('.isDynamicPattern', () => {
describe('Without options', () => {
it('should return true for patterns that include the escape symbol', () => {
assert.ok(util.isDynamicPattern('\\'));
});
it('should return true for patterns that include common glob symbols', () => {
assert.ok(util.isDynamicPattern('*'));
assert.ok(util.isDynamicPattern('abc/*'));
assert.ok(util.isDynamicPattern('?'));
assert.ok(util.isDynamicPattern('abc/?'));
assert.ok(util.isDynamicPattern('!abc'));
});
it('should return true for patterns that include regex group symbols', () => {
assert.ok(util.isDynamicPattern('(a|)'));
assert.ok(util.isDynamicPattern('(a|b)'));
assert.ok(util.isDynamicPattern('abc/(a|b)'));
});
it('should return true for patterns that include regex character class symbols', () => {
assert.ok(util.isDynamicPattern('[abc]'));
assert.ok(util.isDynamicPattern('abc/[abc]'));
assert.ok(util.isDynamicPattern('[^abc]'));
assert.ok(util.isDynamicPattern('abc/[^abc]'));
assert.ok(util.isDynamicPattern('[1-3]'));
assert.ok(util.isDynamicPattern('abc/[1-3]'));
assert.ok(util.isDynamicPattern('[[:alpha:][:digit:]]'));
assert.ok(util.isDynamicPattern('abc/[[:alpha:][:digit:]]'));
});
it('should return true for patterns that include glob extension symbols', () => {
assert.ok(util.isDynamicPattern('@()'));
assert.ok(util.isDynamicPattern('@(a)'));
assert.ok(util.isDynamicPattern('@(a|b)'));
assert.ok(util.isDynamicPattern('abc/!(a|b)'));
assert.ok(util.isDynamicPattern('*(a|b)'));
assert.ok(util.isDynamicPattern('?(a|b)'));
assert.ok(util.isDynamicPattern('+(a|b)'));
});
it('should return true for patterns that include brace expansions symbols', () => {
assert.ok(util.isDynamicPattern('{,}'));
assert.ok(util.isDynamicPattern('{a,}'));
assert.ok(util.isDynamicPattern('{,b}'));
assert.ok(util.isDynamicPattern('{a,b}'));
assert.ok(util.isDynamicPattern('{1..3}'));
});
it('should return false for "!" symbols when a symbol is not specified first in the string', () => {
assert.ok(!util.isDynamicPattern('abc!'));
});
it('should return false for a completely static pattern', () => {
assert.ok(!util.isDynamicPattern(''));
assert.ok(!util.isDynamicPattern('.'));
assert.ok(!util.isDynamicPattern('abc'));
assert.ok(!util.isDynamicPattern('~abc'));
assert.ok(!util.isDynamicPattern('~/abc'));
assert.ok(!util.isDynamicPattern('+~/abc'));
assert.ok(!util.isDynamicPattern('@.(abc)'));
assert.ok(!util.isDynamicPattern('(a b)'));
assert.ok(!util.isDynamicPattern('(a b)'));
assert.ok(!util.isDynamicPattern('[abc'));
});
it('should return false for unfinished regex character class', () => {
assert.ok(!util.isDynamicPattern('['));
assert.ok(!util.isDynamicPattern('[abc'));
});
it('should return false for unfinished regex group', () => {
assert.ok(!util.isDynamicPattern('(a|b'));
assert.ok(!util.isDynamicPattern('abc/(a|b'));
});
it('should return false for unfinished glob extension', () => {
assert.ok(!util.isDynamicPattern('@('));
assert.ok(!util.isDynamicPattern('@(a'));
assert.ok(!util.isDynamicPattern('@(a|'));
assert.ok(!util.isDynamicPattern('@(a|b'));
});
it('should return false for unfinished brace expansions', () => {
assert.ok(!util.isDynamicPattern('{'));
assert.ok(!util.isDynamicPattern('{a'));
assert.ok(!util.isDynamicPattern('{,'));
assert.ok(!util.isDynamicPattern('{a,'));
assert.ok(!util.isDynamicPattern('{a,b'));
});
});
describe('With options', () => {
it('should return true for patterns that include "*?" symbols even when the "extglob" option is disabled', () => {
assert.ok(util.isDynamicPattern('*(a|b)', { extglob: false }));
assert.ok(util.isDynamicPattern('?(a|b)', { extglob: false }));
});
it('should return true when the "caseSensitiveMatch" option is enabled', () => {
assert.ok(util.isDynamicPattern('a', { caseSensitiveMatch: false }));
});
it('should return false for glob extension when the "extglob" option is disabled', () => {
assert.ok(!util.isDynamicPattern('@(a|b)', { extglob: false }));
assert.ok(!util.isDynamicPattern('abc/!(a|b)', { extglob: false }));
assert.ok(!util.isDynamicPattern('+(a|b)', { extglob: false }));
});
it('should return false for brace expansions when the "braceExpansion" option is disabled', () => {
assert.ok(!util.isDynamicPattern('{a,b}', { braceExpansion: false }));
assert.ok(!util.isDynamicPattern('{1..3}', { braceExpansion: false }));
});
});
});
describe('.convertToPositivePattern', () => {
it('should returns converted positive pattern', () => {
const expected = '*.js';
const actual = util.convertToPositivePattern('!*.js');
assert.strictEqual(actual, expected);
});
it('should returns pattern without changes', () => {
const expected = '*.js';
const actual = util.convertToPositivePattern('*.js');
assert.strictEqual(actual, expected);
});
});
describe('.convertToNegativePattern', () => {
it('should returns converted negative pattern', () => {
const expected = '!*.js';
const actual = util.convertToNegativePattern('*.js');
assert.strictEqual(actual, expected);
});
});
describe('.isNegativePattern', () => {
it('should returns true', () => {
const actual = util.isNegativePattern('!*.md');
assert.ok(actual);
});
it('should returns false', () => {
const actual = util.isNegativePattern('*.md');
assert.ok(!actual);
});
it('should returns false for extglob', () => {
const actual = util.isNegativePattern('!(a|b|c)');
assert.ok(!actual);
});
});
describe('.isPositivePattern', () => {
it('should returns true', () => {
const actual = util.isPositivePattern('*.md');
assert.ok(actual);
});
it('should returns false', () => {
const actual = util.isPositivePattern('!*.md');
assert.ok(!actual);
});
});
describe('.getNegativePatterns', () => {
it('should returns only negative patterns', () => {
const expected = ['!*.spec.js'];
const actual = util.getNegativePatterns(['*.js', '!*.spec.js', '*.ts']);
assert.deepStrictEqual(actual, expected);
});
it('should returns empty array', () => {
const expected: Pattern[] = [];
const actual = util.getNegativePatterns(['*.js', '*.ts']);
assert.deepStrictEqual(actual, expected);
});
});
describe('.getPositivePatterns', () => {
it('should returns only positive patterns', () => {
const expected = ['*.js', '*.ts'];
const actual = util.getPositivePatterns(['*.js', '!*.spec.js', '*.ts']);
assert.deepStrictEqual(actual, expected);
});
it('should returns empty array', () => {
const expected: Pattern[] = [];
const actual = util.getPositivePatterns(['!*.js', '!*.ts']);
assert.deepStrictEqual(actual, expected);
});
});
describe('.getBaseDirectory', () => {
it('should returns base directory', () => {
const expected = 'root';
const actual = util.getBaseDirectory('root/*.js');
assert.strictEqual(actual, expected);
});
it('should returns base directory without slash transformation', () => {
const expected = '.';
const actual = util.getBaseDirectory('file-\\(suffix\\).md');
assert.strictEqual(actual, expected);
});
});
describe('.hasGlobStar', () => {
it('should returns true for pattern that includes globstar', () => {
const actual = util.hasGlobStar('**/*.js');
assert.ok(actual);
});
it('should returns false for pattern that has no globstar', () => {
const actual = util.hasGlobStar('*.js');
assert.ok(!actual);
});
});
describe('.endsWithSlashGlobStar', () => {
it('should returns true for pattern that ends with slash and globstar', () => {
const actual = util.endsWithSlashGlobStar('name/**');
assert.ok(actual);
});
it('should returns false for pattern that has no slash, but ends with globstar', () => {
const actual = util.endsWithSlashGlobStar('**');
assert.ok(!actual);
});
it('should returns false for pattern that does not ends with globstar', () => {
const actual = util.endsWithSlashGlobStar('name/**/*');
assert.ok(!actual);
});
});
describe('.isAffectDepthOfReadingPattern', () => {
it('should return true for pattern that ends with slash and globstar', () => {
const actual = util.isAffectDepthOfReadingPattern('name/**');
assert.ok(actual);
});
it('should return true for pattern when the last partial of the pattern is static pattern', () => {
const actual = util.isAffectDepthOfReadingPattern('**/name');
assert.ok(actual);
});
it('should return false', () => {
const actual = util.isAffectDepthOfReadingPattern('**/name/*');
assert.ok(!actual);
});
});
describe('.getNaiveDepth', () => {
it('should return 0', () => {
const expected = 0; // 1 (pattern) - 1 (base directory)
const actual = util.getNaiveDepth('*.js');
assert.strictEqual(actual, expected);
});
it('should returns 1', () => {
const expected = 1; // 4 (pattern) - 2 (base directory) - 1
const actual = util.getNaiveDepth('a/b/*/*.js');
assert.strictEqual(actual, expected);
});
});
describe('.getMaxNaivePatternsDepth', () => {
it('should return 1', () => {
const expected = 1;
const actual = util.getMaxNaivePatternsDepth(['*.js', './*.js']);
assert.strictEqual(actual, expected);
});
it('should return 2', () => {
const expected = 2;
const actual = util.getMaxNaivePatternsDepth(['*.js', './*/*.js']);
assert.strictEqual(actual, expected);
});
});
describe('.makeRE', () => {
it('should return regexp for provided pattern', () => {
const actual = util.makeRe('*.js', {});
assert.ok(actual instanceof RegExp);
});
});
describe('.convertPatternsToRe', () => {
it('should return regexps for provided patterns', () => {
const [actual] = util.convertPatternsToRe(['*.js'], {});
assert.ok(actual instanceof RegExp);
});
});
describe('.matchAny', () => {
it('should return true', () => {
const actual = util.matchAny('fixtures/nested/file.txt', [/fixture/, /fixtures\/nested\/file/]);
assert.ok(actual);
});
it('should return false', () => {
const actual = util.matchAny('fixtures/directory', [/fixtures\/file/]);
assert.ok(!actual);
});
it('should return true for path with leading slash', () => {
const pattern = util.makeRe('*.js', {});
const actual = util.matchAny('./test.js', [pattern]);
assert.ok(actual);
});
});
});
|
joscha/fast-glob
|
src/providers/async.ts
|
import { Task } from '../managers/tasks';
import ReaderStream from '../readers/stream';
import { Entry, EntryItem, ReaderOptions } from '../types';
import Provider from './provider';
export default class ProviderAsync extends Provider<Promise<EntryItem[]>> {
protected _reader: ReaderStream = new ReaderStream(this._settings);
public read(task: Task): Promise<EntryItem[]> {
const root = this._getRootDirectory(task);
const options = this._getReaderOptions(task);
const entries: EntryItem[] = [];
return new Promise((resolve, reject) => {
const stream = this.api(root, task, options);
stream.once('error', reject);
stream.on('data', (entry: Entry) => entries.push(options.transform(entry)));
stream.once('end', () => resolve(entries));
});
}
public api(root: string, task: Task, options: ReaderOptions): NodeJS.ReadableStream {
if (task.dynamic) {
return this._reader.dynamic(root, options);
}
return this._reader.static(task.patterns, options);
}
}
|
joscha/fast-glob
|
src/utils/stream.ts
|
import * as merge2 from 'merge2';
export function merge(streams: NodeJS.ReadableStream[]): NodeJS.ReadableStream {
const mergedStream = merge2(streams);
streams.forEach((stream) => {
stream.once('error', (error) => mergedStream.emit('error', error));
});
return mergedStream;
}
|
andreubotella/swc
|
crates/swc/tests/fixture/issue-3073/2/output/index.ts
|
var Foo;
(function(Foo1) {
var ref;
ref = {
a: 1,
b: 2
}, Foo1.A = ref.a, Foo1.B = ref.b, ref;
})(Foo || (Foo = {
}));
|
ksenonadv/ragemp-types
|
packages/client/game/cam.d.ts
|
<filename>packages/client/game/cam.d.ts
declare interface GameCamLegacy {
renderScriptCams(render: boolean, ease: boolean, easeTime: number, p3: boolean, p4: boolean, p5: number): void;
createCam(camName: string, p1: boolean): number;
createCamWithParams(
camName: string,
posX: number,
posY: number,
posZ: number,
rotX: number,
rotY: number,
rotZ: number,
fov: number,
p8: boolean,
p9: number
): number;
createCamera(camHash: number, p1: boolean): number;
createCameraWithParams(
camHash: number,
posX: number,
posY: number,
posZ: number,
rotX: number,
rotY: number,
rotZ: number,
fov: number,
p8: boolean,
p9: number
): number;
destroyAllCams(bScriptHostCam: boolean): void;
addCamSplineNode(
camera: number,
x: number,
y: number,
z: number,
xRot: number,
yRot: number,
zRot: number,
length: number,
p8: number,
p9: number
): void;
setCamSplinePhase(cam: number, p1: number): void;
getCamSplineNodePhase(cam: number): number;
setCamSplineDuration(cam: number, timeDuration: number): void;
getCamSplineNodeIndex(cam: number): number;
overrideCamSplineVelocity(cam: number, p1: number, p2: number, p3: number): void;
overrideCamSplineMotionBlur(cam: number, p1: number, p2: number, p3: number): void;
isCamSplinePaused(p0: number): boolean;
playSynchronizedCamAnim(p0: number, p1: number, animName: string, animDictionary: string): boolean;
getGameplayCamRot(rotationOrder: number): Vector3;
getGameplayCamRelativeHeading(): number;
setGameplayCamRelativeHeading(heading: number): void;
setGameplayCamRelativePitch(angle: number, scalingFactor: number): void;
setGameplayCamRawYaw(yaw: number): void;
setGameplayCamRawPitch(pitch: number): void;
shakeGameplayCam(shakeName: string, intensity: number): void;
setGameplayCamShakeAmplitude(amplitude: number): void;
stopGameplayCamShaking(p0: boolean): void;
setFollowPedCamCutsceneChat(camName: string, p1: number): boolean;
clampGameplayCamYaw(minimum: number, maximum: number): void;
clampGameplayCamPitch(minimum: number, maximum: number): void;
animateGameplayCamZoom(p0: number, distance: number): void;
setFollowPedCamViewMode(viewMode: number): void;
setFollowVehicleCamZoomLevel(zoomLevel: number): void;
setFollowVehicleCamViewMode(viewMode: number): void;
getGameplayCamRot(rotationOrder: number): Vector3;
getIsMultiplayerBrief(toggle: boolean): void;
shakeCinematicCam(p0: string, p1: number): void;
setCinematicCamShakeAmplitude(p0: number): void;
stopCinematicCamShaking(p0: boolean): void;
setCamEffect(p0: number): void;
}
declare interface GameCamUnk {
_0xAABD62873FFB1A33(p0: number, p1: number): void;
_0xF55E4046F6F831DC(p0: number, p1: number): void;
_0xE111A7C0D200CBC5(p0: number, p1: number): void;
_0x202A5ED9CE01D6E7(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number): void;
_0x661B5C8654ADD825(cam: number, p1: boolean): void;
_0xA2767257A320FC82(p0: number, p1: boolean): void;
_0x271017B9BA825366(p0: number, p1: boolean): void;
_0x5D96CFB59DA076A0(vehicle: number, p1: number, p2: number): void;
_0xC8B5C4A79CC18B94(cam: number): void;
_0x5C48A1D6E3B33179(cam: number): boolean;
_0x4879E4FE39074CDF(): boolean;
_0x487A82C650EB7799(p0: number): void;
_0x0225778816FDC28C(p0: number): void;
_0x28B022A17B068A3A(p0: number, p1: number): void;
_0x469F2ECDEC046337(p0: boolean): void;
_0x3044240D2E0FA842(): boolean;
_0x705A276EBFF3133D(): boolean;
_0xDB90C6CCA48940F1(p0: boolean): void;
_0xA7092AFE81944852(): void;
_0xFD3151CD37EA2245(entity: number): void;
_0xB1381B97F70C7B30(): void;
_0xDD79DF9F4D26E1C9(): void;
_0x271401846BD26E92(p0: boolean, p1: boolean): void;
_0xC8391C309684595A(): void;
_0x59424BD75174C9B1(): void;
_0x9F97DA93681F87EA(): void;
_0x91EF6EE6419E5B97(p0: boolean): void;
_0x9DFE13ECDC1EC196(p0: boolean, p1: boolean): void;
_0x79C0E43EB9B944E2(hash: number): boolean;
_0xEE778F8C7E1142E2(p0: number): number;
_0x2A2173E46DAECD12(p0: number, p1: number): void;
_0x19CAFA3C87F7C2FF(): number;
_0x0AA27680A0BD43FA(): void;
_0xCED08CBE8EBB97C7(p0: number, p1: number): void;
_0x2F7F2B26DD3F18EE(p0: number, p1: number): void;
_0x4008EDF7D6E48175(p0: boolean): void;
_0x380B4968D1E09E55(): void;
_0xCCD078C2665D2973(p0: boolean): void;
_0x247ACBC4ABBC9D1C(p0: boolean): void;
_0xBF72910D0F26F025(): number;
_0x62ECFCFDEE7885D6(): void;
_0xDC9DA9E8789F5246(): void;
_0x1F2300CB7FA7B7F6(): number;
_0x17FCA7199A530203(): number;
_0xD7360051C885628B(): number;
_0x7B8A361C1813FBEF(): void;
_0x324C5AA411DA7737(p0: number): void;
_0x12DED8CA53D47EA5(p0: number): void;
_0x5A43C76F7FC7BA5F(): void;
_0x5C41E6BABC9E2112(p0: number): void;
_0xEAF0FA793D05C592(): number;
_0x62374889A4D59F72(): void;
}
declare interface GameCam extends GameCamLegacy {
renderScriptS(render: boolean, ease: boolean, easeTime: number, p3: boolean, p4: boolean, p5: number): void;
stopRenderingScriptCamsUsingCatchUp(render: boolean, p1: number, p2: number, p3: number): void;
create(camName: string, p1: boolean): number;
createWithParams(
camName: string,
posX: number,
posY: number,
posZ: number,
rotX: number,
rotY: number,
rotZ: number,
fov: number,
p8: boolean,
p9: number
): number;
createEra(camHash: number, p1: boolean): number;
createEraWithParams(
camHash: number,
posX: number,
posY: number,
posZ: number,
rotX: number,
rotY: number,
rotZ: number,
fov: number,
p8: boolean,
p9: number
): number;
destroy(cam: number, bScriptHostCam: boolean): void;
destroyAllS(bScriptHostCam: boolean): void;
doesExist(cam: number): boolean;
setActive(cam: number, active: boolean): void;
isActive(cam: number): boolean;
isRendering(cam: number): boolean;
getRendering(): number;
getCoord(cam: number): Vector3;
getRot(cam: number, rotationOrder: number): Vector3;
getFov(cam: number): number;
getNearClip(cam: number): number;
getFarClip(cam: number): number;
getFarDof(cam: number): number;
setParams(
cam: number,
posX: number,
posY: number,
posZ: number,
rotX: number,
rotY: number,
rotZ: number,
fieldOfView: number,
p8: number,
p9: number,
p10: number,
p11: number
): void;
setCoord(cam: number, posX: number, posY: number, posZ: number): void;
setRot(cam: number, rotX: number, rotY: number, rotZ: number, rotationOrder: number): void;
setFov(cam: number, fieldOfView: number): void;
setNearClip(cam: number, nearClip: number): void;
setFarClip(cam: number, farClip: number): void;
setMotionBlurStrength(cam: number, strength: number): void;
setNearDof(cam: number, nearDOF: number): void;
setFarDof(cam: number, farDOF: number): void;
setDofStrength(cam: number, dofStrength: number): void;
setDofPlanes(cam: number, p1: number, p2: number, p3: number, p4: number): void;
setUseShallowDofMode(cam: number, toggle: boolean): void;
setUseHiDof(): void;
setDofFnumberOfLens(camera: number, p1: number): void;
setDofFocalLengthMultiplier(camera: number, multiplier: number): void;
setDofFocusDistanceBias(camera: number, p1: number): void;
setDofMaxNearInFocusDistance(camera: number, p1: number): void;
setDofMaxNearInFocusDistanceBlendLevel(camera: number, p1: number): void;
attachToEntity(cam: number, entity: number, xOffset: number, yOffset: number, zOffset: number, isRelative: boolean): void;
attachToPedBone(cam: number, ped: number, boneIndex: number, x: number, y: number, z: number, heading: boolean): void;
attachToPedBone2(
cam: number,
ped: number,
boneIndex: number,
p3: number,
p4: number,
p5: number,
p6: number,
p7: number,
p8: number,
p9: boolean
): void;
attachToVehicleBone(
cam: number,
vehicle: number,
boneIndex: number,
relativeRotation: boolean,
rotX: number,
rotY: number,
rotZ: number,
offsetX: number,
offsetY: number,
offsetZ: number,
fixedDirection: boolean
): void;
detach(cam: number): void;
setInheritRollVehicle(cam: number, p1: boolean): void;
pointAtCoord(cam: number, x: number, y: number, z: number): void;
pointAtEntity(cam: number, entity: number, p2: number, p3: number, p4: number, p5: boolean): void;
pointAtPedBone(cam: number, ped: number, boneIndex: number, x: number, y: number, z: number, p6: boolean): void;
stopPointing(cam: number): void;
setAffectsAiming(cam: number, toggle: boolean): void;
setDebugName(camera: number, name: string): void;
addSplineNode(
camera: number,
x: number,
y: number,
z: number,
xRot: number,
yRot: number,
zRot: number,
length: number,
p8: number,
p9: number
): void;
addSplineNodeUsingCameraFrame(cam: number, cam2: number, p2: number, p3: number): void;
addSplineNodeUsingCamera(cam: number, cam2: number, p2: number, p3: number): void;
addSplineNodeUsingGameplayFrame(cam: number, p1: number, p2: number): void;
setSplinePhase(cam: number, p1: number): void;
getSplinePhase(cam: number): number;
getSplineNodePhase(cam: number): number;
setSplineDuration(cam: number, timeDuration: number): void;
setSplineSmoothingStyle(cam: number, smoothingStyle: number): void;
getSplineNodeIndex(cam: number): number;
setSplineNodeEase(cam: number, p1: number, p2: number, p3: number): void;
setSplineNodeVelocityScale(cam: number, p1: number, scale: number): void;
overrideSplineVelocity(cam: number, p1: number, p2: number, p3: number): void;
overrideSplineMotionBlur(cam: number, p1: number, p2: number, p3: number): void;
setSplineNodeExtraFlags(cam: number, p1: number, flags: number): void;
isSplinePaused(p0: number): boolean;
setActiveWithInterp(camTo: number, camFrom: number, duration: number, easeLocation: number, easeRotation: number): void;
isInterpolating(cam: number): boolean;
shake(cam: number, type: string, amplitude: number): void;
animatedShake(cam: number, p1: string, p2: string, p3: string, amplitude: number): void;
isShaking(cam: number): boolean;
setShakeAmplitude(cam: number, amplitude: number): void;
stopShaking(cam: number, p1: boolean): void;
shakeScriptGlobal(p0: string, p1: number): void;
animatedShakeScriptGlobal(p0: string, p1: string, p2: string, p3: number): void;
isScriptGlobalShaking(): boolean;
stopScriptGlobalShaking(p0: boolean): void;
playAnim(
cam: number,
animName: string,
animDictionary: string,
x: number,
y: number,
z: number,
xRot: number,
yRot: number,
zRot: number,
p9: boolean,
p10: number
): boolean;
isPlayingAnim(cam: number, animName: string, animDictionary: string): boolean;
setAnimCurrentPhase(cam: number, phase: number): void;
getAnimCurrentPhase(cam: number): number;
playSynchronizedAnim(p0: number, p1: number, animName: string, animDictionary: string): boolean;
setFlyHorizontalResponse(cam: number, p1: number, p2: number, p3: number): void;
setFlyVerticalSpeedMultiplier(cam: number, p1: number, p2: number, p3: number): void;
setFlyMaxHeight(cam: number, height: number): void;
setFlyCoordAndConstrain(cam: number, x: number, y: number, z: number): void;
isScreenFadedOut(): boolean;
isScreenFadedIn(): boolean;
isScreenFadingOut(): boolean;
isScreenFadingIn(): boolean;
doScreenFadeIn(duration: number): void;
doScreenFadeOut(duration: number): void;
setWidescreenBorders(p0: boolean, p1: number): void;
getGameplayCoord(): Vector3;
getGameplayRot(rotationOrder: number): Vector3;
getGameplayFov(): number;
getGameplayRelativeHeading(): number;
setGameplayRelativeHeading(heading: number): void;
getGameplayRelativePitch(): number;
setGameplayRelativePitch(angle: number, scalingFactor: number): void;
setGameplayRelativeRotation(roll: number, pitch: number, yaw: number): void;
setGameplayRawYaw(yaw: number): void;
setGameplayRawPitch(pitch: number): void;
shakeGameplay(shakeName: string, intensity: number): void;
isGameplayShaking(): boolean;
setGameplayShakeAmplitude(amplitude: number): void;
stopGameplayShaking(p0: boolean): void;
setGameplayFollowPedThisUpdate(ped: number): void;
isGameplayRendering(): boolean;
enableCrosshairThisFrame(): void;
isGameplayLookingBehind(): boolean;
disableCollisionForEntity(entity: number): void;
disableCollisionForObject(entity: number): void;
isSphereVisible(x: number, y: number, z: number, radius: number): boolean;
isFollowPedActive(): boolean;
setFollowPedThisUpdate(camName: string, p1: number): boolean;
clampGameplayYaw(minimum: number, maximum: number): void;
clampGameplayPitch(minimum: number, maximum: number): void;
animateGameplayZoom(p0: number, distance: number): void;
setInVehicleStateThisUpdate(p0: number, p1: number): void;
disableFirstPersonThisFrame(): void;
getFollowPedZoomLevel(): number;
getFollowPedViewMode(): number;
setFollowPedViewMode(viewMode: number): void;
isFollowVehicleActive(): boolean;
getFollowVehicleZoomLevel(): number;
setFollowVehicleZoomLevel(zoomLevel: number): void;
getFollowVehicleViewMode(): number;
setFollowVehicleViewMode(viewMode: number): void;
useStuntEraThisFrame(): void;
setGameplayHash(camName: string): void;
setFollowTurretSeat(seatIndex: number): void;
isAimActive(): boolean;
isAimThirdPersonActive(): boolean;
isFirstPersonAimActive(): boolean;
disableAimThisUpdate(): void;
getFirstPersonAimZoomFactor(): number;
setFirstPersonAimZoomFactor(zoomFactor: number): void;
setFirstPersonPitchRange(p0: number, p1: number): void;
setFirstPersonAimNearClipThisUpdate(p0: number): void;
setThirdPersonAimNearClipThisUpdate(p0: number): void;
getFinalRenderedCoord(): Vector3;
getFinalRenderedRot(rotationOrder: number): Vector3;
getFinalRenderedInWhenFriendlyRot(player: number, rotationOrder: number): Vector3;
getFinalRenderedFov(): number;
getFinalRenderedInWhenFriendlyFov(player: number): number;
getFinalRenderedNearClip(): number;
getFinalRenderedFarClip(): number;
getFinalRenderedNearDof(): number;
getFinalRenderedFarDof(): number;
getFinalRenderedMotionBlurStrength(): number;
setGameplayCoordHint(x: number, y: number, z: number, duration: number, blendOutDuration: number, blendInDuration: number, unk: number): void;
setGameplayPedHint(p0: number, x1: number, y1: number, z1: number, p4: boolean, p5: number, p6: number, p7: number): void;
setGameplayVehicleHint(
vehicle: number,
offsetX: number,
offsetY: number,
offsetZ: number,
p4: boolean,
time: number,
easeInTime: number,
easeOutTime: number
): void;
setGameplayObjectHint(p0: number, p1: number, p2: number, p3: number, p4: boolean, p5: number, p6: number, p7: number): void;
setGameplayEntityHint(
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
p4: boolean,
p5: number,
p6: number,
p7: number,
p8: number
): void;
isGameplayHintActive(): boolean;
stopGameplayHint(p0: boolean): void;
setGameplayHintFov(FOV: number): void;
setGameplayHintFollowDistanceScalar(value: number): void;
setGameplayHintBaseOrbitPitchOffset(value: number): void;
setGameplayHintAnimOffsetx(xOffset: number): void;
setGameplayHintAnimOffsety(yOffset: number): void;
setGameplayHintAnimCloseup(toggle: boolean): void;
setCinematicButtonActive(p0: boolean): void;
isCinematicRendering(): boolean;
shakeCinematic(p0: string, p1: number): void;
isCinematicShaking(): boolean;
setCinematicShakeAmplitude(p0: number): void;
stopCinematicShaking(p0: boolean): void;
disableVehicleFirstPersonThisFrame(): void;
invalidateVehicleIdle(): void;
invalidateIdle(): void;
isCinematicIdleRendering(): boolean;
isInVehicleDisabled(): boolean;
createCinematicShot(p0: number, p1: number, p2: number, entity: number): void;
isCinematicShotActive(p0: number): boolean;
stopCinematicShot(p0: number): void;
forceCinematicRenderingThisUpdate(p0: boolean): void;
setCinematicModeActive(toggle: boolean): void;
isCinematicActive(): boolean;
stopCutsceneShaking(): void;
getFocusPedOnScreen(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number): number;
setEffect(p0: number): void;
setGameplayVehicleCamera(vehicleName: string): void;
setGameplayVehicleCameraName(vehicleModel: number): void;
replayFreeGetMaxRange(): number;
unk: GameCamUnk;
}
declare interface GameCamMp extends GameCam {}
|
ksenonadv/ragemp-types
|
packages/client/game/graphics.d.ts
|
declare interface GetActiveScreenResolutionResult {
x: number;
y: number;
}
declare interface GetStatusOfLoadMissionCreatorPhotoResult {
p0: number;
result: number;
}
declare interface GetScriptGfxPositionResult {
calculatedX: number;
calculatedY: number;
}
declare interface GetScreenResolutionResult {
x: number;
y: number;
}
declare interface GetScreenCoordFromWorldCoordResult {
screenX: number;
screenY: number;
result: boolean;
}
declare interface GameGraphicsUnk {
_0xC5C8F970D4EDFF71(p0: number): void;
_0x7FA5D82B8F58EC06(): number;
_0x5B0316762AFD4A64(): number;
_0x346EF3ECAAAB149E(): void;
_0x1BBC135A4D25EDDE(p0: boolean): void;
_0xF3F776ADA161E47D(p0: number, p1: number): void;
_0xADD6627C4D325458(p0: number): void;
_0x759650634F07B6B4(p0: number): boolean;
_0xCB82A0BF0E3E3265(p0: number): number;
_0x2A893980E96B659A(p0: number): number;
_0x4AF92ACD3141D96C(): void;
_0xE791DF1F73ED2C8B(p0: number): number;
_0xEC72C258667BE5EA(p0: number): number;
_0x9641588DAB93B4B5(p0: number): void;
_0x393BD2275CEB7793(): number;
_0xF51D36185993515D(checkpoint: number, posX: number, posY: number, posZ: number, unkX: number, unkY: number, unkZ: number): void;
_0xFCF6788FC4860CD4(checkpoint: number): void;
_0x615D3925E87A3B26(checkpoint: number): void;
_0xDB1EA9411C8911EC(p0: number): void;
_0x3C788E7F6438754D(p0: number, p1: number, p2: number, p3: number): void;
_0x2D3B147AFAD49DE0(
textureDict: string,
textureName: string,
x: number,
y: number,
width: number,
height: number,
p6: number,
red: number,
green: number,
blue: number,
alpha: number,
p11: number
): void;
_0xB2EBE8CBC58B90E9(): number;
_0xEFABC7722293DA7C(): void;
_0xEF398BEEE4EF45F9(p0: boolean): void;
_0x814AF7DCAACC597B(p0: number): void;
_0x43FA7CBE20DAB219(p0: number): void;
_0xE2892E7E55D7073A(p0: number): void;
_0xC35A6D07C93802B2(): void;
_0xBE197EAA669238F4(p0: number, p1: number, p2: number, p3: number): number;
_0x61F95E5BB3E0A8C6(p0: number): void;
_0xAE51BC858F32BA66(p0: number, p1: number, p2: number, p3: number, p4: number): void;
_0x649C97D52332341A(p0: number): void;
_0x2C42340F916C5930(p0: number): number;
_0x14FC5833464340A8(): void;
_0x0218BA067D249DEA(): void;
_0x1612C45F9E3E0D44(): void;
_0x5DEBD9C4DC995692(): void;
_0xAAE9BE70EC7C69AB(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number): void;
_0x36F6626459D91457(p0: number): void;
_0x259BA6D4E6F808F1(p0: number): void;
_0x25FC3E33A31AD0C9(p0: boolean): void;
_0x0AE73D8DF3A762B2(p0: boolean): void;
_0xCA465D9CC0D231BA(p0: number): void;
_0xC0416B061F2B7E5E(p0: boolean): void;
_0xB3C641F3630BF6DA(p0: number): void;
_0xE59343E9E96529E7(): number;
_0x6A51F78772175A51(toggle: boolean): void;
_0xE63D7C6EECECB66B(toggle: boolean): void;
_0xE3E2C1B4C59DBC77(unk: number): void;
_0x851CD923176EBA7C(): void;
_0xB569F41F3E7E83A4(p0: number): void;
_0x7AC24EAB6D74118D(p0: boolean): boolean;
_0xBCEDB009461DA156(): number;
_0x27FEB5254759CDE3(textureDict: string, p1: boolean): boolean;
_0x8CDE909A0370BB3A(toggle: boolean): void;
_0xBA0127DA25FD54C9(p0: number, p1: number): void;
_0x2A251AA48B2B46DB(): void;
_0x908311265D42A820(p0: number): void;
_0xCFD16F0DB5A3535C(toggle: boolean): void;
_0x5F6DF3D92271E8A1(toggle: boolean): void;
_0x2B40A97646381508(p0: number): void;
_0xBB90E12CAC1DAB25(p0: number): void;
_0xCA4AE345A153D573(p0: boolean): void;
_0x54E22EA2C1956A8D(p0: number): void;
_0x949F397A288B28B3(p0: number): void;
_0xBA3D194057C79A7B(p0: string): void;
_0x5DBF05DB5926D089(p0: number): void;
_0x9B079E5221D984D3(p0: boolean): void;
_0xA46B73FAA3460AE1(p0: boolean): void;
_0xF78B803082D4386F(p0: number): void;
_0xD9454B5752C857DC(): void;
_0x27CFB1B1E078CB2D(): void;
_0x82ACC484FFA3B05F(p0: number): number;
_0x0E4299C549F0D1F1(toggle: boolean): void;
_0x02369D5C8A51FDCF(toggle: boolean): void;
_0x46D1A61A21F566FC(p0: number): void;
_0x03300B57FCAC6DDB(p0: boolean): void;
_0x98EDF76A7271E4F2(): void;
_0x1CBA05AE7BD7EE05(p0: number): void;
_0x98D18905BF723B99(): number;
_0x2FCB133CA50A49EB(val: number): boolean;
_0x86255B1FC929E33E(val: number): boolean;
_0x32F34FF7F617643B(p0: number, p1: number): void;
_0x5E657EF1099EDD65(p0: number): boolean;
_0xD1C7CB175E012964(scaleformHandle: number): boolean;
_0xD1C55B110E4DF534(p0: number): void;
_0x30432A0118736E00(): number;
_0x98C4FE6EC34154CA(presetName: string, ped: number, p2: number, posX: number, posY: number, posZ: number): boolean;
_0x7A42B2E236E71415(): void;
_0x108BE26959A9D9BB(toggle: boolean): void;
}
declare interface GameGraphicsLegacy {
setScreenDrawPosition(horizontalAlign: number, verticalAlign: number): void;
getScreenActiveResolution(): GetActiveScreenResolutionResult;
getScreenAspectRatio(b: boolean): number;
setBlackout(state: boolean): void;
setFarShadowsSuppressed(toggle: boolean): void;
transitionToBlurred(transitionTime: number): boolean;
transitionFromBlurred(transitionTime: number): boolean;
setFrozenRenderingDisabled(toggle: boolean): void;
startParticleFxNonLoopedAtCoord2(
effectName: string,
xPos: number,
yPos: number,
zPos: number,
xRot: number,
yRot: number,
zRot: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean,
p11: boolean
): boolean;
startParticleFxNonLoopedOnPedBone2(
effectName: string,
ped: number,
offsetX: number,
offsetY: number,
offsetZ: number,
rotX: number,
rotY: number,
rotZ: number,
boneIndex: number,
scale: number,
axisX: boolean,
axisY: boolean,
axisZ: boolean
): boolean;
startParticleFxNonLoopedOnEntity2(
effectName: string,
entity: number,
offsetX: number,
offsetY: number,
offsetZ: number,
rotX: number,
rotY: number,
rotZ: number,
scale: number,
axisX: boolean,
axisY: boolean,
axisZ: boolean
): boolean;
startParticleFxLoopedOnEntityBone(
effectName: string,
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
boneIndex: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean
): number;
startParticleFxLoopedOnEntity2(
effectName: string,
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean,
p12: number,
p13: number,
p14: number,
p15: number
): number;
startParticleFxLoopedOnEntityBone2(
effectName: string,
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
boneIndex: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean,
p13: number,
p14: number,
p15: number,
p16: number
): number;
setParticleFxLoopedRange(ptfxHandle: number, range: number): void;
setPtfxAssetNextCall(name: string): void;
setPtfxAssetOldToNew(oldAsset: string, newAsset: string): void;
requestScaleformMovie3(scaleformName: string): number;
hasNamedScaleformMovieLoaded(scaleformName: string): boolean;
callScaleformMovieFunctionFloatParams(
scaleform: number,
methodName: string,
param1: number,
param2: number,
param3: number,
param4: number,
param5: number
): void;
callScaleformMovieFunctionStringParams(
scaleform: number,
methodName: string,
param1: string,
param2: string,
param3: string,
param4: string,
param5: string
): void;
callScaleformMovieFunctionMixedParams(
scaleform: number,
methodName: string,
floatParam1: number,
floatParam2: number,
floatParam3: number,
floatParam4: number,
floatParam5: number,
stringParam1: string,
stringParam2: string,
stringParam3: string,
stringParam4: string,
stringParam5: string
): void;
pushScaleformMovieFunctionFromHudComponent(hudComponent: number, methodName: string): boolean;
pushScaleformMovieFunction(scaleform: number, methodName: string): boolean;
pushScaleformMovieFunctionN(methodName: string): boolean;
popScaleformMovieFunctionVoid(): void;
popScaleformMovieFunction(): number;
sittingTv(methodReturn: number): string;
pushScaleformMovieFunctionParameterInt(value: number): void;
pushScaleformMovieFunctionParameterFloat(value: number): void;
pushScaleformMovieFunctionParameterBool(value: boolean): void;
beginTextComponent(componentType: string): void;
endTextComponent(): void;
pushScaleformMovieFunctionParameterString(string: string): void;
requestHudScaleform(hudComponent: number): void;
hasHudScaleformLoaded(hudComponent: number): boolean;
loadTvChannel(videoCliphash: number): boolean;
startScreenEffect(effectName: string, duration: number, looped: boolean): void;
stopScreenEffect(effectName: string): void;
getScreenEffectIsActive(effectName: string): boolean;
stopAllScreenEffects(): void;
}
declare interface GameGraphics extends GameGraphicsLegacy {
setDebugLinesAndSpheresDrawingActive(enabled: boolean): void;
drawDebugLine(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: number): void;
drawDebugLineWithTwoColours(
x1: number,
y1: number,
z1: number,
x2: number,
y2: number,
z2: number,
r1: number,
g1: number,
b1: number,
r2: number,
g2: number,
b2: number,
alpha1: number,
alpha2: number
): void;
drawDebugSphere(x: number, y: number, z: number, radius: number, red: number, green: number, blue: number, alpha: number): void;
drawDebugBox(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: number): void;
drawDebugCross(x: number, y: number, z: number, size: number, red: number, green: number, blue: number, alpha: number): void;
drawDebugText(text: string, x: number, y: number, z: number, red: number, green: number, blue: number, alpha: number): void;
drawDebugText2D(text: string, x: number, y: number, z: number, red: number, green: number, blue: number, alpha: number): void;
drawLine(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, red: number, green: number, blue: number, alpha: number): void;
drawPoly(
x1: number,
y1: number,
z1: number,
x2: number,
y2: number,
z2: number,
x3: number,
y3: number,
z3: number,
red: number,
green: number,
blue: number,
alpha: number
): void;
drawSpritePoly(
x1: number,
y1: number,
z1: number,
x2: number,
y2: number,
z2: number,
x3: number,
y3: number,
z3: number,
red: number,
green: number,
blue: number,
alpha: number,
textureDict: string,
textureName: string,
u1: number,
v1: number,
w1: number,
u2: number,
v2: number,
w2: number,
u3: number,
v3: number,
w3: number
): void;
drawSpritePoly2(
x1: number,
y1: number,
z1: number,
x2: number,
y2: number,
z2: number,
x3: number,
y3: number,
z3: number,
red1: number,
green1: number,
blue1: number,
alpha1: number,
red2: number,
green2: number,
blue2: number,
alpha2: number,
red3: number,
green3: number,
blue3: number,
alpha3: number,
textureDict: string,
textureName: string,
u1: number,
v1: number,
w1: number,
u2: number,
v2: number,
w2: number,
u3: number,
v3: number,
w3: number
): void;
drawBox(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, red: number, green: number, blue: number, alpha: number): void;
setBackfaceculling(toggle: boolean): void;
beginTakeMissionCreatorPhoto(): number;
getStatusOfTakeMissionCreatorPhoto(): number;
freeMemoryForMissionCreatorPhoto(): void;
loadMissionCreatorPhoto(p1: number, p2: number, p3: number): number;
getStatusOfLoadMissionCreatorPhoto(): GetStatusOfLoadMissionCreatorPhotoResult;
beginTakeHighQualityPhoto(): boolean;
getStatusOfTakeHighQualityPhoto(): number;
freeMemoryForHighQualityPhoto(): void;
saveHighQualityPhoto(unused: number): boolean;
getStatusOfSaveHighQualityPhoto(): number;
freeMemoryForLowQualityPhoto(): void;
drawLowQualityPhotoToPhone(p0: boolean, p1: boolean): void;
getMaximumNumberOfPhotos(): number;
getMaximumNumberOfCloudPhotos(): number;
getCurrentNumberOfCloudPhotos(): number;
getStatusOfSortedListOperation(p0: number): number;
returnTwo(p0: number): number;
drawLightWithRangeAndShadow(
x: number,
y: number,
z: number,
r: number,
g: number,
b: number,
range: number,
intensity: number,
shadow: number
): void;
drawLightWithRange(
posX: number,
posY: number,
posZ: number,
colorR: number,
colorG: number,
colorB: number,
range: number,
intensity: number
): void;
drawSpotLight(
posX: number,
posY: number,
posZ: number,
dirX: number,
dirY: number,
dirZ: number,
colorR: number,
colorG: number,
colorB: number,
distance: number,
brightness: number,
hardness: number,
radius: number,
falloff: number
): void;
drawSpotLightWithShadow(
posX: number,
posY: number,
posZ: number,
dirX: number,
dirY: number,
dirZ: number,
colorR: number,
colorG: number,
colorB: number,
distance: number,
brightness: number,
roundness: number,
radius: number,
falloff: number,
shadowId: number
): void;
fadeUpPedLight(p0: number): void;
updateLightsOnEntity(entity: number): void;
drawMarker(
type: number,
posX: number,
posY: number,
posZ: number,
dirX: number,
dirY: number,
dirZ: number,
rotX: number,
rotY: number,
rotZ: number,
scaleX: number,
scaleY: number,
scaleZ: number,
red: number,
green: number,
blue: number,
alpha: number,
bobUpAndDown: boolean,
faceCamera: boolean,
p19: number,
rotate: boolean,
textureDict: string,
textureName: string,
drawOnEnts: boolean
): void;
drawMarker2(
type: number,
posX: number,
posY: number,
posZ: number,
dirX: number,
dirY: number,
dirZ: number,
rotX: number,
rotY: number,
rotZ: number,
scaleX: number,
scaleY: number,
scaleZ: number,
red: number,
green: number,
blue: number,
alpha: number,
bobUpAndDown: boolean,
faceCamera: boolean,
p19: number,
rotate: boolean,
textureDict: string,
textureName: string,
drawOnEnts: boolean,
p24: boolean,
p25: boolean
): void;
drawSphere(x: number, y: number, z: number, radius: number, red: number, green: number, blue: number, alpha: number): void;
createCheckpoint(
type: number,
posX1: number,
posY1: number,
posZ1: number,
posX2: number,
posY2: number,
posZ2: number,
diameter: number,
red: number,
green: number,
blue: number,
alpha: number,
reserved: number
): number;
setCheckpointScale(checkpoint: number, p0: number): void;
setCheckpointIconScale(checkpoint: number, scale: number): void;
setCheckpointCylinderHeight(checkpoint: number, nearHeight: number, farHeight: number, radius: number): void;
setCheckpointRgba(checkpoint: number, red: number, green: number, blue: number, alpha: number): void;
setCheckpointRgba2(checkpoint: number, red: number, green: number, blue: number, alpha: number): void;
deleteCheckpoint(checkpoint: number): void;
dontRenderInGameUi(p0: boolean): void;
forceRenderInGameUi(toggle: boolean): void;
requestStreamedTextureDict(textureDict: string, p1: boolean): void;
hasStreamedTextureDictLoaded(textureDict: string): boolean;
setStreamedTextureDictAsNoLongerNeeded(textureDict: string): void;
drawRect(x: number, y: number, width: number, height: number, r: number, g: number, b: number, a: number, p8: boolean): void;
setScriptGfxDrawBehindPausemenu(toggle: boolean): void;
setScriptGfxDrawOrder(drawOrder: number): void;
setScriptGfxAlign(horizontalAlign: number, verticalAlign: number): void;
resetScriptGfxAlign(): void;
setScriptGfxAlignParams(x: number, y: number, w: number, h: number): void;
getScriptGfxPosition(x: number, y: number): GetScriptGfxPositionResult;
getSafeZoneSize(): number;
drawSprite(
textureDict: string,
textureName: string,
screenX: number,
screenY: number,
width: number,
height: number,
heading: number,
red: number,
green: number,
blue: number,
alpha: number,
p11: boolean
): void;
drawInteractiveSprite(
textureDict: string,
textureName: string,
screenX: number,
screenY: number,
width: number,
height: number,
heading: number,
red: number,
green: number,
blue: number,
alpha: number
): void;
drawSpriteUv(
textureDict: string,
textureName: string,
x: number,
y: number,
width: number,
height: number,
u1: number,
v1: number,
u2: number,
v2: number,
heading: number,
red: number,
green: number,
blue: number,
alpha: number
): void;
addEntityIcon(entity: number, icon: string): number;
setEntityIconVisibility(entity: number, toggle: boolean): void;
setEntityIconColor(entity: number, red: number, green: number, blue: number, alpha: number): void;
setDrawOrigin(x: number, y: number, z: number, p3: number): void;
clearDrawOrigin(): void;
setBinkMovie(name: string): number;
playBinkMovie(binkMovie: number): void;
stopBinkMovie(binkMovie: number): void;
releaseBinkMovie(binkMovie: number): void;
drawBinkMovie(binkMovie: number, p1: number, p2: number, p3: number, p4: number, p5: number, r: number, g: number, b: number, a: number): void;
setBinkMovieTime(binkMovie: number, progress: number): void;
getBinkMovieTime(binkMovie: number): number;
setBinkMovieVolume(binkMovie: number, value: number): void;
attachTvAudioToEntity(entity: number): void;
setBinkMovieUnk2(binkMovie: number, p1: boolean): void;
setTvAudioFrontend(toggle: boolean): void;
setBinkShouldSkip(binkMovie: number, bShouldSkip: boolean): void;
loadMovieMeshSet(movieMeshSetName: string): number;
releaseMovieMeshSet(movieMeshSet: number): void;
queryMovieMeshSetState(p0: number): number;
getScreenResolution(): GetScreenResolutionResult;
getActiveScreenResolution(): GetActiveScreenResolutionResult;
getAspectRatio(b: boolean): number;
getIsWidescreen(): boolean;
getIsHidef(): boolean;
setNightvision(toggle: boolean): void;
getRequestingnightvision(): boolean;
getUsingnightvision(): boolean;
setNoiseoveride(toggle: boolean): void;
setNoisinessoveride(value: number): void;
getScreenCoordFromWorldCoord(worldX: number, worldY: number, worldZ: number): GetScreenCoordFromWorldCoordResult;
getTextureResolution(textureDict: string, textureName: string): Vector3;
overridePedBadgeTexture(ped: number, txd: string, txn: string): boolean;
setFlash(p0: number, p1: number, fadeIn: number, duration: number, fadeOut: number): void;
disableOcclusionThisFrame(): void;
setArtificialLightsState(state: boolean): void;
setArtificialLightsStateAffectsVehicles(toggle: boolean): void;
createTrackedPoint(): number;
setTrackedPointInfo(point: number, x: number, y: number, z: number, radius: number): void;
isTrackedPointVisible(point: number): boolean;
destroyTrackedPoint(point: number): void;
grassLodShrinkScriptAreas(x: number, y: number, z: number, radius: number, p4: number, p5: number, p6: number): void;
grassLodResetScriptAreas(): void;
cascadeShadowsInitSession(): void;
cascadeShadowsSetCascadeBounds(p0: number, p1: boolean, p2: number, p3: number, p4: number, p5: number, p6: boolean, p7: number): void;
cascadeShadowsSetCascadeBoundsScale(p0: number): void;
cascadeShadowsSetEntityTrackerScale(p0: number): void;
cascadeShadowsEnableEntityTracker(toggle: boolean): void;
cascadeShadowsSetShadowSampleType(type: string): void;
cascadeShadowsClearShadowSampleType(): void;
cascadeShadowsSetAircraftMode(p0: boolean): void;
cascadeShadowsSetDynamicDepthMode(p0: boolean): void;
cascadeShadowsSetDynamicDepthValue(p0: number): void;
golfTrailSetEnabled(toggle: boolean): void;
golfTrailSetPath(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: boolean): void;
golfTrailSetRadius(p0: number, p1: number, p2: number): void;
golfTrailSetColour(
p0: number,
p1: number,
p2: number,
p3: number,
p4: number,
p5: number,
p6: number,
p7: number,
p8: number,
p9: number,
p10: number,
p11: number
): void;
golfTrailSetTessellation(p0: number, p1: number): void;
golfTrailSetFixedControlPoint(
type: number,
xPos: number,
yPos: number,
zPos: number,
p4: number,
red: number,
green: number,
blue: number,
alpha: number
): void;
golfTrailSetShaderParams(p0: number, p1: number, p2: number, p3: number, p4: number): void;
golfTrailSetFacing(p0: boolean): void;
golfTrailGetMaxHeight(): number;
golfTrailGetVisualControlPoint(p0: number): Vector3;
setSeethrough(toggle: boolean): void;
getUsingseethrough(): boolean;
seethroughReset(): void;
seethroughSetFadeStartDistance(distance: number): void;
seethroughSetFadeEndDistance(distance: number): void;
seethroughGetMaxThickness(): number;
seethroughSetMaxThickness(thickness: number): void;
seethroughSetNoiseAmountMin(amount: number): void;
seethroughSetNoiseAmountMax(amount: number): void;
seethroughSetHiLightIntensity(intensity: number): void;
seethroughSetHiLightNoise(noise: number): void;
seethroughSetHeatscale(index: number, heatScale: number): void;
seethroughSetColorNear(red: number, green: number, blue: number): void;
triggerScreenblurFadeIn(transitionTime: number): boolean;
triggerScreenblurFadeOut(transitionTime: number): boolean;
disableScreenblurFade(): void;
getScreenblurFadeCurrentTime(): number;
isScreenblurFadeRunning(): boolean;
togglePausedRenderphases(toggle: boolean): void;
getTogglePausedRenderphasesStatus(): boolean;
resetPausedRenderphases(): void;
setHidofEnvBlurParams(p0: boolean, p1: boolean, nearplaneOut: number, nearplaneIn: number, farplaneOut: number, farplaneIn: number): void;
startParticleFxNonLoopedAtCoord(
effectName: string,
xPos: number,
yPos: number,
zPos: number,
xRot: number,
yRot: number,
zRot: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean
): number;
startNetworkedParticleFxNonLoopedAtCoord(
effectName: string,
xPos: number,
yPos: number,
zPos: number,
xRot: number,
yRot: number,
zRot: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean,
p11: boolean
): boolean;
startParticleFxNonLoopedOnPedBone(
effectName: string,
ped: number,
offsetX: number,
offsetY: number,
offsetZ: number,
rotX: number,
rotY: number,
rotZ: number,
boneIndex: number,
scale: number,
axisX: boolean,
axisY: boolean,
axisZ: boolean
): boolean;
startNetworkedParticleFxNonLoopedOnPedBone(
effectName: string,
ped: number,
offsetX: number,
offsetY: number,
offsetZ: number,
rotX: number,
rotY: number,
rotZ: number,
boneIndex: number,
scale: number,
axisX: boolean,
axisY: boolean,
axisZ: boolean
): boolean;
startParticleFxNonLoopedOnEntity(
effectName: string,
entity: number,
offsetX: number,
offsetY: number,
offsetZ: number,
rotX: number,
rotY: number,
rotZ: number,
scale: number,
axisX: boolean,
axisY: boolean,
axisZ: boolean
): boolean;
startNetworkedParticleFxNonLoopedOnEntity(
effectName: string,
entity: number,
offsetX: number,
offsetY: number,
offsetZ: number,
rotX: number,
rotY: number,
rotZ: number,
scale: number,
axisX: boolean,
axisY: boolean,
axisZ: boolean
): boolean;
startNetworkedParticleFxNonLoopedOnEntityBone(
effectName: string,
entity: number,
offsetX: number,
offsetY: number,
offsetZ: number,
rotX: number,
rotY: number,
rotZ: number,
boneIndex: number,
scale: number,
axisX: boolean,
axisY: boolean,
axisZ: boolean
): boolean;
setParticleFxNonLoopedColour(r: number, g: number, b: number): void;
setParticleFxNonLoopedAlpha(alpha: number): void;
startParticleFxLoopedAtCoord(
effectName: string,
x: number,
y: number,
z: number,
xRot: number,
yRot: number,
zRot: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean,
p11: boolean
): number;
startParticleFxLoopedOnPedBone(
effectName: string,
ped: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
boneIndex: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean
): number;
startParticleFxLoopedOnEntity(
effectName: string,
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean
): number;
startParticleFxLoopedOnEntityBone(
effectName: string,
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
boneIndex: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean
): number;
startNetworkedParticleFxLoopedOnEntity(
effectName: string,
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean,
p12: number,
p13: number,
p14: number,
p15: number
): number;
startNetworkedParticleFxLoopedOnEntityBone(
effectName: string,
entity: number,
xOffset: number,
yOffset: number,
zOffset: number,
xRot: number,
yRot: number,
zRot: number,
boneIndex: number,
scale: number,
xAxis: boolean,
yAxis: boolean,
zAxis: boolean,
p13: number,
p14: number,
p15: number,
p16: number
): number;
stopParticleFxLooped(ptfxHandle: number, p1: boolean): void;
removeParticleFx(ptfxHandle: number, p1: boolean): void;
removeParticleFxFromEntity(entity: number): void;
removeParticleFxInRange(X: number, Y: number, Z: number, radius: number): void;
doesParticleFxLoopedExist(ptfxHandle: number): boolean;
setParticleFxLoopedOffsets(ptfxHandle: number, x: number, y: number, z: number, rotX: number, rotY: number, rotZ: number): void;
setParticleFxLoopedEvolution(ptfxHandle: number, propertyName: string, amount: number, noNetwork: boolean): void;
setParticleFxLoopedColour(ptfxHandle: number, r: number, g: number, b: number, p4: boolean): void;
setParticleFxLoopedAlpha(ptfxHandle: number, alpha: number): void;
setParticleFxLoopedScale(ptfxHandle: number, scale: number): void;
setParticleFxLoopedFarClipDist(ptfxHandle: number, range: number): void;
setParticleFxCamInsideVehicle(p0: boolean): void;
setParticleFxCamInsideNonplayerVehicle(vehicle: number, p1: boolean): void;
setParticleFxShootoutBoat(p0: number): void;
enableClownBloodVfx(toggle: boolean): void;
enableAlienBloodVfx(toggle: boolean): void;
setParticleFxBulletImpactScale(scale: number): void;
useParticleFxAsset(name: string): void;
setParticleFxOverride(oldAsset: string, newAsset: string): void;
resetParticleFxOverride(name: string): void;
washDecalsInRange(p0: number, p1: number, p2: number, p3: number, p4: number): void;
washDecalsFromVehicle(vehicle: number, p1: number): void;
fadeDecalsInRange(p0: number, p1: number, p2: number, p3: number, p4: number): void;
removeDecalsInRange(x: number, y: number, z: number, range: number): void;
removeDecalsFromObject(obj: number): void;
removeDecalsFromObjectFacing(obj: number, x: number, y: number, z: number): void;
removeDecalsFromVehicle(vehicle: number): void;
addDecal(
decalType: number,
posX: number,
posY: number,
posZ: number,
p4: number,
p5: number,
p6: number,
p7: number,
p8: number,
p9: number,
width: number,
height: number,
rCoef: number,
gCoef: number,
bCoef: number,
opacity: number,
timeout: number,
p17: boolean,
p18: boolean,
p19: boolean
): number;
addPetrolDecal(x: number, y: number, z: number, groundLvl: number, width: number, transparency: number): number;
startPetrolTrailDecals(p0: number): void;
addPetrolTrailDecalInfo(x: number, y: number, z: number, p3: number): void;
endPetrolTrailDecals(): void;
removeDecal(decal: number): void;
isDecalAlive(decal: number): boolean;
getDecalWashLevel(decal: number): number;
setDisableDecalRenderingThisFrame(): void;
getIsPetrolDecalInRange(xCoord: number, yCoord: number, zCoord: number, radius: number): boolean;
patchDecalDiffuseMap(decalType: number, textureDict: string, textureName: string): void;
unpatchDecalDiffuseMap(decalType: number): void;
moveVehicleDecals(p0: number, p1: number): void;
addVehicleCrewEmblem(
vehicle: number,
ped: number,
boneIndex: number,
x1: number,
x2: number,
x3: number,
y1: number,
y2: number,
y3: number,
z1: number,
z2: number,
z3: number,
scale: number,
p13: number,
alpha: number
): boolean;
removeVehicleCrewEmblem(vehicle: number, p1: number): void;
getVehicleCrewEmblemRequestState(vehicle: number, p1: number): number;
doesVehicleHaveCrewEmblem(vehicle: number, p1: number): boolean;
overrideInteriorSmokeName(name: string): void;
overrideInteriorSmokeLevel(level: number): void;
overrideInteriorSmokeEnd(): void;
registerNoirScreenEffectThisFrame(): void;
disableVehicleDistantlights(toggle: boolean): void;
setForcePedFootstepsTracks(toggle: boolean): void;
setForceVehicleTrails(toggle: boolean): void;
disableScriptAmbientEffects(p0: number): void;
presetInteriorAmbientCache(timecycleModifierName: string): void;
setTimecycleModifier(modifierName: string): void;
setTimecycleModifierStrength(strength: number): void;
setTransitionTimecycleModifier(modifierName: string, transition: number): void;
clearTimecycleModifier(): void;
getTimecycleModifierIndex(): number;
getTimecycleTransitionModifierIndex(): number;
pushTimecycleModifier(): void;
popTimecycleModifier(): void;
setCurrentPlayerTcmodifier(modifierName: string): void;
setPlayerTcmodifierTransition(value: number): void;
setNextPlayerTcmodifier(modifierName: string): void;
addTcmodifierOverride(modifierName1: string, modifierName2: string): void;
removeTcmodifierOverride(p0: string): void;
setExtraTimecycleModifier(modifierName: string): void;
clearExtraTimecycleModifier(): void;
getExtraTimecycleModifierIndex(): number;
setExtraTimecycleModifierStrength(strength: number): void;
resetExtraTimecycleModifierStrength(): void;
requestScaleformMovie(scaleformName: string): number;
requestScaleformMovie2(scaleformName: string): number;
requestScaleformMovieInstance(scaleformName: string): number;
requestScaleformMovieInteractive(scaleformName: string): number;
hasScaleformMovieLoaded(scaleformHandle: number): boolean;
hasScaleformMovieFilenameLoaded(scaleformName: string): boolean;
hasScaleformContainerMovieLoadedIntoParent(scaleformHandle: number): boolean;
setScaleformMovieAsNoLongerNeeded(scaleformHandle: number): number;
setScaleformMovieToUseSystemTime(scaleform: number, toggle: boolean): void;
setScaleformFitRendertarget(scaleformHandle: number, toggle: boolean): void;
drawScaleformMovie(
scaleformHandle: number,
x: number,
y: number,
width: number,
height: number,
red: number,
green: number,
blue: number,
alpha: number,
unk: number
): void;
drawScaleformMovieFullscreen(scaleform: number, red: number, green: number, blue: number, alpha: number, unk: number): void;
drawScaleformMovieFullscreenMasked(scaleform1: number, scaleform2: number, red: number, green: number, blue: number, alpha: number): void;
drawScaleformMovie3D(
scaleform: number,
posX: number,
posY: number,
posZ: number,
rotX: number,
rotY: number,
rotZ: number,
p7: number,
p8: number,
p9: number,
scaleX: number,
scaleY: number,
scaleZ: number,
p13: number
): void;
drawScaleformMovie3DSolid(
scaleform: number,
posX: number,
posY: number,
posZ: number,
rotX: number,
rotY: number,
rotZ: number,
p7: number,
p8: number,
p9: number,
scaleX: number,
scaleY: number,
scaleZ: number,
p13: number
): void;
callScaleformMovieMethod(scaleform: number, method: string): void;
callScaleformMovieMethodWithNumber(
scaleform: number,
methodName: string,
param1: number,
param2: number,
param3: number,
param4: number,
param5: number
): void;
callScaleformMovieMethodWithString(
scaleform: number,
methodName: string,
param1: string,
param2: string,
param3: string,
param4: string,
param5: string
): void;
callScaleformMovieMethodWithNumberAndString(
scaleform: number,
methodName: string,
floatParam1: number,
floatParam2: number,
floatParam3: number,
floatParam4: number,
floatParam5: number,
stringParam1: string,
stringParam2: string,
stringParam3: string,
stringParam4: string,
stringParam5: string
): void;
beginScaleformScriptHudMovieMethod(hudComponent: number, methodName: string): boolean;
beginScaleformMovieMethod(scaleform: number, methodName: string): boolean;
beginScaleformMovieMethodOnFrontend(methodName: string): boolean;
beginScaleformMovieMethodOnFrontendHeader(methodName: string): boolean;
endScaleformMovieMethod(): void;
endScaleformMovieMethodReturnValue(): number;
isScaleformMovieMethodReturnValueReady(methodReturn: number): boolean;
getScaleformMovieMethodReturnValueInt(methodReturn: number): number;
getScaleformMovieMethodReturnValueBool(methodReturn: number): boolean;
getScaleformMovieMethodReturnValueString(methodReturn: number): string;
scaleformMovieMethodAddParamInt(value: number): void;
scaleformMovieMethodAddParamFloat(value: number): void;
scaleformMovieMethodAddParamBool(value: boolean): void;
beginTextCommandScaleformString(componentType: string): void;
endTextCommandScaleformString(): void;
endTextCommandScaleformString2(): void;
scaleformMovieMethodAddParamTextureNameString2(string: string): void;
scaleformMovieMethodAddParamTextureNameString(string: string): void;
scaleformMovieMethodAddParamPlayerNameString(string: string): void;
scaleformMovieMethodAddParamLatestBriefString(value: number): void;
requestScaleformScriptHudMovie(hudComponent: number): void;
hasScaleformScriptHudMovieLoaded(hudComponent: number): boolean;
removeScaleformScriptHudMovie(hudComponent: number): void;
setTvChannel(channel: number): void;
getTvChannel(): number;
setTvVolume(volume: number): void;
getTvVolume(): number;
drawTvChannel(
xPos: number,
yPos: number,
xScale: number,
yScale: number,
rotation: number,
red: number,
green: number,
blue: number,
alpha: number
): void;
setTvChannelPlaylist(tvChannel: number, playlistName: string, restart: boolean): void;
setTvChannelPlaylistAtHour(tvChannel: number, playlistName: string, hour: number): void;
clearTvChannelPlaylist(tvChannel: number): void;
isPlaylistUnk(tvChannel: number, p1: number): boolean;
isTvPlaylistItemPlaying(videoCliphash: number): boolean;
enableMovieKeyframeWait(toggle: boolean): void;
enableMovieSubtitles(toggle: boolean): void;
ui3DsceneIsAvailable(): boolean;
ui3DscenePushPreset(presetName: string): boolean;
terraingridActivate(toggle: boolean): void;
terraingridSetParams(
x: number,
y: number,
z: number,
p3: number,
rotation: number,
p5: number,
width: number,
height: number,
p8: number,
scale: number,
glowIntensity: number,
normalHeight: number,
heightDiff: number
): void;
terraingridSetColours(
lowR: number,
lowG: number,
lowB: number,
lowAlpha: number,
r: number,
g: number,
b: number,
alpha: number,
highR: number,
highG: number,
highB: number,
highAlpha: number
): void;
animpostfxPlay(effectName: string, duration: number, looped: boolean): void;
animpostfxStop(effectName: string): void;
animpostfxGetUnk(effectName: string): number;
animpostfxIsRunning(effectName: string): boolean;
animpostfxStopAll(): void;
animpostfxStopAndDoUnk(effectName: string): void;
unk: GameGraphicsUnk;
}
declare interface GameGraphicsMp extends GameGraphics {}
|
ksenonadv/ragemp-types
|
packages/server/index.d.ts
|
<gh_stars>0
/// <reference path="enums.d.ts" />
/// <reference path="./hashes/ped_hashes.d.ts" />
/// <reference path="./hashes/vehicle_hashes.d.ts" />
/// <reference path="./hashes/weapon_hashes.d.ts" />
declare type HashOrNumberOrString<T> = T | number | string;
declare type HashOrString<T> = T | string;
declare type Array2d = [number, number];
declare type Array3d = [number, number, number];
declare type Array4d = [number, number, number, number];
declare type RGB = Array3d;
declare type RGBA = Array4d;
declare type KeyValueCollection = { [key: string]: any };
declare interface IVector3 {
x: number;
y: number;
z: number;
}
declare type PlayerWeaponCollection = {
current: number;
reset(): void;
};
declare class Vector3 {
public x: number;
public y: number;
public z: number;
constructor(x: number, y: number, z: number);
constructor(arr: Array3d);
constructor(obj: IVector3);
/**
* Add a Vector3 to another Vector3 or scalar
*
* @param otherVec Vector3 or number: The vector or scalar to be added to the callee.
*/
add(otherVec: Vector3 | number): Vector3;
/**
* Get the angle (in radians) between two vectors.
*
* @param otherVec the other vector to calcuate the angle to.
* @returns The angle (in radians) between two vectors.
*/
angleTo(otherVec: Vector3): number;
/**
* Clone a vector
*
* @returns A copy of a Vector3
*/
clone(): Vector3;
/**
* Calculate the cross product of two vectors.
* The cross product is a vector that is perpendicular to both input vectors.
*
* @param otherVec The other vector.
*/
cross(otherVec: Vector3): Vector3;
/**
* Divide a Vector3 by another Vector3 or scalar.
*
* @param otherVec The vector or scalar to divide the callee by.
*/
divide(otherVec: Vector3 | number): Vector3;
/**
* Calculate the dot product of two vectors.
*
* @param otherVec The other vector.
*/
dot(otherVec: Vector3): number;
/**
* Test where two Vector3s equal each other.
*
* @param otherVec The vector to compare to the callee.
*/
equals(otherVec: Vector3): boolean;
/**
* Get the magnitude of a Vector3
*
* @returns The magnitude of a Vector3
*/
length(): number;
/**
* Get the maximum partial of a Vector3
*
* @returns The maximum partial of a Vector3
*/
max(): number;
/**
* Get the minimum partial of a Vector3
*
* @returns The minimum partial of a Vector3
*/
min(): number;
/**
* Multiply a Vector3 by another Vector3 or scalar.
*
* @param otherVec The vector or scalar to be added to the callee.
*/
multiply(otherVec: Vector3 | number): Vector3;
/**
* Get the opposite of a Vector3 by flipping the sign of each partial.
*
* @returns The opposite of a Vector3 by flipping the sign of each partial
*/
negative(): Vector3;
/**
* Subtract a Vector3 or scalar from another Vector3.
*
* @param otherVec The vector or scalar to be subtracted from the callee.
*/
subtract(otherVec: Vector3 | number): Vector3;
/**
* TODO: docs
*/
toAngles(): Array2d;
/**
* Get an array of the partials of a Vector3.
*
* @returns An array of the partials of a Vector3
*/
toArray(): Array3d;
/**
* Normalized copy of a Vector3- one that has the same direction but with a magnitude of 1.
*
* @returns Normalized copy of a Vector3- one that has the same direction but with a magnitude of 1.
*/
unit(): Array3d;
}
declare class EntityMp {
/**
* Property used for getting an entity ID.
*
* The ID is a unique identifier for the entity.
*
* A server-side ID is NOT the same as a client-side ID.
*
* Use [remoteId](https://wiki.rage.mp/index.php?title=Entity::remoteId) property if you want it to match the server-side ID.
*/
public readonly id: number;
/**
* Property used for getting an entity type.
*/
public readonly type: RageEnums.EntityType;
/**
* Property used to gets/sets the entity's alpha.
*/
public alpha: number;
/**
* Property used to gets/sets the entity's data.
*/
public data: any;
/**
* Property used to gets/sets the entity's dimension.
*
* The dimension determines who the entity is visible to.
*/
public dimension: number;
/**
* Property used to gets/sets the entity's model.
*/
public model: number;
/**
* Property used to gets/sets the entity's position.
*/
public position: Vector3;
/**
* Retrieves the custom data from the entity.
*
* @param name The variabile name
*/
public getVariable<T = any>(name: string): T | undefined;
/**
* Allows to get the value set with [entity.setOwnVariable(key, value)](https://wiki.rage.mp/index.php?title=Entity::setOwnVariable).
*
* @param name The variabile name
*/
public getOwnVariable<T = any>(name: string): T | undefined;
/**
* Set custom data to an entity.
*
* @param name The variabile name
* @param value The value
*/
public setVariable(name: string, value: any): void;
/**
* Set multiple custom data variables to an entity.
*
* @param values The values
*/
public setVariables(values: KeyValueCollection): void;
/**
* Sets the data available to the player as opposed to [entity.setVariable(key, value)](https://wiki.rage.mp/index.php?title=Entity::setVariable).
*/
public setOwnVariable(key: string, value: any): void;
/**
* Set multiple custom data variables that will be only available to an entity.
*/
public setOwnVariables(values: KeyValueCollection): void;
/**
* Gets the distance between two entities.
*
* @param position Vector3
*/
public dist(position: Vector3): number;
/**
* Gets the squared distance between two entities.
*
* @param position Vector3
*/
public distSquared(position: Vector3): number;
/**
* Destroy a created entity.
*/
public destroy(): void;
}
declare class EntityMpPool<T> {
/**
* Property used to get the element count of a pool.
*/
public readonly length: number;
/**
* Property used to get an element pool size.
*
* Useful to be used in explicit array size declaration or manual for loop size (non [foreach](https://wiki.rage.mp/index.php?title=Pool::forEach)).
*/
public readonly size: number;
/**
* TODO: docs
*/
public apply(callingFunction: (...args: any[]) => void, ...args: any[]): void;
/**
* Used to get an element from a pool at an ID.
*
* @param id Element ID, what you need get from the pool.
* @returns An element from a pool at an ID
*/
public at(id: number): T;
/**
* Used for check, exists entity with ID in pool or not.
*
* @param entity Entity ID or the entity itself, what you wanna check in pool.
*/
public exists(entity: T | number): boolean;
/**
* Used for calling a function for each element in a pool.
*
* @param callingFunction Function what will be called
*/
public forEach(callingFunction: (entity: T) => void): void;
/**
* Calling for each entity in a pool.
*
* Same as forEach except faster at lookups. Do not use this for destroying entities..
*
* @param callingFunction Function what will be called
*/
public forEachFast(callingFunction: (entity: T) => void): void;
/**
* Used to call a function for each elements in the pool.
*
* @param dimension Dimension
* @param callingFunction Function, what will be called.
*/
public forEachInDimension(dimension: number, callingFunction: (entity: T) => void): void;
/**
* Used for calling a function for each element in a pool, but only if it in range of position.
*
* @param callingFunction Function, what will be called.
*/
public forEachInRange(position: Vector3, range: number, callingFunction: (entity: T) => void): void;
public forEachInRange(position: Vector3, range: number, dimension: number, callingFunction: (entity: T) => void): void;
/**
* Sorts the closest entities to a certain specified point in the entities pool.
*
* @param position Vector3
* @param limit The limit (Default is 1)
*/
public getClosest(position: Vector3, limit?: number): T | T[];
/**
* Gets the closest set of entities to a position in the defined dimension.
*
* @param position Vector3
* @param dimension The Dimension
* @param limit The Limit
*/
public getClosestInDimension(position: Vector3, dimension: number, limit?: number): T | T[];
/**
* Converts a pool to an array.
*
* If you don't need to create a new array every time, use [Pool::toArrayFast](https://wiki.rage.mp/index.php?title=Pool::toArrayFast).
*/
public toArray(): T[];
/**
* Same as [Pool::toArray](https://wiki.rage.mp/index.php?title=Pool::toArray) except it doesn't create a new array each time and instead updates it and returns the same array.
*/
public toArrayFast(): T[];
}
declare class PlayerMp extends EntityMp {
/**
* Property used for getting the player's action.
*/
public readonly action: string;
/**
* Property used for getting the player's aim target
*
* If player currently [isn't aiming](https://wiki.rage.mp/index.php?title=Player::isAiming), this property will be last aim target.
*/
public readonly aimTarget: PlayerMp;
/**
* Property used for getting the player's weapon hash and ammo.
*/
public readonly allWeapons: number[];
/**
* Property used for getting the player's ip address.
*/
public readonly ip: string;
/**
* Property used for getting the player's aiming state.
*/
public readonly isAiming: boolean;
/**
* Property used for getting the player's climbing state.
*/
public readonly isClimbing: boolean;
/**
* Property used for getting the player's entering vehicle state.
*/
public readonly isEnteringVehicle: boolean;
/**
* Property used for getting the player's cover state.
*/
public readonly isInCover: boolean;
/**
* Property used for getting the player's melee state.
*/
public readonly isInMelee: boolean;
/**
* Property used for getting the player's jumping state.
*/
public readonly isJumping: boolean;
/**
* Property used for getting the player's leaving vehicle state.
*/
public readonly isLeavingVehicle: boolean;
/**
* Property used for getting the player's on ladder state.
*/
public readonly isOnLadder: boolean;
/**
* Property used for getting the player's reloading state.
*/
public readonly isReloading: boolean;
/**
* Property used for getting the player's primary hair color.
*/
public readonly hairColor: number;
/**
* Property used for getting the player's hair highlight color.
*/
public readonly hairHighlightColor: number;
/**
* Property used for getting the player's packet loss.
*/
public readonly packetLoss: number;
/**
* Property used for getting the player's ping.
*/
public readonly ping: number;
/**
* Property used for getting the player's social club id.
*/
public readonly rgscId: string;
/**
* Property used for getting the player's vehicle seat.
*/
public readonly seat: RageEnums.VehicleSeat;
/**
* Property used for getting the player's client serial.
*/
public readonly serial: string;
/**
* Property used for getting the player's social club.
*/
public readonly socialClub: string;
/**
* Property used for getting the player's streamed players.
*/
public readonly streamedPlayers: PlayerMp[];
/**
* Property used for getting the player's weapons.
*/
public readonly weapons: PlayerWeaponCollection;
/**
* Property used for getting the player's vehicle.
*/
public readonly vehicle: VehicleMp;
/**
* Property used for getting the player's voice listeners.
*
* @returns All active voice listeners as array, which got added by [Player::enableVoiceTo](https://wiki.rage.mp/index.php?title=Player::enableVoiceTo).
*/
public readonly voiceListeners: PlayerMp[];
/**
* Property used to gets/sets the player's armour.
*/
public armour: number;
/**
* Property used to gets/sets the player's eye color.
*/
public eyeColor: number;
/**
* Property used to gets/sets the player's game type.
*/
public gameType: string;
/**
* Property used to gets/sets the player's heading.
*/
public heading: number;
/**
* Property used to gets/sets the player's health.
*/
public health: number;
/**
* Property used to gets/sets the player's name.
*/
public name: string;
/**
* Property used to gets/sets the player's weapon.
*/
public weapon: number;
/**
* Property used to gets/sets the player's weapon ammo.
*/
public weaponAmmo: number;
/**
* Property used to gets/sets the player's outgoing sync.
*/
public disableOutgoingSync: boolean;
/**
* Bans the player from your server.
*
* The ban reason doesn't display for the player, you need to use something else to display it for the player.
*
* Also, all bans that use this function are cleared once the server restarts.
*
* You need to save the bans yourself if you want them to stay after restarting your server.
* @param reason The reason of ban
*/
public ban(reason: string): void;
/**
* `FROM SERVER` Calls a client-side event for the selected player
*
* `FROM CLIENT` For Peer 2 Peer connections.
*
* The current client can call an event on another client's scriptside and that other client can handle that event.
*
* @param eventName The event name that will be called
* @param args Any arguments, what should be sent to client. Supports entities, strings, numbers and booleans. (Objects and Arrays should be packed to JSON format.) Arguments has to be packed in an array.
*/
public call(eventName: string, args?: any[]): void;
/**
* Calls the specified player's clientside Remote prodecure call (RPC) event and expects a callback.
*
* @param eventProcName Procedure Name
* @param args Args
*/
public callProc(eventName: string, args?: any[]): Promise<any>;
/**
* Triggers a client-side event for the selected player unreliably, which means it will be affected by potential packet loss, but it will be triggered way more faster, useful for when you need frequent triggers.
*
* @param eventName Event Name
* @param args Args
*/
public callUnreliable(eventName: string, args?: any[]): void;
/**
* TODO: docs
*/
public cancelPendingRpc(procName?: string): void;
/**
* TODO: docs
*/
public clearDecorations(): void;
/**
* Enables voice listening to a certain player.
*
* @param targetPlayer The Player you want to listen to.
*/
public enableVoiceTo(targetPlayer: PlayerMp): void;
/**
* Disables voice listening to a certain player.
*
* @param targetPlayer The Player you want to stop listen to.
*/
public disableVoiceTo(targetPlayer: PlayerMp): void;
/**
* TODO: docs
*/
public eval(code: string): void;
/**
* Gets a hash of player clothes.
*
* @param component [Components](https://wiki.rage.mp/index.php?title=Player::getClothes)
* @returns A hash of player clothes
*/
public getClothes(component: RageEnums.ClothesComponent | number): {
drawable: number;
texture: number;
palette: number;
};
/**
* Gets the tattoo (decoration) from a collection specified.
*
* @param collection [Collections](https://github.com/root-cause/v-tattoos)
*/
public getDecoration(collection: number): number;
/**
* Gets the various freemode face features, e.g. nose length, chin shape. Scale ranges from -1.0 to 1.0. Index can be 0 - 19.
*
* @param index [Index](https://wiki.rage.mp/index.php?title=Player::getFaceFeature)
*/
public getFaceFeature(index: number): number;
/**
* TODO: docs
*/
public getHeadBlend(): {
shapes: number[];
skins: number[];
shapeMix: number;
skinMix: number;
thirdMix: number;
};
/**
* TODO: docs
*/
public getHeadOverlay(overlay: RageEnums.HeadOverlay | number): Array4d;
/**
* Gets a prop of player from ID.
*
* @param prop [Props](https://wiki.rage.mp/index.php?title=Player::getProp)
* @returns A prop of player from ID
*/
public getProp(prop: RageEnums.PlayerProp | number): {
drawable: number;
texture: number;
};
/**
* Get the weapon's ammo.
*
* @param weapon Weapon Hash
*/
public getWeaponAmmo(weapon: HashOrNumberOrString<RageEnums.Hashes.Weapon>): number;
/**
* Gives a weapon(see) for the player.
*
* @param weaponHash Weapon Hash
* @param ammo Ammo
*/
public giveWeapon(weaponHash: HashOrNumberOrString<RageEnums.Hashes.Weapon>, ammo: number): void;
public giveWeapon(weaponHashes: HashOrNumberOrString<RageEnums.Hashes.Weapon>[], ammo: number): void;
/**
* TODO: docs
*/
public hasPendingRpc(procName?: string): boolean;
/**
* Used for check, player is located in stream distance for another player or not.
*
* @param player Player
*/
public isStreamed(player: PlayerMp): boolean;
/**
* Invokes specified [native](https://cdn.rage.mp/public/natives/) function
*
* @param hash Hash
* @param args Args
*/
public invoke(hash: string, ...args: any[]): void;
/**
* Kicks a player from the server.
*
* @param reason This message does not show up for the player being kicked
*/
public kick(reason: string): void;
/**
* Silently kicks the player which will then reconnect them back to the server.
*
* Useful for quick reconnects without going through the UI.
*
* The client will act as if it has timed out.
*/
public kickSilent(): void;
/**
* Sends a notification to the player.
*
* You can use the colour codes found here: [Fonts and colors](https://wiki.rage.mp/index.php?title=Fonts_and_Colors)
*
* @param message Message
*/
public notify(message: string): void;
/**
* Writes a chat message to player.
*
* @param message Text what should be output in player chat.
*/
public outputChatBox(message: string): void;
/**
* Starts animation
*
* @param dict [Animation List](https://wiki.rage.mp/index.php?title=Animations)
* @param name Animation Name
* @param speed Animation Speed
* @param flag [Animation Flags](https://wiki.rage.mp/index.php?title=Player::playAnimation)
*/
public playAnimation(dict: string, name: string, speed: number, flag: number): void;
/**
* Stops animation of the player
*/
public stopAnimation(): void;
/**
* Puts player into vehicle.
*
* You can't put player in vehicle immediately after creating vehicle, use timeout (200 ms will be fine)
*
* @param vehicle Vehicle
* @param seat Seat Number
*/
public putIntoVehicle(vehicle: VehicleMp, seat: RageEnums.VehicleSeat | number): void;
/**
* Removes all weapons from the player
*/
public removeAllWeapons(): void;
/**
* Ejects player from vehicle.
*/
public removeFromVehicle(): void;
/**
* Removes a weapon of player. Weapon's hashes list
*
* @param weaponHash [Weapon Hash](https://wiki.rage.mp/index.php?title=Weapons)
*/
public removeWeapon(weaponHash: HashOrNumberOrString<RageEnums.Hashes.Weapon>): void;
/**
* Sets clothing for player.
*
* Alternative of client-side function: [Player::setComponentVariation](https://wiki.rage.mp/index.php?title=Player::setComponentVariation)
*
* @param component ClothesComponent
* @param drawable Number
* @param texture Texture
* @param palette Palette
*/
public setClothes(component: RageEnums.ClothesComponent | number, drawable: number, texture: number, palette: number): void;
/**
* Sets player customization (NB: This resets your weapons also).
*
* IMPORTANT! faceFeatures array must contain 20 elements
*/
public setCustomization(
gender: boolean,
shapeFirst: number,
shapeSecond: number,
shapeThird: number,
skinFirst: number,
skinSecond: number,
skinThird: number,
shapeMix: number,
skinMix: number,
thirdMix: number,
eyeColor: number,
hairColor: number,
hightlightColor: number,
faceFeatures: number[]
): void;
/**
* Applies an Item from a PedDecorationCollection to a player. These include tattoos and shirt decals.
*
* @param collection Model hash or name
* @param overlay Model hash or name
*/
public setDecoration(collection: number, overlay: number): void;
/**
* Sets the various freemode face features, e.g. nose length, chin shape. Scale ranges from -1.0 to 1.0. Index can be 0 - 19.
*/
public setFaceFeature(index: number, scale: number): void;
/**
* Used for freemode (online) characters.
*
* @param firstColor First Color
* @param secondColor Second Color
*/
public setHairColor(firstColor: number, secondColor: number): void;
/**
* TODO: docs
*/
public setHeadBlend(
shapeFirst: number,
shapeSecond: number,
shapeThird: number,
skinFirst: number,
skinSecond: number,
skinThird: number,
shapeMix: number,
skinMix: number,
thirdMix: number
): void;
/**
* OverlayID ranges from 0 to 12, index from 0 to _GET_NUM_OVERLAY_VALUES(overlayID)-1, and opacity from 0.0 to 1.0.
*
* First and second color you can take in the list of hair colors.
*
* [List of colors](https://wiki.gtanet.work/index.php?title=Hair_Colors)
*
* To disable any overlay use 255 as index.
*/
public setHeadOverlay(overlay: RageEnums.HeadOverlay | number, value: Array4d): void;
/**
* Sets the prop for the player
*/
public setProp(prop: RageEnums.PlayerProp | number, drawable: number, texture: number): void;
/**
* Sets the amount of ammo for the selected weapon
*
* @param weapon Weapon Hash
* @param ammo Ammo
*/
public setWeaponAmmo(weapon: HashOrNumberOrString<RageEnums.Hashes.Weapon>, ammo: number): void;
/**
* Spawns the player.
*
* @param position Vector3
*/
public spawn(position: Vector3): void;
/**
* Updates the player head blend data
*/
public updateHeadBlend(shapeMix: number, skinMix: number, thirdMix: number): void;
/**
* Makes the player play a scenario.
*
* @param scenario [Scenario List](https://wiki.rage.mp/index.php?title=Scenarios)
*/
public playScenario(scenario: string): void;
/**
* Calls all streamed in players' clientside from the specified player passing data.
*
* @param includeSelf Calls the specified player's clientside also along with the streamed players to him
* @param eventName Event Name
* @param args Args
*/
public callToStreamed(includeSelf: boolean, eventName: string, args?: any[]): void;
}
declare class PlayerMpPool extends EntityMpPool<PlayerMp> {
/**
* Writes a chat message for all players (like [Player::outputChatBox](https://wiki.rage.mp/index.php?title=Player::outputChatBox)).
*
* @param text The text to be sent
*/
public broadcast(text: string): void;
/**
* Writes a chat message for all players in range (like [Player::outputChatBox](https://wiki.rage.mp/index.php?title=Player::outputChatBox)).
*
* @param position The position from which the broadcast will be sent
* @param range The range from position
* @param dimension The dimension in which the broadcast will be sent (optional)
* @param text The text to be sent
*/
public broadcastInRange(position: Vector3, range: number, text: string): void;
public broadcastInRange(position: Vector3, range: number, dimension: number, text: string): void;
/**
* Triggers an event for:
*
* - the whole server
* - specified players array
*
* @param eventName Event name, what will be called
* @param args Any arguments, what should be sended to client. Supports entities, strings, numbers and booleans. (Objects and Arrays should be packed to JSON format.)
*/
public call(eventName: string, args?: any[]): void;
public call(players: PlayerMp[], eventName: string, args?: any[]): void;
/**
* Calls added client-side event for any players in a specific dimension
*
* @param dimension The dimension in which the event will be sent
* @param eventName Event name, what will be called
* @param args Any arguments, what should be sended to client. Supports entities, strings, numbers and booleans. (Objects and Arrays should be packed to JSON format.)
*/
public callInDimension(dimension: number, eventName: string, args?: any[]): void;
/**
* Calls a function for each player in range of position.
*
* @param position The position from which the broadcast will be sent
* @param range The range from position
* @param eventName Event name, what will be called
* @param args Any arguments, what should be sended to client. Supports entities, strings, numbers and booleans. (Objects and Arrays should be packed to JSON format.)
*/
public callInRange(position: Vector3, range: number, eventName: string, args?: any[]): void;
public callInRange(position: Vector3, range: number, dimension: number, eventName: string, args?: any[]): void;
/**
* TODO: docs
*/
public callUnreliable(eventName: string, args?: any[]): void;
public callUnreliable(players: PlayerMp[], eventName: string, args?: any[]): void;
/**
* TODO: docs
*/
public callInDimensionUnreliable(dimension: number, eventName: string, args?: any[]): void;
/**
* TODO: docs
*/
public callInRangeUnreliable(position: Vector3, range: number, eventName: string, args?: any[]): void;
public callInRangeUnreliable(position: Vector3, range: number, dimension: number, eventName: string, args?: any[]): void;
}
declare type Quaternion = {
x: number;
y: number;
z: number;
w: number;
};
declare class VehicleMp extends EntityMp {
/**
* Property used for getting the vehicle's extras
*/
public readonly extras: boolean[];
/**
* Property used for getting the vehicle's mods
*/
public readonly mods: number[];
/**
* Property used for getting the engine's health.
*
* For edit health use [Vehicle::repair](https://wiki.rage.mp/index.php?title=Vehicle::repair)
*/
public readonly engineHealth: number;
/**
* Property used for getting the brake's state.
*/
public readonly brake: boolean;
/**
* Property used for getting the highbeams's state.
*/
public readonly highbeams: boolean;
/**
* Property used for getting the horn's state.
*/
public readonly horn: boolean;
/**
* Property used for getting the rocket boost's state.
*/
public readonly rocketBoost: boolean;
/**
* Property used for getting the siren's state.
*/
public readonly siren: boolean;
/**
* Property used for getting the steer angle's state.
*
* From -1 to 1
*/
public readonly steerAngle: number;
/**
* Property used for getting the vehicle velocity.
*/
public readonly velocity: Vector3;
/**
* Property used for getting the vehicle's streamed players
*/
public readonly streamedPlayers: PlayerMp[];
/**
* Property used for getting the vehicle's heading.
*/
public readonly heading: number;
/**
* Property used for getting the vehicle's quaternion.
*/
public readonly quaternion: Quaternion;
/**
* Property used for getting the vehicle's trailer
*/
public readonly trailer: VehicleMp;
/**
* Property used for getting the vehicle's trailered by
*/
public readonly traileredBy: VehicleMp;
/**
* Property used to gets/sets the vehicle's rotation.
*/
public rotation: Vector3;
/**
* Property used to gets/sets the body's health.
*/
public bodyHealth: number;
/**
* Property used to gets/sets the vehicle's controller.
*/
public controller: PlayerMp | undefined;
/**
* Property used to gets/sets the vehicle's custom tires.
*/
public customTires: boolean;
/**
* Property used for getting the vehicle's engine status.
*/
public engine: boolean;
/**
* Property used to gets/sets the vehicle's dashboard color.
*/
public dashboardColor: number;
/**
* Property used to gets/sets the vehicle's dead state.
*/
public dead: boolean;
/**
* Property used to gets/sets the vehicle's livery
*/
public livery: number;
/**
* Property used to gets/sets the vehicle's lock state
*/
public locked: boolean;
/**
* Property used to gets/sets the vehicle's movable state.
*/
public movable: boolean;
/**
* Property used for getting the vehicle's neon status.
*/
public neonEnabled: boolean;
/**
* Property used to gets/sets the vehicle's number plate
*
* Maximum length: 8 char
*/
public numberPlate: string;
/**
* Property used to gets/sets the vehicle's number plate type
*/
public numberPlateType: RageEnums.VehicleNumberPlateType;
/**
* Property used to gets/sets the vehicle's pearlescent color
*
* Using the [Vehicle colors](https://wiki.rage.mp/index.php?title=Vehicle_Colors).
*/
public pearlescentColor: number;
/**
* Property used to gets/sets the vehicle's taxi lights state.
*/
public taxiLights: boolean;
/**
* Property used to gets/sets the vehicle's trim color.
*/
public trimColor: number;
/**
* Property used to gets/sets the vehicle's wheels [color](https://wiki.rage.mp/index.php?title=Vehicle_Colors).
*/
public wheelColor: number;
/**
* Property used to gets/sets the vehicle's wheel type.
*/
public wheelType: number;
/**
* Property used to gets/sets the vehicle's window tint.
*
* 1 - 255
*/
public windowTint: number;
/**
* Explodes the target vehicle.
*/
public explode(): void;
/**
* On the client-side, this function requires three args (red: int, green: int, blue: int), and will return an object: RGB
*
* @param id 0 - Primary Color | 1 - Secondary Color
*/
public getColor(id: number): number;
/**
* Used to get the vehicle RGB body color. Returns null if never set explicitly.
*
* @param id 0 - Primary Color | 1 - Secondary Color
*/
public getColorRGB(id: number): RGB;
/**
* Get the extra currently applied on vehicle in the target extra id.
*
* @param extraId Extra Id
*/
public getExtra(index: number): boolean;
/**
* Gets the mod currently applied on your vehicle in the targetted modType.
*
* @param modType Mod Type
*/
public getMod(modType: number): number;
/**
* Used to get the current neon lights of a vehicle.
*/
public getNeonColor(): number[];
/**
* Get the occupant inside a vehicle by seat number
*
* @param seat Vehicle Seat
*/
public getOccupant(seat: number): PlayerMp;
/**
* Gets the occupants inside of a vehicle.
*/
public getOccupants(): PlayerMp[];
/**
* Get vehicle paint by id
*
* @param id 0 - Primary Color | 1 - Secondary Color
*/
public getPaint(id: number): number;
/**
* Used for check, vehicle is located in stream distance for player or not.
*
* @param player Player object
*/
public isStreamed(player: PlayerMp): boolean;
/**
* Repairs a vehicle.
*/
public repair(): void;
/**
* Sets vehicle body color. ([Vehicle colors](https://wiki.rage.mp/index.php?title=Vehicle_Colors))
*
* @param primary Primary Color
* @param secondary Secondary Color
*/
public setColor(primary: number, secondary: number): void;
/**
* Sets vehicle RGB body color.
*
* @param red1 Primary Red Colour [0 - 255]
* @param green1 Primary Green Colour [0 - 255]
* @param blue1 Primary Blue Colour [0 - 255]
* @param red2 Secondary Red Colour [0 - 255]
* @param green2 Secondary Green Colour [0 - 255]
* @param blue2 Secondary Blue Colour [0 - 255]
*/
public setColorRGB(red1: number, green1: number, blue1: number, red2: number, green2: number, blue2: number): void;
/**
* Max extra ID is 16.
*/
public setExtra(index: number, value: boolean): void;
/**
* Applies the specified mod onto the vehicle.
*
* @param modType Mod Type
* @param modIndex Mod Index
*/
public setMod(modType: number, modIndex: number): void;
/**
* Sets vehicle neon lights.
*
* @param red Red Value 0 - 255.
* @param green Green Value 0 - 255.
* @param blue Blue Value 0 - 255.
*/
public setNeonColor(red: number, green: number, blue: number): void;
/**
* TODO: docs
*/
public setPaint(primaryType: number, primaryColor: number, secondaryType: number, secondaryColor: number): void;
/**
* TODO: docs
*/
public setOccupant(seat: number, player: PlayerMp): void;
/**
* Spawns vehicle.
*
* @param position Vector3
* @param heading Heading
*/
public spawn(position: Vector3, heading: number): void;
}
declare interface VehicleMpPool extends EntityMpPool<VehicleMp> {
'new'(
model: HashOrNumberOrString<RageEnums.Hashes.Vehicle>,
position: Vector3,
options?: {
alpha?: number;
color?: [Array2d, Array2d] | [RGB, RGB];
dimension?: number;
engine?: boolean;
heading?: number;
locked?: boolean;
numberPlate?: string;
}
): VehicleMp;
}
declare interface EventMpThis {
cancel: boolean;
}
declare interface IServerEvents {
entityCreated: (this: EventMpThis, entity: EntityMp) => void;
entityDestroyed: (this: EventMpThis, entity: EntityMp) => void;
entityModelChange: (this: EventMpThis, entity: EntityMp, oldModel: number) => void;
incomingConnection: (this: EventMpThis, ip: string, serial: string, rgscName: string, rgscId: string, gameType: string) => void;
packagesLoaded: (this: EventMpThis) => void;
playerChat: (this: EventMpThis, player: PlayerMp, text: string) => void;
playerCommand: (this: EventMpThis, player: PlayerMp, command: string) => void;
playerDamage: (this: EventMpThis, player: PlayerMp, healthLoss: number, armorLoss: number) => void;
playerDeath: (this: EventMpThis, player: PlayerMp, reason: number, killer?: PlayerMp) => void;
playerEnterCheckpoint: (this: EventMpThis, player: PlayerMp, checkpoint: CheckpointMp) => void;
playerEnterColshape: (this: EventMpThis, player: PlayerMp, colshape: ColshapeMp) => void;
playerEnterVehicle: (this: EventMpThis) => void;
playerExitCheckpoint: (this: EventMpThis, player: PlayerMp, checkpoint: CheckpointMp) => void;
playerExitColshape: (this: EventMpThis, player: PlayerMp, colshape: ColshapeMp) => void;
playerExitVehicle: (this: EventMpThis, player: PlayerMp, vehicle: VehicleMp, seat: number) => void;
playerJoin: (this: EventMpThis, player: PlayerMp) => void;
playerQuit: (this: EventMpThis, player: PlayerMp, exitType: string, reason: string) => void;
playerReachWaypoint: (this: EventMpThis, player: PlayerMp) => void;
playerReady: (this: EventMpThis, player: PlayerMp) => void;
playerSpawn: (this: EventMpThis, player: PlayerMp) => void;
playerStartEnterVehicle: (this: EventMpThis, player: PlayerMp, vehicle: VehicleMp) => void;
playerStartExitVehicle: (this: EventMpThis, player: PlayerMp) => void;
playerStreamIn: (this: EventMpThis, player: PlayerMp, forPlayer: PlayerMp) => void;
playerStreamOut: (this: EventMpThis, player: PlayerMp, forPlayer: PlayerMp) => void;
playerWeaponChange: (this: EventMpThis, player: PlayerMp, oldWeapon: number, newWeapon: number) => void;
serverShutdown: (this: EventMpThis) => void;
trailerAttached: (this: EventMpThis, vehicle: VehicleMp, trailer: VehicleMp) => void;
vehicleDamage: (this: EventMpThis, vehicle: VehicleMp, bodyHealthLoss: number, engineHealthLoss: number) => void;
vehicleDeath: (this: EventMpThis, vehicle: VehicleMp) => void;
vehicleHornToggle: (this: EventMpThis, vehicle: VehicleMp, toggle: boolean) => void;
vehicleSirenToggle: (this: EventMpThis, vehicle: VehicleMp, toggle: boolean) => void;
}
declare class EventMp {
// @ts-ignore
constructor<K extends keyof IServerEvents>(eventName: K, callback: IServerEvents[K]);
constructor(eventName: string, callback: (...args: any[]) => void);
/**
* Destroys the event
*/
public destroy(): void;
}
declare type MultiEventHandlers = Partial<IServerEvents> & Record<string, (...args: any) => void>;
declare class EventMpPool {
/**
* Delays server's shutdown till you finish all your async tasks.
*/
public delayShutdown: boolean;
/**
* Delays server's initialization of packages to run early functions.
*/
public delayInitialization: boolean;
/**
* Registers event handlers.
*
* Returning true will destroy automatically the event handler.
*
* @param eventName The name of the event you wish to attach a handler to
* @param callback The function that you want the event to trigger, which has to be defined before you add the handler
*/
public add<K extends keyof IServerEvents>(eventName: K, callback: IServerEvents[K]): void;
public add(eventHandlers: MultiEventHandlers): void;
public add(eventName: string, callback: (this: EventMpThis, ...args: any[]) => void): void;
/**
* Registers a command handler.
*
* @param commandName The name of the command you wish to attach a handler to
* @param callback The function that you want the command to trigger, which has to be defined before you add the handler
*/
public addCommand(commandName: string, callback: (player: PlayerMp, fullText: string, ...args: string[]) => void): void;
public addCommand(commands: { [commandName: string]: (player: PlayerMp, fullText: string, ...args: string[]) => void }): void;
/**
* Register the specified player's Remote Prodecure Call (RPC) event and expects a callback.
*
* @param procedureName The name of the procedure you wish to attach a handler to
* @param callback The function that you want the RPC to trigger, which has to be defined before you add the handler
*/
public addProc(procedureName: string, callback: (...args: any[]) => void): void;
public addProc(procedures: { [name: string]: (...args: any[]) => void }): void;
/**
* Calls registered event handlers. This function can call serverside events from serverside and clientside events from clientside.
*
* 1.1 - If you're sending number more than 2^31 to client, you need to arg.toString() transform your number on server and parseInt(arg) on client.
*
* @param eventName The name of the event you wish to call
* @param args The arguments
*/
public call<K extends keyof IServerEvents>(eventName: K, ...args: any[]): void;
public call(eventName: string, ...args: any[]): void;
/**
* Gets all handlers of the specified event.
*
* @param eventName Name of the event you want to gets all handlers
* @returns An array of specified event
*/
public getAllOf<K extends keyof IServerEvents>(eventName: K): Event[];
public getAllOf(eventName: string): Event[];
/**
* Removes the specified event from events tree.
*
* @param eventName Name of the event you want to remove
* @param callback The function that you want the event to remove
*/
public remove<K extends keyof IServerEvents>(eventName: K, callback?: IServerEvents[K]): void;
public remove(eventName: string, callback?: (...args: any[]) => void): void;
public remove(eventNames: string[]): void;
/**
* Resets the whole event manager.
*/
public reset(): void;
}
declare class BlipMp extends EntityMp {
/**
* Property related to the Blip's color. [Colors](https://wiki.rage.mp/index.php?title=Blip::color)
*/
color: number;
/**
* Changes the name of the blip shown on the map. When you press Esc and hover over the blip, it will have this name.
*/
name: string;
/**
* Used to have a fade in/out of the blip when you're in range of the draw distance.
*/
drawDistance: number;
/**
* Changes the blip rotation.
*/
rotation: number;
/**
* Changes the blip scale.
*/
scale: number;
/**
* Changes the behavior of the Blip on the minimap.
*/
shortRange: boolean;
/**
* Changes the blip sprite. [Sprites](https://wiki.rage.mp/index.php?title=Blip::sprite)
*/
sprite: number;
/**
* Creates a route to the blip from the player's location.
*
* @param player Player object or an array of player objects
* @param color All colors available on [Blip Colors](https://wiki.rage.mp/index.php?title=Blips#Blip_colors) page
* @param scale Float
*/
routeFor(player: PlayerMp | PlayerMp[] | undefined, color: number, scale: number): void;
/**
* Removes a route to blip for player.
*
* @param player Array or object of player to which to remove route
*/
unrouteFor(player: PlayerMp | PlayerMp[]): void;
}
declare interface BlipMpPool extends EntityMpPool<BlipMp> {
'new'(
sprite: number,
position: Vector3,
options?: {
alpha?: number;
color?: number;
dimension?: number;
drawDistance?: number;
name?: string;
rotation?: number;
scale?: number;
shortRange?: boolean;
}
): BlipMp;
}
declare class CheckpointMp extends EntityMp {
/**
* Property related to the Checkpoint's color.
*/
color: number;
/**
* This property is used to set or retrieve the direction of the checkpoint.
*/
destination: Vector3;
/**
* This property is used to set or get the radius of the checkpoint.
*/
radius: number;
/**
* This property is used to set or get the visible of the checkpoint.
*/
visible: boolean;
/**
* Returns an array of 4 numbers, with a checkpoint color.
*/
getColor(): number[];
/**
* Hiding a checkpoint for a particular player.
*/
hideFor(player: PlayerMp): void;
/**
* Sets the checkpoint color.
*
* @param red Red color value (0 to 255)
* @param green Green color value (0 to 255)
* @param blue Blue color value (0 to 255)
* @param alpha Alpha color value (0 to 255)
*/
setColor(red: number, green: number, blue: number, alpha: number): void;
/**
* Showing a checkpoint for a particular player.
*/
showFor(player: PlayerMp): void;
}
declare interface CheckpointMpPool extends EntityMpPool<CheckpointMp> {
'new'(
type: number,
position: Vector3,
radius: number,
options?: {
color?: RGBA;
dimension?: number;
direction?: Vector3;
visible?: boolean;
}
): CheckpointMp;
}
declare class ColshapeMp extends EntityMp {
/**
* Returns type of colshape.
*/
readonly shapeType: RageEnums.ColshapeType;
/**
* Checking if a point is within the colshape.
*
* @param point Vector3
*/
isPointWithin(point: Vector3): boolean;
}
declare class ColshapeMpPool extends EntityMpPool<ColshapeMp> {
/**
* Create a ColShape of circle in the 2D plane
*
* @param x Number in float
* @param y Number in float
* @param range Number in float
* @param dimension Number (optional parameter)
*/
newCircle(x: number, y: number, range: number, dimension?: number): ColshapeMp;
/**
* Creates a cuboid ColShape in 3D space
*
* @param x Number in float
* @param y Number in float
* @param z Number in float
* @param width Number in float
* @param depth Number in float
* @param height Number in float
* @param dimension Number (optional)
*/
newCuboid(x: number, y: number, z: number, width: number, depth: number, height: number, dimension?: number): ColshapeMp;
/**
* Creates a rectangle (square) ColShape 2D plane
*
* @param x Number in float
* @param y Number in float
* @param width Number in float
* @param height Number in float
* @param dimension Number (optional)
*/
newRectangle(x: number, y: number, width: number, height: number, dimension?: number): ColshapeMp;
/**
* Creates a Sphere ColShape
*
* @param x Number in float
* @param y Number in float
* @param z Number in float
* @param range Number in float
* @param dimension Number (optional parameter)
*/
newSphere(x: number, y: number, z: number, range: number, dimension?: number): ColshapeMp;
/**
* Creates a Colshape into the shape of a Tube.
*
* @param x Number in float
* @param y Number in float
* @param z Number in float
* @param height Number in float
* @param range Number in float
* @param dimension Number in float
*/
newTube(x: number, y: number, z: number, height: number, range: number, dimension?: number): ColshapeMp;
}
declare class MarkerMp extends EntityMp {
/**
* TODO: docs
*/
direction: Vector3;
/**
* Sets the scale of the selected marker
*/
scale: number;
/**
* TODO: docs
*/
visible: boolean;
/**
* Gets the marker's color.
*/
getColor(): number[];
/**
* Hiding a marker for a particular player.
*/
hideFor(player: PlayerMp): void;
/**
* Sets the marker color.
*
* @param red Red color value (0 to 255)
* @param green Green color value (0 to 255)
* @param blue Blue color value (0 to 255)
* @param alpha Alpha color value (0 to 255)
*/
setColor(red: number, green: number, blue: number, alpha: number): void;
/**
* Showing a marker for a particular player.
*/
showFor(player: PlayerMp): void;
}
declare interface MarkerMpPool extends EntityMpPool<MarkerMp> {
'new'(
type: number,
position: Vector3,
scale: number,
options?: {
color?: RGBA;
dimension?: number;
direction?: Vector3;
rotation?: Vector3;
visible?: boolean;
}
): MarkerMp;
}
declare class TextLabelMp extends EntityMp {
/**
* Update the color of the selected label
*/
color: RGB;
/**
* Update the draw distance of the selected label
*/
drawDistance: number;
/**
* Updates the los(Line of Sight) on the selected label.
*/
los: boolean;
/**
* Updates the text of a created label.
*/
text: string;
}
declare interface TextLabelMpPool extends EntityMpPool<TextLabelMp> {
'new'(
text: string,
position: Vector3,
options?: {
color?: RGBA;
dimension?: number;
drawDistance?: number;
font?: number;
los?: boolean;
}
): TextLabelMp;
}
declare class PedMp extends EntityMp {
controller: PlayerMp;
}
declare interface PedMpPool extends EntityMpPool<PedMp> {
'new'(
modelHash: number,
position: Vector3,
options?: {
dynamic?: boolean;
frozen?: boolean;
invincible?: boolean;
lockController?: boolean;
}
): PedMp;
}
declare class ObjectMp extends EntityMp {
rotation: Vector3;
}
declare interface ObjectMpPool extends EntityMpPool<ObjectMp> {
/**
* @see https://cdn.rage.mp/public/odb/index.html
*/
'new'(
model: HashOrNumberOrString<string>,
position: Vector3,
options?: {
alpha?: number;
dimension?: number;
rotation?: Vector3;
}
): ObjectMp;
}
declare interface WorldMp {
/**
* This property gets/sets game weather.
*
* [Weather](https://wiki.rage.mp/index.php?title=Weather)
*/
weather: HashOrString<RageEnums.Weather>;
/**
* This function sets time.
*/
time: {
hour: number;
minute: number;
second: number;
set(hour: number, minute: number, second: number): void;
};
trafficLights: {
/**
* This property locks the traffic lights in their current position.
*/
locked: boolean;
/**
* This property set the traffic lights state. (If you want to make your own traffic lights system, make sure of locking the traffic lights to avoid the game to change them by itself)
*/
state: number;
};
/**
* Removes an IPL and sync it to every client
*
* @param ipl [IPLs](https://wiki.rage.mp/index.php?title=Interiors_and_Locations)
*/
removeIpl(ipl: string): void;
/**
* Requests an IPL and sync it to every client.
*
* @param name ipl [IPLs](https://wiki.rage.mp/index.php?title=Interiors_and_Locations)
*/
requestIpl(name: string): void;
/**
* Starts a weather transition to the weather specified and sync it to all clients.
*
* @param weather [Weather](https://wiki.rage.mp/index.php?title=Weather)
* @param duration Weather transitioning time
*/
setWeatherTransition(weather: HashOrString<RageEnums.Weather>, duration?: number): void;
}
declare interface DummyMp {
dummyType: number;
}
declare interface DummyMpPool {
'new'(dummyEntityType: number, sharedVariables: KeyValueCollection): DummyMp;
forEachByType(dummyEntityType: number, fn: (entity: DummyMp) => void): void;
}
declare interface ConfigMp {
announce: boolean;
bind: string;
gamemode: string;
encryption: boolean;
maxplayers: number;
name: string;
'stream-distance': number;
port: number;
'disallow-multiple-connections-per-ip': boolean;
'limit-time-of-connections-per-ip': number;
url: string;
language: string;
'sync-rate': number;
'resource-scan-thread-limit': number;
'max-ping': number;
'min-fps': number;
'max-packet-loss': number;
'allow-cef-debugging': boolean;
'enable-nodejs': boolean;
csharp: boolean;
'enable-http-security': boolean;
'voice-chat': boolean;
'allow-voice-chat-input': number;
'voice-chat-sample-rate': number;
'fastdl-host': string;
}
declare interface NetworkMp {
startBatch(): void;
endBatch(): void;
}
declare interface Mp {
Player: typeof PlayerMp;
players: PlayerMpPool;
Vehicle: typeof VehicleMp;
vehicles: VehicleMpPool;
Event: typeof EventMp;
events: EventMpPool;
Blip: typeof BlipMp;
blips: BlipMpPool;
Checkpoint: typeof CheckpointMp;
checkpoints: CheckpointMpPool;
Colshape: typeof ColshapeMp;
colshapes: ColshapeMpPool;
Marker: typeof MarkerMp;
markers: MarkerMpPool;
TextLabel: typeof TextLabelMp;
labels: TextLabelMpPool;
Ped: typeof PedMp;
peds: PedMpPool;
Object: typeof ObjectMp;
objects: ObjectMpPool;
dummies: DummyMpPool;
world: WorldMp;
config: ConfigMp;
network: NetworkMp;
Vector3: typeof Vector3;
joaat(str: string): number;
joaat(strs: string[]): number[];
}
declare const mp: Mp;
|
ksenonadv/ragemp-types
|
packages/server/enums.d.ts
|
<reponame>ksenonadv/ragemp-types
declare namespace RageEnums {
const enum ClothesComponent {
HEAD = 0,
BEARD = 1,
HAIR = 2,
TORSO = 3,
LEGS = 4,
HANDS = 5,
FOOT = 6,
NONE = 7,
ACCESSORIES_1 = 8,
ACCESSORIES_2 = 9,
MASK = 10,
DECALS = 11,
AUXILIARY = 12
}
const enum ColshapeType {
CIRCLE = 'circle',
CUBOID = 'cuboid',
POLYGON = 'polygon',
RECTANGLE = 'rectangle',
SPHERE = 'sphere',
TUBE = 'tube'
}
const enum EntityType {
BLIP = 'blip',
CHECKPOINT = 'checkpoint',
COLSHAPE = 'colshape',
DUMMY = 'dummy',
MARKER = 'marker',
OBJECT = 'object',
PICKUP = 'pickup',
PLAYER = 'player',
VEHICLE = 'vehicle',
PED = 'ped',
TEXT_LABEL = 'textlabel'
}
const enum HeadOverlay {
BLEMISHES = 0,
FACIAL_HAIR = 1,
EYEBROWS = 2,
AGEING = 3,
MAKEUP = 4,
BLUSH = 5,
COMPLEXION = 6,
SUN_DAMAGE = 7,
LIPSTICK = 8,
FRECKLES = 9,
CHEST_HAIR = 10,
BODY_BLEMISHES = 11,
ADD_BODY_BLEMISHES = 12
}
const enum Marker {
UPSIDE_DOWN_CONE = 0,
VERTICAL_CYLINDER = 1,
THICK_CEVRON_UP = 2,
THIN_CEVRON_UP = 3,
CHECKERED_FLAG_RECT = 4,
CHECKERED_FLAG_CIRCLE = 5,
VERTICAL_CIRCLE = 6,
PLANE_MODEL = 7,
LOST_MC_DARK = 8,
LOST_MC_LIGHT = 9,
NUMBER_0 = 10,
NUMBER_1 = 11,
NUMBER_2 = 12,
NUMBER_3 = 13,
NUMBER_4 = 14,
NUMBER_5 = 15,
NUMBER_6 = 16,
NUMBER_7 = 17,
NUMBER_8 = 18,
NUMBER_9 = 19,
CHEVRON_UP_1 = 20,
CHEVRON_UP_2 = 21,
CHEVRON_UP_3 = 22,
HORIZONTAL_CIRCLE_FLAT = 23,
REPLAY_ICON = 24,
HORIZONTAL_CIRCLE_SKINNY = 25,
HORIZONTAL_CIRCLE_ARROW = 26,
HORIZONTAL_SPLIT_ARROW_CIRCLE = 27,
DEBUG_SPHERE = 28,
DOLLOR_SIGN = 29,
HORIZONTAL_BARS = 30,
WOLF_HEAD = 31
}
const enum PlayerProp {
HELMET = 0,
GLASSES = 1,
EAR_ACCESSORY = 2
}
const enum VehicleNumberPlateType {
BLUE_WHITE = 0,
YELLOW_BLACK = 1,
YELLOW_BLUE = 2,
BLUE_WHITE2 = 3,
BLUE_WHITE3 = 4,
YANKTON = 5
}
const enum VehicleSeat {
DRIVER,
PASSENGER_1,
PASSENGER_2,
PASSENGER_3,
PASSENGER_4,
PASSENGER_5,
PASSENGER_6,
PASSENGER_7,
PASSENGER_8,
PASSENGER_9,
PASSENGER_10,
PASSENGER_11,
PASSENGER_12,
PASSENGER_13,
PASSENGER_14,
PASSENGER_15,
PASSENGER_16
}
const enum Weather {
BLIZZARD = 'BLIZZARD',
CLEAR = 'CLEAR',
CLEARING = 'CLEARING',
CLOUDS = 'CLOUDS',
EXTRA_SUNNY = 'EXTRASUNNY',
FOGGY = 'FOGGY',
OVERCAST = 'OVERCAST',
RAIN = 'RAIN',
SMOG = 'SMOG',
SNOW_LIGHT = 'SNOWLIGHT',
THUNDER = 'THUNDER',
XMAS = 'XMAS'
}
}
|
ksenonadv/ragemp-types
|
packages/cef/index.d.ts
|
interface Mp {
trigger(name: string, ...args: any[]): void;
}
interface Window {
mp: Mp;
}
declare var mp: Mp;
|
devrajsinghrawat/sidetree.js
|
packages/wallet/src/operations/LocalSigner.ts
|
<reponame>devrajsinghrawat/sidetree.js<filename>packages/wallet/src/operations/LocalSigner.ts
import { ISigner } from '@decentralized-identity/ion-sdk';
import { OperationKeyType } from './types';
import InputValidator from './InputValidator';
import { sign } from '@sidetree/crypto';
type PrivateKeyJwk = any;
/**
* An ISigner implementation that uses a given local private key.
*/
export default class LocalSigner implements ISigner {
/**
* Creates a new local signer using the given private key.
*/
public static create(privateKey: PrivateKeyJwk): ISigner {
return new LocalSigner(privateKey);
}
private constructor(private privateKey: PrivateKeyJwk) {
InputValidator.validateOperationKey(privateKey, OperationKeyType.Private);
}
public async sign(header: object, content: object): Promise<string> {
const compactJws = await sign(header, content, this.privateKey);
return compactJws;
}
}
|
devrajsinghrawat/sidetree.js
|
packages/core/src/test/TransactionProcessor.spec.ts
|
/*
* The code in this file originated from
* @see https://github.com/decentralized-identity/sidetree
* For the list of changes that was made to the original code
* @see https://github.com/transmute-industries/sidetree.js/blob/main/reference-implementation-changes.md
*
* Copyright 2020 - Transmute Industries Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* eslint-disable jest/no-jasmine-globals */
import {
AnchoredDataSerializer,
ErrorCode,
FetchResultCode,
IBlockchain,
SidetreeError,
TransactionModel,
FetchResult,
ValueTimeLockModel,
} from '@sidetree/common';
import AnchorFile from '../write/AnchorFile';
import { MockCas } from '@sidetree/cas';
import ChunkFile from '../write/ChunkFile';
import Compressor from '../util/Compressor';
import DownloadManager from '../DownloadManager';
import JasmineSidetreeErrorValidator from './JasmineSidetreeErrorValidator';
import MapFile from '../write/MapFile';
import { MockLedger } from '@sidetree/ledger';
import MockOperationStore from './mocks/MockOperationStore';
import OperationGenerator from './generators/OperationGenerator';
import TransactionProcessor from '../TransactionProcessor';
import ValueTimeLockVerifier from '../ValueTimeLockVerifier';
import config from './config-test.json';
jest.setTimeout(10 * 1000);
console.info = (): null => null;
describe('TransactionProcessor', () => {
let casClient: MockCas;
let operationStore: MockOperationStore;
let downloadManager: DownloadManager;
let blockchain: IBlockchain;
let transactionProcessor: TransactionProcessor;
let versionMetadataFetcher: any = {};
const versionMetadata = {
normalizedFeeToPerOperationFeeMultiplier: 0.01,
};
versionMetadataFetcher = {
getVersionMetadata: () => {
return versionMetadata;
},
};
beforeEach(() => {
casClient = new MockCas();
operationStore = new MockOperationStore();
downloadManager = new DownloadManager(
config.maxConcurrentDownloads,
casClient
);
downloadManager.start();
blockchain = new MockLedger();
transactionProcessor = new TransactionProcessor(
downloadManager,
operationStore,
blockchain,
versionMetadataFetcher
);
});
afterEach(async () => {
downloadManager.stop();
});
describe('prcoessTransaction', () => {
it('should ignore error and return true when AnchoredDataSerializer throws a sidetree error', async () => {
const anchoredData = 'Bad Format';
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer',
};
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeTruthy();
});
it('should ignore error and return true when FeeManager throws a sidetree error', async () => {
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 0,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer',
};
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeTruthy();
});
it('should return true if anchor file hash is not valid', async () => {
spyOn(downloadManager, 'download').and.callFake(
(): Promise<FetchResult> => {
const result: FetchResult = { code: FetchResultCode.InvalidHash };
return new Promise((resolve) => {
resolve(result);
});
}
);
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 1,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 999999,
normalizedTransactionFee: 1,
writer: 'writer',
};
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeTruthy();
});
it('should return true if fetch result code is max size exceeded', async () => {
spyOn(downloadManager, 'download').and.callFake(
(): Promise<FetchResult> => {
const result: FetchResult = { code: FetchResultCode.MaxSizeExceeded };
return new Promise((resolve) => {
resolve(result);
});
}
);
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 1,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 999999,
normalizedTransactionFee: 1,
writer: 'writer',
};
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeTruthy();
});
it('should return true if fetch result code is not a file', async () => {
spyOn(downloadManager, 'download').and.callFake(
(): Promise<FetchResult> => {
const result: FetchResult = { code: FetchResultCode.NotAFile };
return new Promise((resolve) => {
resolve(result);
});
}
);
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 1,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 999999,
normalizedTransactionFee: 1,
writer: 'writer',
};
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeTruthy();
});
it('should return true if fetch result code is cas not reachable', async () => {
spyOn(downloadManager, 'download').and.callFake(
(): Promise<FetchResult> => {
const result: FetchResult = { code: FetchResultCode.CasNotReachable };
return new Promise((resolve) => {
resolve(result);
});
}
);
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 1,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 999999,
normalizedTransactionFee: 1,
writer: 'writer',
};
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeFalsy();
});
it('should return true if fetch result code is not found', async () => {
spyOn(downloadManager, 'download').and.callFake(
(): Promise<FetchResult> => {
const result: FetchResult = { code: FetchResultCode.NotFound };
return new Promise((resolve) => {
resolve(result);
});
}
);
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 1,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 999999,
normalizedTransactionFee: 1,
writer: 'writer',
};
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeFalsy();
});
it('should return false to allow retry if unexpected error is thrown', async () => {
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 1,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 999999,
normalizedTransactionFee: 1,
writer: 'writer',
};
// Mock a method used by `processTransaction` to throw an error.
spyOn(AnchoredDataSerializer, 'deserialize').and.throwError(
'Some unexpected error.'
);
const result = await transactionProcessor.processTransaction(
mockTransaction
);
expect(result).toBeFalsy();
});
});
describe('downloadAndVerifyAnchorFile', () => {
it('should throw if paid operation count exceeded the protocol limit.', async () => {
const mockTransaction: TransactionModel = {
anchorString: 'anchor string',
normalizedTransactionFee: 123,
transactionFeePaid: 1234,
transactionNumber: 98765,
transactionTime: 5678,
transactionHash: 'hash',
transactionTimeHash: 'transaction time hash',
writer: 'writer',
};
await JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrownAsync(
() =>
transactionProcessor['downloadAndVerifyAnchorFile'](
mockTransaction,
'mock_hash',
999999
), // Some really large paid operation count.
ErrorCode.TransactionProcessorPaidOperationCountExceedsLimit
);
});
it('should throw if operation count in anchor file exceeded the paid limit.', async () => {
const createOperation1 = (
await OperationGenerator.generateCreateOperation()
).createOperation;
const createOperation2 = (
await OperationGenerator.generateCreateOperation()
).createOperation;
const anyHash = OperationGenerator.generateRandomHash();
const mockAnchorFileModel = await AnchorFile.createModel(
'writerLockId',
anyHash,
[createOperation1, createOperation2],
[],
[]
);
const mockAnchorFileBuffer = await Compressor.compress(
Buffer.from(JSON.stringify(mockAnchorFileModel))
);
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.returnValue(
Promise.resolve(mockAnchorFileBuffer)
);
const mockTransaction: TransactionModel = {
anchorString: 'anchor string',
normalizedTransactionFee: 123,
transactionFeePaid: 1234,
transactionNumber: 98765,
transactionTime: 5678,
transactionHash: 'hash',
transactionTimeHash: 'transaction time hash',
writer: 'writer',
};
await JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrownAsync(
() =>
transactionProcessor['downloadAndVerifyAnchorFile'](
mockTransaction,
'mock_hash',
1
),
ErrorCode.AnchorFileOperationCountExceededPaidLimit
);
});
it('should bubble up any errors thrown by verify lock routine', async () => {
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.returnValue(
Promise.resolve(Buffer.from('value'))
);
const mockAnchorFile: AnchorFile = {
createOperations: [],
didUniqueSuffixes: ['abc', 'def'],
model: {
writer_lock_id: 'lock',
map_file_uri: 'map_hash',
operations: {},
},
recoverOperations: [],
deactivateOperations: [],
};
spyOn(AnchorFile, 'parse').and.returnValue(
Promise.resolve(mockAnchorFile)
);
const mockValueTimeLock: ValueTimeLockModel = {
amountLocked: 1234,
identifier: 'identifier',
lockTransactionTime: 1234,
unlockTransactionTime: 7890,
normalizedFee: 200,
owner: 'owner',
};
spyOn(
transactionProcessor['blockchain'],
'getValueTimeLock'
).and.returnValue(Promise.resolve(mockValueTimeLock));
const mockTransaction: TransactionModel = {
anchorString: 'anchor string',
normalizedTransactionFee: 123,
transactionFeePaid: 1234,
transactionNumber: 98765,
transactionTime: 5678,
transactionHash: 'hash',
transactionTimeHash: 'transaction time hash',
writer: 'writer',
};
const mockErrorCode = 'some error code';
const lockVerifySpy = spyOn(
ValueTimeLockVerifier,
'verifyLockAmountAndThrowOnError'
).and.callFake(() => {
throw new SidetreeError(mockErrorCode);
});
const paidOperationCount = 52;
await JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrownAsync(
() =>
transactionProcessor['downloadAndVerifyAnchorFile'](
mockTransaction,
'anchor_hash',
paidOperationCount
),
mockErrorCode
);
expect(lockVerifySpy).toHaveBeenCalledWith(
mockValueTimeLock,
paidOperationCount,
mockTransaction.transactionTime,
mockTransaction.writer,
versionMetadataFetcher
);
});
it('should return the parsed file.', async () => {
const createOperationData = await OperationGenerator.generateCreateOperation();
const anyHash = OperationGenerator.generateRandomHash();
const mockAnchorFileModel = await AnchorFile.createModel(
'wrierLockId',
anyHash,
[createOperationData.createOperation],
[],
[]
);
const mockAnchorFileBuffer = await Compressor.compress(
Buffer.from(JSON.stringify(mockAnchorFileModel))
);
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.returnValue(
Promise.resolve(mockAnchorFileBuffer)
);
spyOn(
transactionProcessor['blockchain'],
'getValueTimeLock'
).and.returnValue(Promise.resolve(undefined));
spyOn(
ValueTimeLockVerifier,
'verifyLockAmountAndThrowOnError'
).and.returnValue(undefined);
const mockTransaction: TransactionModel = {
anchorString: 'anchor string',
normalizedTransactionFee: 123,
transactionFeePaid: 1234,
transactionNumber: 98765,
transactionTime: 5678,
transactionHash: 'hash',
transactionTimeHash: 'transaction time hash',
writer: 'writer',
};
const paidBatchSize = 2;
const downloadedAnchorFile = await transactionProcessor[
'downloadAndVerifyAnchorFile'
](mockTransaction, 'mock_hash', paidBatchSize);
expect(downloadedAnchorFile.model).toEqual(mockAnchorFileModel);
});
});
describe('downloadAndVerifyMapFile', () => {
it('should validate the map file when the map file does not declare the `operations` property.', async () => {
const createOperationData = await OperationGenerator.generateCreateOperation();
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperationData.createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Setting up a mock map file that has 1 update in it to be downloaded.
const chunkFileHash = OperationGenerator.generateRandomHash();
const mockMapFileBuffer = await MapFile.createBuffer(chunkFileHash, []);
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.returnValue(
Promise.resolve(mockMapFileBuffer)
);
// Setting the total paid operation count to be 1 (needs to be at least 2 in success case).
const totalPaidOperationCount = 1;
const fetchedMapFile = await transactionProcessor[
'downloadAndVerifyMapFile'
](anchorFile, totalPaidOperationCount);
expect(fetchedMapFile).toBeDefined();
expect(fetchedMapFile!.updateOperations.length).toEqual(0);
expect(fetchedMapFile!.model.chunks[0].chunk_file_uri).toEqual(
chunkFileHash
);
});
it('should return undefined if update operation count is greater than the max paid update operation count.', async () => {
const createOperationData = await OperationGenerator.generateCreateOperation();
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperationData.createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Setting up a mock map file that has 1 update in it to be downloaded.
const updateOperationRequestData = await OperationGenerator.generateUpdateOperationRequest();
const chunkFileHash = OperationGenerator.generateRandomHash();
const mockMapFileBuffer = await MapFile.createBuffer(chunkFileHash, [
updateOperationRequestData.updateOperation,
]);
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.returnValue(
Promise.resolve(mockMapFileBuffer)
);
// Setting the total paid operation count to be 1 (needs to be at least 2 in success case).
const totalPaidOperationCount = 1;
const fetchedMapFile = await transactionProcessor[
'downloadAndVerifyMapFile'
](anchorFile, totalPaidOperationCount);
expect(fetchedMapFile).toBeUndefined();
});
it('should return undefined if there are multiple operations for the same DID between anchor and map file.', async () => {
const createOperationData = await OperationGenerator.generateCreateOperation();
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperationData.createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Setting up a mock map file that has 1 update in it to be downloaded.
const updateOperationRequestData = await OperationGenerator.generateUpdateOperationRequest(
createOperationData.createOperation.didUniqueSuffix
);
const chunkFileHash = OperationGenerator.generateRandomHash();
const mockMapFileBuffer = await MapFile.createBuffer(chunkFileHash, [
updateOperationRequestData.updateOperation,
]);
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.returnValue(
Promise.resolve(mockMapFileBuffer)
);
const totalPaidOperationCount = 10;
const fetchedMapFile = await transactionProcessor[
'downloadAndVerifyMapFile'
](anchorFile, totalPaidOperationCount);
expect(fetchedMapFile).toBeUndefined();
});
it('should return undefined if unexpected error caught.', async () => {
const createOperationData = await OperationGenerator.generateCreateOperation();
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperationData.createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Mocking an unexpected error thrown.
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.throwError(
'Any unexpected error.'
);
const totalPaidOperationCount = 10;
const fetchedMapFile = await transactionProcessor[
'downloadAndVerifyMapFile'
](anchorFile, totalPaidOperationCount);
expect(fetchedMapFile).toBeUndefined();
});
it('should throw if a network related error is caught.', async () => {
const createOperationData = await OperationGenerator.generateCreateOperation();
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperationData.createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Mocking a non-network related known error thrown.
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.callFake(
() => {
throw new SidetreeError(ErrorCode.CasNotReachable);
}
);
const totalPaidOperationCount = 10;
await JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrownAsync(
() =>
transactionProcessor['downloadAndVerifyMapFile'](
anchorFile,
totalPaidOperationCount
),
ErrorCode.CasNotReachable
);
});
it('should return undefined if non-network related known error is caught.', async () => {
const createOperationData = await OperationGenerator.generateCreateOperation();
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperationData.createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Mocking a non-network related known error thrown.
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.callFake(
() => {
throw new SidetreeError(ErrorCode.CasFileTooLarge);
}
);
const totalPaidOperationCount = 10;
const fetchedMapFile = await transactionProcessor[
'downloadAndVerifyMapFile'
](anchorFile, totalPaidOperationCount);
expect(fetchedMapFile).toBeUndefined();
});
});
describe('downloadAndVerifyChunkFile', () => {
it('should return undefined if no map file is given.', async () => {
const mapFileModel = undefined;
const fetchedChunkFileModel = await transactionProcessor[
'downloadAndVerifyChunkFile'
](mapFileModel);
expect(fetchedChunkFileModel).toBeUndefined();
});
it('should return undefined if unexpected error caught.', async () => {
const anyHash = OperationGenerator.generateRandomHash();
const mapFileBuffer = await MapFile.createBuffer(anyHash, []);
const mapFileModel = await MapFile.parse(mapFileBuffer);
// Mocking an unexpected error thrown.
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.throwError(
'Any unexpected error.'
);
const fetchedMapFile = await transactionProcessor[
'downloadAndVerifyChunkFile'
](mapFileModel);
expect(fetchedMapFile).toBeUndefined();
});
it('should throw if a network related error is caught.', async () => {
const anyHash = OperationGenerator.generateRandomHash();
const mapFileBuffer = await MapFile.createBuffer(anyHash, []);
const mapFileModel = await MapFile.parse(mapFileBuffer);
// Mocking a non-network related known error thrown.
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.callFake(
() => {
throw new SidetreeError(ErrorCode.CasNotReachable);
}
);
await JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrownAsync(
() => transactionProcessor['downloadAndVerifyChunkFile'](mapFileModel),
ErrorCode.CasNotReachable
);
});
it('should return undefined if non-network related known error is caught.', async () => {
const anyHash = OperationGenerator.generateRandomHash();
const mapFileBuffer = await MapFile.createBuffer(anyHash, []);
const mapFileModel = await MapFile.parse(mapFileBuffer);
// Mocking a non-network related known error thrown.
spyOn(transactionProcessor as any, 'downloadFileFromCas').and.callFake(
() => {
throw new SidetreeError(ErrorCode.CasFileTooLarge);
}
);
const fetchedMapFile = await transactionProcessor[
'downloadAndVerifyChunkFile'
](mapFileModel);
expect(fetchedMapFile).toBeUndefined();
});
});
describe('composeAnchoredOperationModels', () => {
it('should compose operations successfully given valid anchor, map, and chunk files.', async () => {
// Create `TransactionModel`.
const transactionModel: TransactionModel = {
anchorString: 'anything',
normalizedTransactionFee: 999,
transactionFeePaid: 9999,
transactionNumber: 1,
transactionTime: 1,
transactionHash: 'hash',
transactionTimeHash: 'anyValue',
writer: 'anyWriter',
};
// Create anchor file with 1 create operation.
const createOperationData = await OperationGenerator.generateCreateOperation();
const createOperation = createOperationData.createOperation;
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Create map file model with 1 update operation.
const updateOperationRequestData = await OperationGenerator.generateUpdateOperationRequest();
const updateOperation = updateOperationRequestData.updateOperation;
const chunkFileHash = OperationGenerator.generateRandomHash();
const mapFileBuffer = await MapFile.createBuffer(chunkFileHash, [
updateOperation,
]);
const mapFileModel = await MapFile.parse(mapFileBuffer);
// Create chunk file model with delta for the 2 operations created above.
const chunkFileBuffer = await ChunkFile.createBuffer(
[createOperation],
[],
[updateOperation]
);
const chunkFileModel = await ChunkFile.parse(chunkFileBuffer);
// Setting the total paid operation count to be 1 (needs to be at least 2 in success case).
const anchoredOperationModels = await transactionProcessor[
'composeAnchoredOperationModels'
](transactionModel, anchorFile, mapFileModel, chunkFileModel);
expect(anchoredOperationModels.length).toEqual(2);
expect(anchoredOperationModels[0].didUniqueSuffix).toEqual(
createOperation.didUniqueSuffix
);
expect(anchoredOperationModels[0].operationIndex).toEqual(0);
expect(anchoredOperationModels[0].transactionTime).toEqual(1);
expect(anchoredOperationModels[1].didUniqueSuffix).toEqual(
updateOperation.didUniqueSuffix
);
});
it('should compose operations successfully given valid anchor file, but no map and chunk files.', async () => {
// Create `TransactionModel`.
const transactionModel: TransactionModel = {
anchorString: 'anything',
normalizedTransactionFee: 999,
transactionFeePaid: 9999,
transactionNumber: 1,
transactionTime: 1,
transactionHash: 'hash',
transactionTimeHash: 'anyValue',
writer: 'anyWriter',
};
// Create anchor file with 1 create operation.
const createOperationData = await OperationGenerator.generateCreateOperation();
const createOperation = createOperationData.createOperation;
const mapFileHash = OperationGenerator.generateRandomHash();
const anchorFileBuffer = await AnchorFile.createBuffer(
'writerLockId',
mapFileHash,
[createOperation],
[],
[]
);
const anchorFile = await AnchorFile.parse(anchorFileBuffer);
// Setting the total paid operation count to be 1 (needs to be at least 2 in success case).
const anchoredOperationModels = await transactionProcessor[
'composeAnchoredOperationModels'
](transactionModel, anchorFile, undefined, undefined);
expect(anchoredOperationModels.length).toEqual(1);
expect(anchoredOperationModels[0].didUniqueSuffix).toEqual(
createOperation.didUniqueSuffix
);
expect(anchoredOperationModels[0].operationIndex).toEqual(0);
expect(anchoredOperationModels[0].transactionTime).toEqual(1);
});
});
});
|
devrajsinghrawat/sidetree.js
|
packages/wallet/src/operations/__tests__/ion/SidetreeWallet.Operations.spec.ts
|
<reponame>devrajsinghrawat/sidetree.js<filename>packages/wallet/src/operations/__tests__/ion/SidetreeWallet.Operations.spec.ts
// Based on:
// https://github.com/decentralized-identity/ion-sdk/blob/main/tests/operations.spec.ts
import { OperationType, SidetreeDocumentModel } from '../../types';
import LocalSigner from '../../LocalSigner';
import * as operations from '../../index';
describe('SidetreeWallet.operations', () => {
describe('createCreateRequest', () => {
it('should generate a create request with desired arguments', async () => {
const recoveryKey = require('./vectors/inputs/jwkEs256k1Public.json');
const updateKey = require('./vectors/inputs/jwkEs256k2Public.json');
const publicKey = require('./vectors/inputs/publicKeyModel1.json');
const publicKeys = [publicKey];
const service = require('./vectors/inputs/service1.json');
const services = [service];
const document: SidetreeDocumentModel = {
publicKeys,
services,
};
const input = { recoveryKey, updateKey, document };
const result = operations.create(input);
expect(result.type).toEqual(OperationType.Create);
expect(result.delta.updateCommitment).toEqual(
'EiDKIkwqO69IPG3pOlHkdb86nYt0aNxSHZu2r-bhEznjdA'
);
expect(result.delta.patches.length).toEqual(1);
expect(result.suffixData.recoveryCommitment).toEqual(
'EiBfOZdMtU6OBw8Pk879QtZ-2J-9FbbjSZyoaA_bqD4zhA'
);
expect(result.suffixData.deltaHash).toEqual(
'EiCfDWRnYlcD9EGA3d_5Z1AHu-iYqMbJ9nfiqdz5S8VDbg'
);
});
});
describe('createUpdateRequest', () => {
it('should generate an update request with the given arguments', async () => {
const publicKey = require('./vectors/inputs/publicKeyModel1.json');
const publicKeys = [publicKey];
const service = require('./vectors/inputs/service1.json');
const services = [service];
const input = {
didSuffix: '<KEY>',
updatePublicKey: require('./vectors/inputs/jwkEs256k1Public.json'),
nextUpdatePublicKey: require('./vectors/inputs/jwkEs256k2Public.json'),
servicesToAdd: services,
idsOfServicesToRemove: ['someId1'],
publicKeysToAdd: publicKeys,
idsOfPublicKeysToRemove: ['someId2'],
signer: LocalSigner.create(
require('./vectors/inputs/jwkEs256k1Private.json')
),
};
const result = await operations.update(input);
expect(result.didSuffix).toEqual(
'EiDyOQbbZAa3aiRzeCkV7LOx3SERjjH93EXoIM3UoN4oWg'
);
expect(result.type).toEqual(OperationType.Update);
expect(result.revealValue).toEqual(
'EiAJ-97Is59is6FKAProwDo870nmwCeP8n5nRRFwPpUZVQ'
);
expect(result.signedData).toEqual(
'<KEY>YO9MrPFw'
);
expect(result.delta.updateCommitment).toEqual(
'EiDKIkwqO69IPG3pOlHkdb86nYt0aNxSHZu2r-bhEznjdA'
);
expect(result.delta.patches.length).toEqual(4); // add/remove service and add/remove key
});
it('should generate an update request with the no arguments', async () => {
const input = {
didSuffix: '<KEY>',
updatePublicKey: require('./vectors/inputs/jwkEs256k1Public.json'),
nextUpdatePublicKey: require('./vectors/inputs/jwkEs256k2Public.json'),
signer: LocalSigner.create(
require('./vectors/inputs/jwkEs256k1Private.json')
),
};
const result = await operations.update(input);
expect(result.didSuffix).toEqual(
'<KEY>'
);
});
});
describe('createRecoverRequest', () => {
it('should generate a recover request with given arguments', async () => {
const publicKey = require('./vectors/inputs/publicKeyModel1.json');
const publicKeys = [publicKey];
const service = require('./vectors/inputs/service1.json');
const services = [service];
const document: SidetreeDocumentModel = {
publicKeys,
services,
};
const result = await operations.recover({
didSuffix: '<KEY>',
recoveryPublicKey: require('./vectors/inputs/jwkEs256k1Public.json'),
nextRecoveryPublicKey: require('./vectors/inputs/jwkEs256k2Public.json'),
nextUpdatePublicKey: require('./vectors/inputs/jwkEs256k3Public.json'),
document,
signer: LocalSigner.create(
require('./vectors/inputs/jwkEs256k1Private.json')
),
});
expect(result.didSuffix).toEqual(
'EiDyOQbbZAa3aiRzeCkV7LOx3SERjjH93EXoIM3UoN4oWg'
);
expect(result.revealValue).toEqual(
'EiAJ-97Is59is6FKAProwDo870nmwCeP8n5nRRFwPpUZVQ'
);
expect(result.type).toEqual(OperationType.Recover);
expect(result.signedData).toEqual(
'<KEY>'
);
expect(result.delta.updateCommitment).toEqual(
'EiBJGXo0XUiqZQy0r-fQUHKS3RRVXw5nwUpqGVXEGuTs-g'
);
expect(result.delta.patches.length).toEqual(1); // replace
});
});
describe('createDeactivateRequest', () => {
it('should generate a deactivate request with the given arguments', async () => {
const result = await operations.deactivate({
didSuffix: 'EiDyOQbbZAa3aiRzeCkV7LOx3SERjjH93EXoIM3UoN4oWg',
recoveryPublicKey: require('./vectors/inputs/jwkEs256k1Public.json'),
signer: LocalSigner.create(
require('./vectors/inputs/jwkEs256k1Private.json')
),
});
expect(result.didSuffix).toEqual(
'EiDyOQbbZAa3aiRzeCkV7LOx3SERjjH93EXoIM3UoN4oWg'
);
expect(result.type).toEqual(OperationType.Deactivate);
expect(result.revealValue).toEqual(
'EiAJ-97Is59is6FKAProwDo870nmwCeP8n5nRRFwPpUZVQ'
);
expect(result.signedData).toEqual(
'<KEY>'
);
});
});
});
|
devrajsinghrawat/sidetree.js
|
packages/db/src/MongoDbBase.ts
|
<filename>packages/db/src/MongoDbBase.ts
/*
* The code in this file originated from
* @see https://github.com/decentralized-identity/sidetree
* For the list of changes that was made to the original code
* @see https://github.com/transmute-industries/sidetree.js/blob/main/reference-implementation-changes.md
*
* Copyright 2020 - Transmute Industries Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { Collection, MongoClient, Db } from 'mongodb';
import MongoDb from './MongoDb';
export default abstract class MongoDbBase {
abstract collectionName: string;
private serverUrl: string;
public databaseName: string;
private client: MongoClient | undefined;
protected db: Db | undefined;
protected collection: Collection<any> | undefined;
constructor(serverUrl: string, databaseName: string) {
this.serverUrl = serverUrl;
this.databaseName = databaseName;
}
public async close(): Promise<void> {
return this.client!.close();
}
public async clearCollection(): Promise<void> {
try {
await this.collection!.deleteMany({});
} catch (e) {
// do nothing.
}
}
public async initialize(): Promise<void> {
this.client =
this.client ||
(await MongoClient.connect(this.serverUrl, {
useUnifiedTopology: true,
useNewUrlParser: true,
})); // `useNewUrlParser` addresses nodejs's URL parser deprecation warning.
this.db = this.client.db(this.databaseName);
this.collection = await MongoDb.createCollectionIfNotExist(
this.db!,
this.collectionName
);
}
}
|
devrajsinghrawat/sidetree.js
|
packages/core/src/Resolver.ts
|
/*
* The code in this file originated from
* @see https://github.com/decentralized-identity/sidetree
* For the list of changes that was made to the original code
* @see https://github.com/transmute-industries/sidetree.js/blob/main/reference-implementation-changes.md
*
* Copyright 2020 - Transmute Industries Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import {
AnchoredOperationModel,
DidState,
IOperationStore,
IVersionManager,
Multihash,
OperationType,
SidetreeError,
} from '@sidetree/common';
/**
* NOTE: Resolver cannot be versioned because it needs to be aware of `VersionManager` to fetch versioned operation processors.
*/
export default class Resolver {
public constructor(
private versionManager: IVersionManager,
private operationStore: IOperationStore
) {}
/**
* Resolve the given DID unique suffix to its latest DID state.
* @param didUniqueSuffix The unique suffix of the DID to resolve. e.g. if 'did:sidetree:abc123' is the DID, the unique suffix would be 'abc123'
* @returns Final DID state of the DID. Undefined if the unique suffix of the DID is not found or the DID state is not constructable.
*/
public async resolve(didUniqueSuffix: string): Promise<DidState | undefined> {
console.info(`Resolving DID unique suffix '${didUniqueSuffix}'...`);
const operations = await this.operationStore.get(didUniqueSuffix);
const operationsByType = Resolver.categorizeOperationsByType(operations);
// Find and apply a valid create operation.
let didState = await this.applyCreateOperation(
operationsByType.createOperations
);
// If can't construct an initial DID state.
if (didState === undefined) {
return undefined;
}
// Apply recovery/deactivate operations until an operation matching the next recovery commitment cannot be found.
const recoverAndDeactivateOperations = operationsByType.recoverOperations.concat(
operationsByType.deactivateOperations
);
const recoveryCommitValueToOperationMap = await this.constructCommitValueToOperationLookupMap(
recoverAndDeactivateOperations
);
didState = await this.applyRecoverAndDeactivateOperations(
didState,
recoveryCommitValueToOperationMap
);
// If the previous applied operation is a deactivate. No need to continue further.
if (didState.nextRecoveryCommitmentHash === undefined) {
return didState;
}
// Apply update operations until an operation matching the next update commitment cannot be found.
const updateCommitValueToOperationMap = await this.constructCommitValueToOperationLookupMap(
operationsByType.updateOperations
);
didState = await this.applyUpdateOperations(
didState,
updateCommitValueToOperationMap
);
return didState;
}
private static categorizeOperationsByType(
operations: AnchoredOperationModel[]
): {
createOperations: AnchoredOperationModel[];
recoverOperations: AnchoredOperationModel[];
updateOperations: AnchoredOperationModel[];
deactivateOperations: AnchoredOperationModel[];
} {
const createOperations = [];
const recoverOperations = [];
const updateOperations = [];
const deactivateOperations = [];
for (const operation of operations) {
if (operation.type === OperationType.Create) {
createOperations.push(operation);
} else if (operation.type === OperationType.Recover) {
recoverOperations.push(operation);
} else if (operation.type === OperationType.Update) {
updateOperations.push(operation);
} else {
// This is a deactivate operation.
deactivateOperations.push(operation);
}
}
return {
createOperations,
recoverOperations,
updateOperations,
deactivateOperations,
};
}
/**
* Iterate through all duplicates of creates until we can construct an initial DID state (some creates maybe incomplete. eg. without `delta`).
*/
private async applyCreateOperation(
createOperations: AnchoredOperationModel[]
): Promise<DidState | undefined> {
let didState;
for (const createOperation of createOperations) {
didState = await this.applyOperation(createOperation, undefined);
// Exit loop as soon as we can construct an initial state.
if (didState !== undefined) {
break;
}
}
return didState;
}
/**
* Apply recovery/deactivate operations until an operation matching the next recovery commitment cannot be found.
*/
private async applyRecoverAndDeactivateOperations(
startingDidState: DidState,
commitValueToOperationMap: Map<string, AnchoredOperationModel[]>
): Promise<DidState> {
let didState = startingDidState;
while (
commitValueToOperationMap.has(didState.nextRecoveryCommitmentHash!)
) {
let operationsWithCorrectRevealValue: AnchoredOperationModel[] = commitValueToOperationMap.get(
didState.nextRecoveryCommitmentHash!
)!;
// Sort using blockchain time.
operationsWithCorrectRevealValue = operationsWithCorrectRevealValue.sort(
(a, b) => a.transactionNumber - b.transactionNumber
);
const newDidState:
| DidState
| undefined = await this.applyFirstValidOperation(
operationsWithCorrectRevealValue,
didState
);
// We are done if we can't find a valid recover/deactivate operation to apply.
if (newDidState === undefined) {
break;
}
// We reach here if we have successfully computed a new DID state.
didState = newDidState;
// If the previous applied operation is a deactivate. No need to continue further.
if (didState.nextRecoveryCommitmentHash === undefined) {
return didState;
}
}
return didState;
}
/**
* Apply update operations until an operation matching the next update commitment cannot be found.
*/
private async applyUpdateOperations(
startingDidState: DidState,
commitValueToOperationMap: Map<string, AnchoredOperationModel[]>
): Promise<DidState> {
let didState = startingDidState;
while (commitValueToOperationMap.has(didState.nextUpdateCommitmentHash!)) {
let operationsWithCorrectRevealValue: AnchoredOperationModel[] = commitValueToOperationMap.get(
didState.nextUpdateCommitmentHash!
)!;
// Sort using blockchain time.
operationsWithCorrectRevealValue = operationsWithCorrectRevealValue.sort(
(a, b) => a.transactionNumber - b.transactionNumber
);
const newDidState:
| DidState
| undefined = await this.applyFirstValidOperation(
operationsWithCorrectRevealValue,
didState
);
// We are done if we can't find a valid update operation to apply.
if (newDidState === undefined) {
break;
}
// We reach here if we have successfully computed a new DID state.
didState = newDidState;
}
return didState;
}
/**
* Applies the given operation to the given DID state.
* @param operation The operation to be applied.
* @param didState The DID state to apply the operation on top of.
* @returns The resultant `DidState`. The given DID state is return if the given operation cannot be applied.
*/
private async applyOperation(
operation: AnchoredOperationModel,
didState: DidState | undefined
): Promise<DidState | undefined> {
let appliedDidState = didState;
// NOTE: MUST NOT throw error, else a bad operation can be used to denial resolution for a DID.
try {
const operationProcessor = this.versionManager.getOperationProcessor(
operation.transactionTime
);
appliedDidState = await operationProcessor.apply(
operation,
appliedDidState
);
} catch (error) {
console.log(
`Skipped bad operation for DID ${operation.didUniqueSuffix} at time ${
operation.transactionTime
}. Error: ${SidetreeError.stringify(error as any)}`
);
}
return appliedDidState;
}
/**
* @returns The new DID State if a valid operation is applied, `undefined` otherwise.
*/
private async applyFirstValidOperation(
operations: AnchoredOperationModel[],
originalDidState: DidState
): Promise<DidState | undefined> {
let newDidState = originalDidState;
// Stop as soon as an operation is applied successfully.
for (const operation of operations) {
newDidState = (await this.applyOperation(operation, newDidState))!;
// If operation matching the recovery commitment is applied.
if (
newDidState.lastOperationTransactionNumber !==
originalDidState.lastOperationTransactionNumber
) {
return newDidState;
}
}
// Else we reach the end of operations without being able to apply any of them.
return undefined;
}
/**
* Constructs a single commit value -> operation lookup map by looping through each supported hash algorithm,
* hashing each operations as key, then adding the result to a map.
*/
private async constructCommitValueToOperationLookupMap(
nonCreateOperations: AnchoredOperationModel[]
): Promise<Map<string, AnchoredOperationModel[]>> {
const commitValueToOperationMap = new Map<
string,
AnchoredOperationModel[]
>();
// Loop through each supported algorithm and hash each operation.
const allSupportedHashAlgorithms = this.versionManager
.allSupportedHashAlgorithms;
for (const hashAlgorithm of allSupportedHashAlgorithms) {
for (const operation of nonCreateOperations) {
const operationProcessor = this.versionManager.getOperationProcessor(
operation.transactionTime
);
const revealValueBuffer = await operationProcessor.getRevealValue(
operation
);
const hashOfRevealValue = Multihash.hashThenEncode(
revealValueBuffer,
hashAlgorithm
);
if (commitValueToOperationMap.has(hashOfRevealValue)) {
commitValueToOperationMap.get(hashOfRevealValue)!.push(operation);
} else {
commitValueToOperationMap.set(hashOfRevealValue, [operation]);
}
}
}
return commitValueToOperationMap;
}
}
|
devrajsinghrawat/sidetree.js
|
packages/core/src/test/Observer.spec.ts
|
/*
* The code in this file originated from
* @see https://github.com/decentralized-identity/sidetree
* For the list of changes that was made to the original code
* @see https://github.com/transmute-industries/sidetree.js/blob/main/reference-implementation-changes.md
*
* Copyright 2020 - Transmute Industries Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import retry from 'async-retry';
import {
AnchoredDataSerializer,
IOperationStore,
Encoder,
SharedErrorCode,
FetchResult,
FetchResultCode,
IVersionManager,
SidetreeError,
TransactionModel,
Multihash,
} from '@sidetree/common';
import AnchorFile from '../write/AnchorFile';
import { MockLedger } from '@sidetree/ledger';
import { MockCas } from '@sidetree/cas';
import ChunkFile from '../write/ChunkFile';
import DownloadManager from '../DownloadManager';
import MapFile from '../write/MapFile';
import MockOperationStore from './mocks/MockOperationStore';
import MockTransactionStore from './mocks/MockTransactionStore';
import MockVersionManager from './mocks/MockVersionManager';
import Observer from '../Observer';
import OperationGenerator from './generators/OperationGenerator';
import TransactionSelector from '../TransactionSelector';
import TransactionProcessor from '../TransactionProcessor';
console.info = (): null => null;
describe('Observer', () => {
const config = require('./config-test.json');
let casClient;
let downloadManager: DownloadManager;
let operationStore: IOperationStore;
let transactionStore: MockTransactionStore;
let blockchain: MockLedger;
let versionManager: IVersionManager;
beforeAll(async () => {
jest.setTimeout(20000); // These asynchronous tests can take a bit longer than normal.
casClient = new MockCas();
// Setting the CAS to always return 404.
const readSpy = jest.spyOn(casClient, 'read');
readSpy.mockReturnValue(
Promise.resolve({ code: FetchResultCode.NotFound })
);
operationStore = new MockOperationStore();
transactionStore = new MockTransactionStore();
downloadManager = new DownloadManager(
config.maxConcurrentDownloads,
casClient
);
downloadManager.start();
blockchain = new MockLedger();
const versionMetadataFetcher = {} as any;
// Mock the blockchain to return an empty lock
const valueSpy = jest.spyOn(blockchain, 'getValueTimeLock');
valueSpy.mockReturnValue(Promise.resolve(undefined));
const transactionProcessor = new TransactionProcessor(
downloadManager,
operationStore,
blockchain,
versionMetadataFetcher
);
const transactionSelector = new TransactionSelector(transactionStore);
versionManager = new MockVersionManager();
const transactionProcessorSpy = jest.spyOn(
versionManager,
'getTransactionProcessor'
);
transactionProcessorSpy.mockReturnValue(transactionProcessor);
const transactionSelectorSpy = jest.spyOn(
versionManager,
'getTransactionSelector'
);
transactionSelectorSpy.mockReturnValue(transactionSelector);
});
beforeEach(() => {
transactionStore = new MockTransactionStore();
});
afterAll(() => {
downloadManager.stop();
});
it('should record transactions processed with expected outcome.', async () => {
// Prepare the mock response from blockchain service.
const initialTransactionFetchResponseBody = {
moreTransactions: false,
transactions: [
{
transactionNumber: 1,
transactionTime: 1000,
transactionTimeHash: '1000',
transactionHash: '1000',
anchorString: '1stTransaction',
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer1',
},
{
transactionNumber: 2,
transactionTime: 1000,
transactionTimeHash: '1000',
transactionHash: '1000',
anchorString: '2ndTransaction',
transactionFeePaid: 2,
normalizedTransactionFee: 2,
writer: 'writer2',
},
],
};
const subsequentTransactionFetchResponseBody = {
moreTransactions: false,
transactions: [],
};
const blockchainClient = new MockLedger();
let readInvocationCount = 0;
const mockReadFunction = async (): Promise<{
moreTransactions: boolean;
transactions: TransactionModel[];
}> => {
readInvocationCount++;
if (readInvocationCount === 1) {
return initialTransactionFetchResponseBody;
} else {
return subsequentTransactionFetchResponseBody;
}
};
const readSpy = jest.spyOn(blockchainClient, 'read');
readSpy.mockImplementation(mockReadFunction);
// Start the Observer.
const observer = new Observer(
versionManager,
blockchainClient,
config.maxConcurrentDownloads,
operationStore,
transactionStore,
transactionStore,
1
);
// mocking throughput limiter to make testing easier
const throughputspy = jest.spyOn(
observer['throughputLimiter'],
'getQualifiedTransactions'
);
throughputspy.mockImplementation((transactions: TransactionModel[]) => {
return new Promise((resolve) => {
resolve(transactions);
});
});
const processedTransactions = transactionStore.getTransactions();
await observer.startPeriodicProcessing(); // Asynchronously triggers Observer to start processing transactions immediately.
// Monitor the processed transactions list until change is detected or max retries is reached.
await retry(
async () => {
const processedTransactionCount = transactionStore.getTransactions()
.length;
if (processedTransactionCount === 2) {
return;
}
// NOTE: if anything throws, we retry.
throw new Error(
'Incorrect number of changes to the processed transactions list.'
);
},
{
retries: 10,
minTimeout: 500, // milliseconds
maxTimeout: 500, // milliseconds
}
);
observer.stopPeriodicProcessing(); // Asynchronously stops Observer from processing more transactions after the initial processing cycle.
// throughput limiter applies logic to filter out some transactions
expect(processedTransactions.length).toEqual(2);
expect(processedTransactions[0].anchorString).toEqual('1stTransaction');
expect(processedTransactions[1].anchorString).toEqual('2ndTransaction');
});
it('should process a valid operation batch successfully.', async () => {
const operation1Data = await OperationGenerator.generateAnchoredCreateOperation(
{ transactionTime: 1, transactionNumber: 1, operationIndex: 1 }
);
const operation2Data = await OperationGenerator.generateAnchoredCreateOperation(
{ transactionTime: 1, transactionNumber: 1, operationIndex: 2 }
);
const createOperations = [
operation1Data.createOperation,
operation2Data.createOperation,
];
// Generating chunk file data.
const mockbChunkFileBuffer = await ChunkFile.createBuffer(
createOperations,
[],
[]
);
const mockChunkFileFetchResult: FetchResult = {
code: FetchResultCode.Success,
content: mockbChunkFileBuffer,
};
const mockChunkFilehash = Encoder.encode(
Multihash.hash(Buffer.from('MockChunkFileHash'))
);
// Generating map file data.
const mockMapFileBuffer = await MapFile.createBuffer(mockChunkFilehash, []);
const mockMapFileHash = Encoder.encode(
Multihash.hash(Buffer.from('MockMapFileHash'))
);
const mockMapFileFetchResult: FetchResult = {
code: FetchResultCode.Success,
content: mockMapFileBuffer,
};
// Generating anchor file data.
const mockAnchorFileBuffer = await AnchorFile.createBuffer(
'writerlock',
mockMapFileHash,
createOperations,
[],
[]
);
const mockAnchoreFileFetchResult: FetchResult = {
code: FetchResultCode.Success,
content: mockAnchorFileBuffer,
};
const mockAnchorFilehash = Encoder.encode(
Multihash.hash(Buffer.from('MockAnchorFileHash'))
);
// Prepare the mock fetch results from the `DownloadManager.download()`.
const mockDownloadFunction = async (hash: string): Promise<FetchResult> => {
if (hash === mockAnchorFilehash) {
return mockAnchoreFileFetchResult;
} else if (hash === mockMapFileHash) {
return mockMapFileFetchResult;
} else if (hash === mockChunkFilehash) {
return mockChunkFileFetchResult;
} else {
throw new Error('Test failed, unexpected hash given');
}
};
const downloadSpy = jest.spyOn(downloadManager, 'download');
downloadSpy.mockImplementation(mockDownloadFunction);
const blockchainClient = new MockLedger();
const observer = new Observer(
versionManager,
blockchainClient,
config.maxConcurrentDownloads,
operationStore,
transactionStore,
transactionStore,
1
);
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: mockAnchorFilehash,
numberOfOperations: createOperations.length,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer',
};
const transactionUnderProcessing = {
transaction: mockTransaction,
processingStatus: 'pending',
};
await (observer as any).processTransaction(
mockTransaction,
transactionUnderProcessing
);
const didUniqueSuffixes = createOperations.map(
(operation) => operation.didUniqueSuffix
);
for (const didUniqueSuffix of didUniqueSuffixes) {
const operationArray = await operationStore.get(didUniqueSuffix);
expect(operationArray.length).toEqual(1);
}
});
// Testing invalid anchor file scenarios:
const invalidAnchorFileTestsInput = [
[FetchResultCode.MaxSizeExceeded, 'exceeded max size limit'],
[FetchResultCode.NotAFile, 'is not a file'],
[FetchResultCode.InvalidHash, 'is not a valid hash'],
];
for (const tuple of invalidAnchorFileTestsInput) {
const mockFetchReturnCode = tuple[0];
const expectedConsoleLogSubstring = tuple[1];
it(`should stop processing a transaction if ${mockFetchReturnCode}`, async () => {
const blockchainClient = new MockLedger();
const observer = new Observer(
versionManager,
blockchainClient,
config.maxConcurrentDownloads,
operationStore,
transactionStore,
transactionStore,
1
);
const downloadSpy = jest.spyOn(downloadManager, 'download');
downloadSpy.mockReturnValue(
Promise.resolve({ code: mockFetchReturnCode as FetchResultCode })
);
let expectedConsoleLogDetected = false;
const consoleSpy = jest.spyOn(global.console, 'info');
consoleSpy.mockImplementation((message: string) => {
if (message.includes(expectedConsoleLogSubstring)) {
expectedConsoleLogDetected = true;
}
});
jest.spyOn(transactionStore, 'removeUnresolvableTransaction');
jest.spyOn(transactionStore, 'recordUnresolvableTransactionFetchAttempt');
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: 'EiA_psBVqsuGjoYXMIRrcW_mPUG1yDXbh84VPXOuVQ5oqw',
numberOfOperations: 1,
});
const mockTransaction: TransactionModel = {
transactionNumber: 1,
transactionTime: 1000000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer',
};
const transactionUnderProcessing = {
transaction: mockTransaction,
processingStatus: 'pending',
};
await (observer as any).processTransaction(
mockTransaction,
transactionUnderProcessing
);
expect(expectedConsoleLogDetected).toBeTruthy();
expect(transactionStore.removeUnresolvableTransaction).toHaveBeenCalled();
expect(
transactionStore.recordUnresolvableTransactionFetchAttempt
).not.toHaveBeenCalled();
});
}
it('should detect and handle block reorganization correctly.', async () => {
// Prepare the mock response from blockchain service.
const initialTransactionFetchResponseBody = {
moreTransactions: false,
transactions: [
{
transactionNumber: 1,
transactionTime: 1000,
transactionTimeHash: '1000',
transactionHash: '1000',
anchorString: '1stTransaction',
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer1',
},
{
transactionNumber: 2,
transactionTime: 2000,
transactionTimeHash: '2000',
transactionHash: '2000',
anchorString: '2ndTransaction',
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer2',
},
{
transactionNumber: 3,
transactionTime: 3000,
transactionTimeHash: '3000',
transactionHash: '3000',
anchorString: '3rdTransaction',
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer3',
},
],
};
const transactionFetchResponseBodyAfterBlockReorg = {
moreTransactions: false,
transactions: [
{
transactionNumber: 2,
transactionTime: 2001,
transactionTimeHash: '2001',
transactionHash: '2001',
anchorString: '2ndTransactionNew',
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer1',
},
{
transactionNumber: 3,
transactionTime: 3001,
transactionTimeHash: '3000',
transactionHash: '3001',
anchorString: '3rdTransactionNew',
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer2',
},
{
transactionNumber: 4,
transactionTime: 4000,
transactionTimeHash: '4000',
transactionHash: '4000',
anchorString: '4thTransaction',
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer3',
},
],
};
const subsequentTransactionFetchResponseBody = {
moreTransactions: false,
transactions: [],
};
const blockchainClient = new MockLedger();
// Force blockchain time to be higher than the latest known transaction time by core,
// such that Observer will consider `InvalidTransactionNumberOrTimeHash` a block reorg.
(blockchainClient as any).latestTime = {
time: 5000,
hash: '5000',
};
let readInvocationCount = 0;
const mockReadFunction = async (): Promise<{
moreTransactions: boolean;
transactions: TransactionModel[];
}> => {
readInvocationCount++;
if (readInvocationCount === 1) {
// 1st call returns initial set of transactions.
return initialTransactionFetchResponseBody;
}
if (readInvocationCount === 2) {
// 2nd call simulates a block reorganization.
throw new SidetreeError(
SharedErrorCode.InvalidTransactionNumberOrTimeHash
);
}
if (readInvocationCount === 3) {
// 3nd call occurs after the 'getFirstValidTransaction' call and returns the 'correct' set of transactions.
return transactionFetchResponseBodyAfterBlockReorg;
} else {
return subsequentTransactionFetchResponseBody;
}
};
const readSpy = jest.spyOn(blockchainClient, 'read');
readSpy.mockImplementation(mockReadFunction);
// Make the `getFirstValidTransaction` call return the first transaction as the most recent knwon valid transactions.
const getTransactionSpy = jest.spyOn(
blockchainClient,
'getFirstValidTransaction'
);
getTransactionSpy.mockReturnValue(
Promise.resolve(initialTransactionFetchResponseBody.transactions[0])
);
// Process first set of transactions.
const observer = new Observer(
versionManager,
blockchainClient,
config.maxConcurrentDownloads,
operationStore,
transactionStore,
transactionStore,
1
);
// mocking throughput limiter to make testing easier
const transactionSpy = jest.spyOn(
observer['throughputLimiter'],
'getQualifiedTransactions'
);
transactionSpy.mockImplementation((transactions: TransactionModel[]) => {
return new Promise((resolve) => {
resolve(transactions);
});
});
await observer.startPeriodicProcessing(); // Asynchronously triggers Observer to start processing transactions immediately.
// Monitor the processed transactions list until the expected count or max retries is reached.
const processedTransactions = transactionStore.getTransactions();
await retry(
async () => {
const processedTransactionCount = processedTransactions.length;
if (processedTransactionCount === 4) {
return;
}
// NOTE: the `retry` library retries if error is thrown.
throw new Error('Block reorganization not handled.');
},
{
retries: 10,
minTimeout: 1000, // milliseconds
maxTimeout: 1000, // milliseconds
}
);
expect(processedTransactions.length).toEqual(4);
expect(processedTransactions[0].anchorString).toEqual('1stTransaction');
expect(processedTransactions[1].anchorString).toEqual('2ndTransactionNew');
expect(processedTransactions[2].anchorString).toEqual('3rdTransactionNew');
expect(processedTransactions[3].anchorString).toEqual('4thTransaction');
await observer.stopPeriodicProcessing();
});
it('should not rollback if blockchain time in bitcoin service is behind core service.', async () => {
const anchoredData = AnchoredDataSerializer.serialize({
anchorFileHash: '1stTransaction',
numberOfOperations: 1,
});
const transaction = {
transactionNumber: 1,
transactionTime: 1000,
transactionHash: 'hash',
transactionTimeHash: '1000',
anchorString: anchoredData,
transactionFeePaid: 1,
normalizedTransactionFee: 1,
writer: 'writer',
};
// Prep the transaction store with some initial state.
await transactionStore.addTransaction(transaction);
const blockchainClient = new MockLedger();
// Always return a blockchain time less than the last transaction known by core to simulate blockchain service being behind core service.
const timeSpy = jest.spyOn(blockchainClient, 'getLatestTime');
timeSpy.mockReturnValue(Promise.resolve({ time: 500, hash: '500' }));
// Simulate the read response when blockchain service blockchain time is behind core service's.
let readInvocationCount = 0;
const mockReadFunction = async (
sinceTransactionNumber?: number,
transactionTimeHash?: string
): Promise<{
moreTransactions: boolean;
transactions: TransactionModel[];
}> => {
readInvocationCount++;
expect(sinceTransactionNumber).toEqual(2);
expect(transactionTimeHash).toEqual('1000');
throw new SidetreeError(
SharedErrorCode.InvalidTransactionNumberOrTimeHash
);
};
const readSpy = jest.spyOn(blockchainClient, 'read');
readSpy.mockImplementation(mockReadFunction);
// NOTE: it is irrelvant what getFirstValidTransaction() returns because it is expected to be not called at all.
const getFirstValidTransactionSpy = jest.spyOn(
blockchainClient,
'getFirstValidTransaction'
);
getFirstValidTransactionSpy.mockReturnValue(Promise.resolve(undefined));
// Process first set of transactions.
const observer = new Observer(
versionManager,
blockchainClient,
config.maxConcurrentDownloads,
operationStore,
transactionStore,
transactionStore,
1
);
const revertInvalidTransactionsSpy = jest.spyOn(
observer as any,
'revertInvalidTransactions'
);
revertInvalidTransactionsSpy.mockReturnValue(Promise.resolve(undefined));
observer.startPeriodicProcessing(); // Asynchronously triggers Observer to start processing transactions immediately.
// Monitor the Observer until at two processing cycle has lapsed.
await retry(
async () => {
if (readInvocationCount >= 2) {
return;
}
// NOTE: the `retry` library retries if error is thrown.
throw new Error(
'Two transaction processing cycles have not occured yet.'
);
},
{
retries: 3,
minTimeout: 1000, // milliseconds
maxTimeout: 1000, // milliseconds
}
);
expect(revertInvalidTransactionsSpy).toHaveBeenCalledTimes(0);
expect(getFirstValidTransactionSpy).toHaveBeenCalledTimes(0);
observer.stopPeriodicProcessing();
});
});
|
devrajsinghrawat/sidetree.js
|
packages/wallet/src/operations/index.ts
|
<reponame>devrajsinghrawat/sidetree.js
export * from './create';
export * from './update';
export * from './recover';
export * from './deactivate';
export * from './createLongFormDid';
|
devrajsinghrawat/sidetree.js
|
packages/wallet/src/functions/sidetreeEncoding.ts
|
/*
* Copyright 2020 - Transmute Industries Inc.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import crypto from 'crypto';
import { Multihash, Encoder } from '@sidetree/common';
const sha256AlgorithmMultihashCode = 18;
export const sha256 = (data: Buffer): Buffer => {
return crypto
.createHash('sha256') // may need to change in the future.
.update(data)
.digest();
};
export const hashThenEncode = (data: Buffer): string => {
return Multihash.hashThenEncode(data, sha256AlgorithmMultihashCode);
};
export const canonicalizeThenHashThenEncode = (data: object): string => {
return Multihash.canonicalizeThenHashThenEncode(data);
};
export const canonicalizeThenDoubleHashThenEncode = (data: object): string => {
return Multihash.canonicalizeThenDoubleHashThenEncode(data);
};
export const encode = (data: Buffer | string): string => {
return Encoder.encode(data);
};
|
devrajsinghrawat/sidetree.js
|
packages/wallet/src/operations/LocalSigner.test.ts
|
import LocalSigner from './LocalSigner';
it('can sign with ES256K', async () => {
const signer = LocalSigner.create(
require('./__tests__/ion/vectors/inputs/jwkEs256k1Private.json')
);
const signature = await signer.sign({}, { hello: 'world' });
expect(signature).toBe(
'<KEY>'
);
});
|
devrajsinghrawat/sidetree.js
|
packages/wallet/src/functions/getRecoverOperationForProfile.ts
|
<filename>packages/wallet/src/functions/getRecoverOperationForProfile.ts
/*
* Copyright 2020 - Transmute Industries Inc.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import canonicalize from 'canonicalize';
import base64url from 'base64url';
import { sign } from '@sidetree/crypto';
import { canonicalizeThenHashThenEncode } from './sidetreeEncoding';
import { toKeyPair } from './toKeyPair';
import { PublicKeyPurpose } from '@sidetree/common';
import { SidetreeRecoverOperation, SidetreeReplaceOptions } from '../types';
export const getRecoverOperationForProfile = async (
mnemonic: string,
index: number,
didUniqueSuffix: string,
profile = 'SVIP',
options: SidetreeReplaceOptions = {}
): Promise<SidetreeRecoverOperation> => {
if (profile !== 'SVIP') {
throw new Error('SVIP Profile is only supported profile');
}
const currentRecoveryKeyPair = await toKeyPair(mnemonic, index, 'Ed25519');
const nextRecoveryKeyPair = await toKeyPair(mnemonic, index + 1, 'Ed25519');
const signingKeyPair = currentRecoveryKeyPair;
const keyAgreementKeyPair = await toKeyPair(mnemonic, index + 1, 'X25519');
const deleta_object = {
update_commitment: canonicalizeThenHashThenEncode(
nextRecoveryKeyPair.publicKeyJwk
),
patches: [
{
action: 'replace',
document: {
public_keys: [
{
id: signingKeyPair.id.split('#').pop(),
type: 'JsonWebKey2020',
jwk: signingKeyPair.publicKeyJwk,
purpose: [
PublicKeyPurpose.General,
PublicKeyPurpose.Auth,
PublicKeyPurpose.AssertionMethod,
PublicKeyPurpose.CapabilityInvocation,
PublicKeyPurpose.CapabilityDelegation,
],
},
{
id: keyAgreementKeyPair.id.split('#').pop(),
type: 'JsonWebKey2020',
jwk: keyAgreementKeyPair.publicKeyJwk,
purpose: [
PublicKeyPurpose.General,
PublicKeyPurpose.KeyAgreement,
],
},
],
...options,
},
},
],
};
const jws_payload = {
delta_hash: canonicalizeThenHashThenEncode(deleta_object),
recovery_key: JSON.parse(canonicalize(currentRecoveryKeyPair.publicKeyJwk)),
recovery_commitment: canonicalizeThenHashThenEncode(
nextRecoveryKeyPair.publicKeyJwk
),
};
const jws = await sign(
{},
jws_payload as any,
currentRecoveryKeyPair.privateKeyJwk
);
const encoded_delta = base64url.encode(canonicalize(deleta_object));
const recoverOperation: SidetreeRecoverOperation = {
type: 'recover',
did_suffix: didUniqueSuffix,
signed_data: jws,
delta: encoded_delta,
};
return recoverOperation;
};
|
devrajsinghrawat/sidetree.js
|
packages/did-method/src/DidMethod.ts
|
/*
* Copyright 2020 - Transmute Industries Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import {
Config,
ResponseModel,
ResponseStatus,
ProtocolVersionModel,
IBlockchain,
ICas,
} from '@sidetree/common';
import {
BatchScheduler,
DownloadManager,
Observer,
Resolver,
ServiceInfo,
VersionManager,
} from '@sidetree/core';
import {
MongoDbOperationStore,
MongoDbOperationQueue,
MongoDbTransactionStore,
MongoDbUnresolvableTransactionStore,
} from '@sidetree/db';
/**
* The core class that is instantiated when running a Sidetree node.
*/
export default class DidMethod {
static readonly cachedBlockchainTimeRefreshInSeconds = 60;
public transactionStore: MongoDbTransactionStore;
private unresolvableTransactionStore: MongoDbUnresolvableTransactionStore;
public operationStore: MongoDbOperationStore;
public versionManager: VersionManager;
public blockchain: IBlockchain;
private cas: ICas;
private downloadManager: DownloadManager;
private observer: Observer;
private batchScheduler: BatchScheduler;
private resolver: Resolver;
private serviceInfo: ServiceInfo;
public constructor(
config: Config,
protocolVersions: ProtocolVersionModel[],
blockchain: IBlockchain,
cas: ICas
) {
// Component dependency construction & injection.
this.versionManager = new VersionManager(config, protocolVersions); // `VersionManager` is first constructed component.
this.operationStore = new MongoDbOperationStore(
config.mongoDbConnectionString,
config.databaseName
);
this.blockchain = blockchain;
this.cas = cas;
this.downloadManager = new DownloadManager(
config.maxConcurrentDownloads,
this.cas
);
this.resolver = new Resolver(this.versionManager, this.operationStore);
this.batchScheduler = new BatchScheduler(
this.versionManager,
this.blockchain,
config.batchingIntervalInSeconds
);
this.transactionStore = new MongoDbTransactionStore(
config.mongoDbConnectionString,
config.databaseName
);
this.unresolvableTransactionStore = new MongoDbUnresolvableTransactionStore(
config.mongoDbConnectionString,
config.databaseName
);
this.observer = new Observer(
this.versionManager,
this.blockchain,
config.maxConcurrentDownloads,
this.operationStore,
this.transactionStore,
this.unresolvableTransactionStore,
config.observingIntervalInSeconds
);
this.serviceInfo = new ServiceInfo('core');
}
/**
* The initialization method that must be called before consumption of this core object.
* The method starts the Observer and Batch Writer.
*/
public async initialize(
startObserver = true,
startBatchWriter = true,
startPeriodicCachedBlockchainTimeRefresh = false
): Promise<void> {
await this.transactionStore.initialize();
await this.unresolvableTransactionStore.initialize();
await this.operationStore.initialize();
await this.blockchain.initialize();
await this.cas.initialize();
await this.versionManager.initialize(
this.blockchain,
this.cas,
this.downloadManager,
this.operationStore,
this.resolver,
this.transactionStore
); // `VersionManager` is last initialized component.
if (startObserver) {
await this.observer.startPeriodicProcessing();
}
if (startBatchWriter) {
this.batchScheduler.startPeriodicBatchWriting();
}
if (startPeriodicCachedBlockchainTimeRefresh) {
this.startPeriodicCachedBlockchainTimeRefresh();
}
this.downloadManager.start();
}
/**
* The function that starts periodically anchoring operation batches to blockchain.
*/
public startPeriodicCachedBlockchainTimeRefresh: VoidFunction = () => {
setInterval(
async () => this.blockchain.getLatestTime(),
DidMethod.cachedBlockchainTimeRefreshInSeconds * 1000
);
};
public async triggerBatchWriting(): Promise<void> {
await this.batchScheduler.writeOperationBatch();
}
public async triggerProcessTransactions(): Promise<void> {
// By passing true, we force the observer to wait for all transactions
// to be downloaded before returning. We need that for testing
await this.observer.refreshLastKnownTransaction();
await this.observer.processTransactions(true);
}
public async triggerBatchAndObserve(): Promise<void> {
await this.triggerBatchWriting();
await this.triggerProcessTransactions();
}
public async close(): Promise<void> {
const currentTime = this.blockchain.approximateTime;
const operationQueue = this.versionManager.getOperationQueue(
currentTime.time
);
if (operationQueue) {
await (operationQueue as MongoDbOperationQueue).close();
}
await this.transactionStore.close();
await this.unresolvableTransactionStore.close();
await this.operationStore.close();
await this.observer.stopPeriodicProcessing();
await this.cas.close();
this.downloadManager.stop();
this.batchScheduler.stopPeriodicBatchWriting();
}
/**
* Handles an operation request.
*/
public async handleOperationRequest(request: Buffer): Promise<ResponseModel> {
const currentTime = this.blockchain.approximateTime;
const requestHandler = this.versionManager.getRequestHandler(
currentTime.time
);
const response = requestHandler.handleOperationRequest(request);
return response;
}
/**
* Handles resolve operation.
* @param didOrDidDocument Can either be:
* 1. Fully qualified DID. e.g. 'did:sidetree:abc' or
* 2. An encoded DID Document prefixed by the DID method name. e.g. 'did:sidetree:<encoded-DID-Document>'.
*/
public async handleResolveRequest(
didOrDidDocument: string
): Promise<ResponseModel> {
const currentTime = this.blockchain.approximateTime;
const requestHandler = this.versionManager.getRequestHandler(
currentTime.time
);
const response = requestHandler.handleResolveRequest(didOrDidDocument);
return response;
}
/**
* Handles the get version request. It gets the versions from the dependent services
* as well.
*/
public async handleGetVersionRequest(): Promise<ResponseModel> {
const responses = [
this.serviceInfo.getServiceVersion(),
await this.blockchain.getServiceVersion(),
await this.cas.getServiceVersion(),
];
return {
status: ResponseStatus.Succeeded,
body: JSON.stringify(responses),
};
}
}
|
hungcat/boardgameLocal
|
src/common/models.ts
|
import * as getUUID from "uuid/v4";
export class ItemBase {
_id: string;
get itemType(): string {
return this.constructor.name;
}
offset: { top: number, left: number };
constructor() {
this._id = getUUID();
this.offset = { top: 0, left: 0 };
}
equals(item: ItemBase) {
return this._id === item._id;
}
}
const imgPrefix: string = 'assets/images/';
const imgExt: string = '.png';
export class Card extends ItemBase {
face: string;
back: string;
isFace: boolean;
constructor(args: any = {}) {
super();
this.face = args.face || 'noimage';
this.back = args.back || 'noimage';
this.isFace = !!args.isFace;
}
changeFace(isFace?: boolean) {
this.isFace = (isFace == null) ? !this.isFace : isFace;
}
getUpSide(forceSide?: boolean) {
return (forceSide == null ? this.isFace : forceSide)
? this.face
: this.back;
}
getImgPath(forceSide?: boolean) {
return imgPrefix + this.getUpSide(forceSide) + imgExt;
}
static readonly EMPTY = new Card({ face: 'empty', back: 'empty' });
};
export class Deck extends ItemBase {
name: string;
cards: Array<Card>;
constructor(args: any = {}) {
super();
this.name = args.name || "deck";
this.cards = args.cards || [];
}
setCards(cards: Array<Card>) {
if (cards) this.cards = cards;
}
getNthCardUpSidePath(pos: number = 0, forceSide?: boolean) {
let lastCard = this.cards[this.cards.length - 1 - pos];
return (lastCard || Card.EMPTY).getImgPath(forceSide);
}
addCard(card: Card, pos: string | number = 'top') {
if (!card) return;
if (pos === 'top') {
this.cards.push(card);
} else if (pos === 'bottom') {
this.cards.unshift(card);
} else if (isFinite(pos as number) && (0 <= pos || pos <= this.cards.length)) {
this.cards.splice(pos as number, 0, card);
} else {
this.cards.push(card);
}
}
insertCard(card: Card, pos: number) {
if (card) {
if (pos < 0 || this.cards.length < pos) pos = this.cards.length;
this.cards.splice(pos, 0, card);
}
}
popCard(target?: Card | number) {
if (target == null) {
return this.cards.pop();
}
if (target instanceof Card) {
target = this.findPos(target);
}
if (0 <= target && target < this.cards.length) {
this.cards.splice(target, 1);
} else {
return null;
}
}
findPos(card: Card) {
return this.cards.findIndex(c => card.equals(c));
}
}
export class Player extends ItemBase {
name: string;
hand: Deck;
constructor(args: any = {}) {
super();
this.name = args.name || 'Player0';
this.hand = new Deck({ name: this.name + 'の手札' });
}
}
|
hungcat/boardgameLocal
|
src/common/config.ts
|
const port: string = '3000';
export module ClientConfig {
export const wsHost: string = 'ws://localhost:' + port + '/ws';
};
export module ServerConfig {
export const serverPort: string = port;
export const isHTTPS: boolean = false;
export const httpsKey: string = '';
export const httpsCert: string = '';
};
|
hungcat/boardgameLocal
|
src/client/src/app/shared/dynamic-component.service.ts
|
<gh_stars>0
import {
Injectable,
ViewContainerRef,
ComponentFactoryResolver,
Component,
ComponentRef,
OnInit,
OnDestroy,
Output,
EventEmitter,
ElementRef,
} from '@angular/core';
declare var $: any;
@Component({})
export class DynamicComponentBase implements OnInit, OnDestroy {
@Output() oninit = new EventEmitter();
@Output() ondestroy = new EventEmitter();
doDestroy = new EventEmitter();
isDestroyable = false;
constructor(protected _el: ElementRef) {}
ngOnInit() {
this.oninit.emit(null);
}
ngOnDestroy() {
this.ondestroy.emit(null);
}
setOnInit(next: any) {
this.oninit.subscribe(next);
}
setOnDestroy(next: any) {
this.ondestroy.subscribe(next);
}
setDoDestroy(next: any) {
this.doDestroy.subscribe(next);
}
setCss(css: any) {
$(this.getDOM()).css(css);
}
getFullOffset() {
let $this = $(this.getDOM());
let offset = $this.offset();
offset.bottom = offset.top + $this.outerHeight(true);
offset.right = offset.left + $this.outerWidth(true);
return offset;
}
getDOM() { return this._el.nativeElement; }
}
@Injectable()
export class DynamicComponentService {
public components: Set<ComponentRef<Component>> = new Set();
constructor(private _cfr: ComponentFactoryResolver){}
public createComponent(domRef: ViewContainerRef, comp: any, callback = (comp: any, compRef: ComponentRef<any>) => {}) {
return this.createComponentG<typeof comp>(domRef, comp, callback);
}
public createComponentG<T extends DynamicComponentBase>(domRef: ViewContainerRef, comp: T, callback = (comp: T, compRef: ComponentRef<T>) => {}): T {
const factory = this._cfr.resolveComponentFactory(comp as any);
const compRef = domRef.createComponent(factory) as ComponentRef<T>;
const ins = compRef.instance;
if (ins) {
// set closing event
ins.setDoDestroy(() => {
this.components.delete(compRef);
compRef.destroy();
});
ins.isDestroyable = true;
}
callback(ins, compRef);
this.components.add(compRef);
compRef.changeDetectorRef.detectChanges();
return ins;
}
}
|
hungcat/boardgameLocal
|
src/server/shared/websocket-adapter.ts
|
import * as http from "http";
import * as WebSocket from "ws";
import * as getUUID from "uuid/v4";
import { WSApp } from './websocket-app'
function WrapWebSocketAdapter(apps: Array<WSApp>) {
return new WebSocketAdapter(apps).exportOnConnection();
}
interface WSAOptions {
checkBeforeBroadcast?: boolean;
brokenConnectionDetection?: WatchingOption;
}
interface WatchingOption {
enabled: true;
intervalSeconds?: number;
}
class WebSocketAdapter implements WSAOptions {
conns: Map<WebSocket, { isAlive: boolean }>;
apps: Array<WSApp>;
checkBeforeBroadcast: boolean;
brokenConnectionDetection: WatchingOption;
constructor(apps: Array<WSApp>, options: WSAOptions = {
checkBeforeBroadcast: true,
brokenConnectionDetection: {
enabled: true,
intervalSeconds: 10 * 60
}
}) {
this.conns = new Map();
this.apps = apps;
this.checkBeforeBroadcast = options.checkBeforeBroadcast;
this.brokenConnectionDetection = options.brokenConnectionDetection;
if (this.brokenConnectionDetection.enabled) {
this.startBrokenConnectionDetection();
}
}
exportOnConnection() { return this.onconnection.bind(this); }
onconnection(ws: WebSocket, req: http.IncomingMessage) {
this.conns.set(ws, { isAlive: true });
ws.on('pong', () => { this.conns.get(ws).isAlive = true; });
ws.on('message', (msg: string) => {
this.onmessage(ws, msg)
});
this.apps.forEach((app) => { app.onconnection(this, ws, req); });
}
onmessage(ws: WebSocket, msg: string) {
//console.log(msg);
const obj = JSON.parse(msg);
this.apps.forEach((app) => { app.onmessage(this, ws, obj.type, obj.data); });
this.checkConnections();
}
terminateConn(ws: WebSocket, e?: Error) {
this.conns.delete(ws);
this.apps.forEach((app) => { app.ondisconnection(this, ws, e); });
return ws.terminate();
}
send(ws: WebSocket, data: string, onerror?: (e: Error) => void) {
ws.send(data, (e: Error) => {
if (e) {
console.log('Failed to send.');
if (onerror) onerror(e);
//console.log(e);
this.terminateConn(ws, e);
}
});
}
broadcast(data: string, excludes: Array<WebSocket> = []) {
if (this.checkBeforeBroadcast) {
this.checkConnections();
}
this.conns.forEach((v: any, ws: WebSocket) => {
if (!excludes.includes(ws)) {
this.send(ws, data);
}
});
}
checkConnections() {
this.conns.forEach((v: any, ws: WebSocket) => {
if (ws.readyState !== WebSocket.OPEN) {
this.terminateConn(ws);
}
});
}
startBrokenConnectionDetection() {
const interval = setInterval(() => {
this.conns.forEach((v: any, ws: WebSocket) => {
if (v.isAlive === false) return this.terminateConn(ws);
v.isAlive = false;
ws.ping('', false, true);
});
}, this.brokenConnectionDetection.intervalSeconds);
}
}
export { WebSocketAdapter, WrapWebSocketAdapter }
|
hungcat/boardgameLocal
|
src/client/src/app/board/items/area-generator/area-generator.component.ts
|
import {
Component,
OnInit,
ViewContainerRef,
ElementRef,
} from '@angular/core';
import { AreaComponent } from "../area/area.component";
import { DynamicComponentBase, DynamicComponentService } from "../../../shared/dynamic-component.service";
@Component({
selector: 'app-area-generator',
templateUrl: './area-generator.component.html',
styleUrls: ['./area-generator.component.css'],
providers: [ DynamicComponentService ]
})
export class AreaGeneratorComponent extends DynamicComponentBase {
constructor(
_el: ElementRef,
private _vcr: ViewContainerRef,
private _dcs: DynamicComponentService
){ super(_el); }
createArea() {
this._dcs.createComponent(this._vcr, AreaComponent, (compRef) => {
let instance = compRef.instance;
instance.title = '消せる手札';
instance.setCss({'top': '20vw'});
instance.setOnDestroy(() => {
console.log('area has destroyed')
})
});
}
}
|
hungcat/boardgameLocal
|
src/common/utils.ts
|
const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
export function isUUID(id: string) {
return uuidPattern.test(id);
}
|
hungcat/boardgameLocal
|
src/client/src/config.ts
|
export { ClientConfig } from '../../common/config';
|
hungcat/boardgameLocal
|
src/client/src/app/board/items/card/card.component.ts
|
import { Component, Input, Output, EventEmitter, HostBinding, HostListener, ElementRef, ChangeDetectorRef } from '@angular/core';
import { DynamicComponentBase } from "../../../shared/dynamic-component.service";
import { makeDraggable, updateDraggableZIndex } from "../../../shared/utils";
import { Card } from "../../../shared/models";
declare var $: any;
@Component({
selector: 'app-card',
templateUrl: './card.component.html',
styleUrls: ['./card.component.css'],
})
export class CardComponent extends DynamicComponentBase {
@Input() card: Card = new Card();
@HostBinding('attr.data-item-type')
itemType: string = this.card.itemType;
@Output()
onleave = new EventEmitter();
constructor(
_el: ElementRef,
private _cdr: ChangeDetectorRef,
) { super(_el); }
ngOnInit() {
super.ngOnInit();
this.setDraggable();
$(this.getDOM())
.data('getCard', this.getCard.bind(this))
.data('removeCard', this.remove.bind(this));
}
setDraggable() {
let $this = $(this.getDOM());
let isInArea = $this.parent().hasClass('card-area');
makeDraggable($this, {
helper: isInArea ? 'clone' : 'original',
appendTo: isInArea ? document.body : 'parent',
start: function(e, ui) {
$(this).filter(
(i, v) => $(v).parent().hasClass('card-area')
).addClass('invisible placeholder');
let scrollAnimation = (e) => {
let hoveredArea = $.getTopElementManager()
.list
.map(obj => obj.element)
.filter(el => el.tagName == 'APP-AREA');
let $target = $(hoveredArea).first().find('.card-area');
if ($target.length == 0) return;
let relPos = e.pageX - $target.offset().left;
let pw = $target.width();
let fromCenter = relPos - pw / 2;
let doMove = Math.abs(fromCenter) > pw * 0.25;
if (doMove) {
$target.not(':animated').animate({
scrollLeft: $target.scrollLeft() + (fromCenter < 0 ? -500 : 500)
}, 'normal', 'linear', () => { scrollAnimation(e); });
} else {
$target.filter(':animated').stop();
}
}
$('html').on('mousemove', scrollAnimation);
},
stop: function(e, ui) {
$(this).filter(
(i, v) => $(v).parent().hasClass('card-area')
).removeClass('invisible placeholder');
$('html').off('mousemove');
},
});
}
@HostListener('dblclick')
toggleFace() {
this.card.changeFace();
this._cdr.detectChanges();
}
getCard() { return this.card; }
setCard(card: Card) {
if (card) {
this.card = card;
this._cdr.detectChanges();
}
}
remove() {
if (this.isDestroyable) {
this.doDestroy.emit(null);
} else {
this.onleave.emit(null);
}
}
}
|
hungcat/boardgameLocal
|
src/client/src/app/board/items/deck/deck.component.ts
|
import { Component, Input, ElementRef, HostBinding, HostListener, NgZone, ChangeDetectorRef } from '@angular/core';
import { DynamicComponentBase } from "../../../shared/dynamic-component.service";
import { makeDraggable, makeDroppable } from "../../../shared/utils";
import { Card, Deck } from "../../../shared/models";
declare var $: any;
@Component({
selector: 'app-deck',
templateUrl: './deck.component.html',
styleUrls: ['./deck.component.css'],
})
export class DeckComponent extends DynamicComponentBase {
deck: Deck = new Deck();
@HostBinding('attr.data-item-type')
itemType: string = this.deck.itemType;
@HostBinding('class.with-shadow')
get hasCard() { return this.deck.cards.length > 0; }
@HostBinding('class.fixed')
fixed: boolean = false;
pickingNum = 0;
constructor(
_el: ElementRef,
private _cdr: ChangeDetectorRef,
) { super(_el); }
ngOnInit() {
super.ngOnInit();
this.setDraggable();
this.setDroppable();
$(this.getDOM())
.data('popCard', this.popCard.bind(this));
}
setDraggable() {
makeDraggable(this._el, {
helper: (e, ui) => {
let $this = $(e.currentTarget);
if ($this.hasClass('fixed')) {
return $this
.clone()
.removeClass('.with-shadow');
} else {
return $this;
}
},
start: (e, ui) => {
this.pickingNum = this.fixed ? 1 : 0;
this._cdr.detectChanges();
},
stop: (e, ui) => {
this.pickingNum = 0;
this._cdr.detectChanges();
},
});
}
setDroppable() {
makeDroppable(this._el, {
drop: (e, ui) => {
console.log('dropped to deck');
switch (ui.draggable.attr('data-item-type')) {
case 'Card':
this.deck.addCard(ui.draggable.data('getCard')());
ui.draggable.data('removeCard')();
break;
}
},
});
}
@HostListener('dblclick')
toggleFixed() {
this.fixed = !this.fixed;
this._cdr.detectChanges();
}
setDeck(deck: Deck) {
if (deck) {
this.deck = deck;
this._cdr.detectChanges();
}
}
popCard() {
let card = this.deck.popCard();
this._cdr.detectChanges();
return card;
}
}
|
hungcat/boardgameLocal
|
src/server/routes/apis/index.ts
|
import { Router, Request, Response } from "express";
const router: Router = Router();
/* GET users listing. */
router.get('/', function(req: Request, res: Response, next) {
res.send('respond with a resource');
});
export = router;
|
hungcat/boardgameLocal
|
src/client/src/app/shared/models.ts
|
export * from '../../../../common/models'
|
hungcat/boardgameLocal
|
src/client/src/app/user-registration/user-registration.component.ts
|
<reponame>hungcat/boardgameLocal
import { Component, OnInit, Input } from '@angular/core';
import { Router } from '@angular/router';
import { WebSocketService } from "../shared/websocket.service";
@Component({
selector: 'user-registration',
templateUrl: './user-registration.component.html',
styleUrls: ['./user-registration.component.css'],
})
export class UserRegistrationComponent implements OnInit {
@Input() userName: string = '';
constructor(
private _router: Router,
private _ws: WebSocketService,
){}
ngOnInit() {
this._ws.on('messageParsed', this.messageHandler.bind(this))
this.userName = sessionStorage.getItem('userName');
}
messageHandler(type: string, data: any) {
switch(type) {
case 'registrationResponse':
if (data.isOK) {
sessionStorage.setItem('id', data.id);
sessionStorage.setItem('userName', data.userName);
this._router.navigate(['/board']);
}
break;
}
}
login() {
if (this.userName !== null){
this._ws.send({
type: 'registrationChallenge',
data: {
id: sessionStorage.getItem('id'),
userName: this.userName
}
});
}
}
keypressHandler(event) {
if (event.keyCode === 13){
this.login();
}
}
}
|
hungcat/boardgameLocal
|
src/server/shared/websocket-app.ts
|
<filename>src/server/shared/websocket-app.ts<gh_stars>0
import * as http from "http";
import * as WebSocket from "ws";
import { WebSocketAdapter } from "./websocket-adapter";
interface WSApp {
onconnection: (wsa: WebSocketAdapter, ws: WebSocket, req: http.IncomingMessage) => void;
onmessage: (wsa: WebSocketAdapter, ws: WebSocket, type: string, data: any) => void;
ondisconnection: (wsa: WebSocketAdapter, ws: WebSocket, e?: Error) => void;
}
export { WSApp };
|
hungcat/boardgameLocal
|
src/server/config.ts
|
export { ServerConfig } from '../common/config';
|
hungcat/boardgameLocal
|
src/client/src/app/board/items/player/player.component.ts
|
import { Component, OnInit, ElementRef, ViewContainerRef, HostBinding, NgZone} from '@angular/core';
import { DynamicComponentBase, DynamicComponentService } from "../../../shared/dynamic-component.service";
import { makeDraggable, makeDroppable } from "../../../shared/utils";
import { AreaComponent } from "../area/area.component";
import { Card, Player } from "../../../shared/models";
@Component({
selector: 'app-player',
templateUrl: './player.component.html',
styleUrls: ['./player.component.css'],
providers: [ DynamicComponentService ]
})
export class PlayerComponent extends DynamicComponentBase {
player: Player = new Player();
@HostBinding('attr.data-item-type')
itemType: string = this.player.itemType;
constructor(
_el: ElementRef,
private _vcr: ViewContainerRef,
private _dcs: DynamicComponentService,
private _zone: NgZone,
) { super(_el); }
ngOnInit() {
super.ngOnInit();
this.setDraggable();
this.setDroppable();
}
setDraggable() {
makeDraggable(this._el);
}
setDroppable() {
makeDroppable(this._el, {
drop: (e, ui) => {
console.log('dropped to ' + this.player.name);
//console.log('cards: ' + this.cards.length);
switch (ui.draggable.attr('data-item-type')) {
case 'Card':
this.addCardToHand(ui.draggable.data('getCard')());
ui.draggable.data('removeCard')();
break;
case 'Deck':
if (ui.draggable.hasClass('fixed')) {
this.addCardToHand(ui.draggable.data('popCard')());
}
break;
}
},
});
}
showHand() {
this._dcs.createComponent(this._vcr, AreaComponent, (comp) => {
comp.setDeck(this.player.hand);
comp.setCss({'top': '20vw'});
});
}
setPlayer(player: Player) {
if (player) {
this._zone.run(() => {
this.player = player;
});
}
}
addCardToHand(card: Card) {
if (card) {
this._zone.run(() => {
this.player.hand.addCard(card);
});
}
}
}
|
hungcat/boardgameLocal
|
src/server/app.ts
|
<filename>src/server/app.ts
import * as express from "express";
import * as path from "path";
import * as logger from "morgan";
import * as compression from "compression";
import * as cookieParser from "cookie-parser";
import { json, urlencoded } from "body-parser";
import * as expressWs from "express-ws";
import * as apis from "./routes/apis";
import * as ws from "./routes/ws";
const app: express.Application = express();
const baseHref: string = '/';
expressWs(app);
app.disable("x-powered-by");
app.use(logger('dev'));
app.use(json());
app.use(urlencoded({ extended: true }));
app.use(cookieParser());
app.use(compression());
app.use(baseHref, express.static(path.resolve(__dirname, '../client')));
app.use(baseHref + 'node_modules', express.static(path.resolve(__dirname, '../../src/client/node_modules/')));
app.use('/apis', apis);
app.use('/ws', ws);
app.get('*', function(req: express.Request, res: express.Response) {
res.sendFile(path.resolve(__dirname, '../client/index.html'));
});
/*
// catch 404 and forward to error handler
app.use(function(req, res, next) {
let err: any = new Error('Not Found');
err.status = 404;
next(err);
});
// error handler
app.use(function(err: any, req, res, next) {
// set locals, only providing error in development
res.locals.message = err.message;
res.locals.error = req.app.get('env') === 'development' ? err : {};
// render the error page
res.status(err.status || 500);
res.render('error');
});
*/
export { app };
|
hungcat/boardgameLocal
|
src/client/src/app/board/items/area/area.component.ts
|
<filename>src/client/src/app/board/items/area/area.component.ts
import { Component, OnInit, ElementRef, ViewChildren, QueryList, NgZone, HostBinding } from '@angular/core';
import { DynamicComponentBase } from "../../../shared/dynamic-component.service";
import { makeDraggable, makeDroppable } from "../../../shared/utils";
import { Card, Deck } from "../../../shared/models";
import { CardComponent } from "../card/card.component";
declare var $: any;
@Component({
selector: 'app-area',
templateUrl: './area.component.html',
styleUrls: ['./area.component.css']
})
export class AreaComponent extends DynamicComponentBase {
@HostBinding('attr.data-item-type')
itemType: string = 'area';
deck = new Deck({ name: '手札' });
get title() {
return this.deck.name;
};
@ViewChildren('cards')
cardsRef: QueryList<CardComponent>;
constructor(
_el: ElementRef,
private _zone: NgZone,
) { super(_el); }
ngOnInit() {
super.ngOnInit();
this.setDraggable();
this.setDroppable();
}
setDraggable() {
makeDraggable(this._el, { axis: 'y' });
}
setDroppable() {
makeDroppable(this._el, {
drop: (e, ui) => {
console.log('dropped to ' + this.title);
//console.log('cards: ' + this.cards.length);
//console.log(e);
let droppedPos = this.cardsRef
.toArray()
.map(cc => cc.getFullOffset())
.map(o => (o.left + o.right) / 2)
.findIndex(x => e.pageX < x);
//console.log(this.cardsRef.toArray())
//console.log(droppedPos)
switch (ui.draggable.attr('data-item-type')) {
case 'Card':
let card = ui.draggable.data('getCard')();
let idx = this.deck.findPos(card);
if (idx > -1 && idx < droppedPos) droppedPos -= 1;
ui.draggable.data('removeCard')();
this.insertCard(card, droppedPos);
break;
case 'Deck':
if (ui.draggable.hasClass('fixed')) {
let card = ui.draggable.data('popCard')();
this.insertCard(card, droppedPos);
}
break;
}
},
});
}
onExitClicked(e?: any) {
this.doDestroy.emit(null);
}
addCard(card: Card) {
if (card) {
this._zone.run(() => {
this.deck.addCard(card);
});
}
}
insertCard(card: Card, pos: number) {
if (card) {
this._zone.run(() => {
this.deck.insertCard(card, pos);
});
}
}
onCardDestroy(card: Card) {
if (card) {
let pos = this.deck.findPos(card);
if (pos >= 0) {
this._zone.run(() => {
this.deck.popCard(pos);
});
}
}
}
setDeck(deck: Deck) {
if (deck) {
this._zone.run(() => {
this.deck = deck;
});
}
}
setCards(cards: Array<Card>) {
if (cards) {
this._zone.run(() => {
this.deck.setCards(cards);
});
}
}
}
|
hungcat/boardgameLocal
|
src/client/src/app/shared/websocket.service.ts
|
import { Injectable, Inject, Optional } from '@angular/core';
export const WSHOST = 'wsHost';
const defaultURL = 'ws://localhost:3000/ws';
@Injectable()
export class WebSocketService {
private url: string;
private _ws: WebSocket;
private reconnectCount: number = 0;
private autoReconnect: boolean = true;
private messageQueue = [];
private listeners = {
'open': [],
'message': [],
'messageParsed': [],
'close': [],
'error': [],
};
constructor(@Inject(WSHOST) @Optional() url?: string) {
this.url = url || defaultURL;
this.reconnectCount = 0;
this.connect(true);
}
connect(force: boolean = false) {
if (!force && this._ws && this._ws.readyState !== WebSocketState.OPEN) {
return;
}
this._ws = new WebSocket(this.url);
this._ws.onopen = this.onOpen.bind(this);
this._ws.onclose = this.onClose.bind(this);
this._ws.onerror = this.onError.bind(this);
this._ws.onmessage = this.onMessage.bind(this);
}
reconnect() {
this.close();
setTimeout(() => {
console.log('Try to reconnect at ' + this.reconnectCount + 'th time.');
this.connect();
}, reconnectInterval(++this.reconnectCount));
}
close() {
if (this._ws) {
this._ws.close(1000);
this._ws = null;
}
}
/* inner listeners */
private onOpen(e: Event) {
//console.log(e);
this.reconnectCount = 0;
this.listeners.open.forEach(f => f(e));
this.fireMessageQueue();
}
private onClose(e: CloseEvent) {
//console.log(e);
this.listeners.close.forEach(f => f(e));
if (this.autoReconnect && e.code !== 1000) {
this.reconnect();
} else {
this.messageQueue = [];
}
}
private onError(e: ErrorEvent) {
console.log(e);
this.listeners.error.forEach(f => f(e));
}
private onMessage(e: MessageEvent) {
console.log(e);
this.listeners.message.forEach(f => f(e));
if (e) {
try {
const o = JSON.parse(e.data);
this.listeners.messageParsed.forEach(f => f(o.type, o.data));
} catch (ex) {
console.log(ex);
}
}
}
/* sender */
send(data: string | any) {
if (typeof data !== 'string') {
data = JSON.stringify(data);
}
this.messageQueue.unshift(data);
this.fireMessageQueue();
}
fireMessageQueue() {
while (this.messageQueue.length && this.isOpened()) {
this._ws.send(this.messageQueue.pop());
}
}
// ?
isState(state: string) {
return this._ws && this._ws.readyState === WebSocketState[state];
}
isOpened() {
return this._ws && this._ws.readyState === WebSocketState.OPEN;
}
/* addEventListener */
on(eName: string, listener: Function) {
let listeners = this.listeners[eName];
if (listeners) listeners.push(listener);
}
}
function reconnectInterval(k: number) {
return Math.min(30, (Math.pow(2, k) - 1)) * 1000 * Math.random();
}
export enum WebSocketState {
CONNECTING, OPEN, CLOSING, CLOSE
}
|
hungcat/boardgameLocal
|
src/server/shared/board.ts
|
import * as http from "http";
import * as WebSocket from "ws";
import * as getUUID from "uuid/v4";
import { WSApp } from "./websocket-app";
import { WebSocketAdapter } from "./websocket-adapter";
import { Player } from "../../common/models";
import { isUUID } from "../../common/utils";
class UserInfo {
private _id: string;
private _name: string;
private _isUser: boolean;
constructor(args: any = {}) {
this._id = getUUID();
this._name = args.name;
this._isUser = false;
}
get id() { return this._id; }
set id(id: string) {
if (isUUID(id)) this._id = id;
}
get name() { return this._name || ('[id:' + this._id + ']'); }
set name(name: string) {
this._isUser = true;
this._name = name;
}
get isUser() { return this._isUser; }
}
class ConnInfo {
ip: string;
agent: string;
constructor(args: any = {}) {
let req = args.req;
if (req) {
this.ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
this.agent = req.headers['user-agent'];
}
}
}
class WebSocketUser {
user: UserInfo;
conn: ConnInfo;
constructor(args: any = {}) {
this.user = new UserInfo(args);
this.conn = new ConnInfo(args);
}
}
class BoardApp implements WSApp {
users: Map<WebSocket, WebSocketUser>;
usersDB: Map<string, UserInfo>;
constructor() {
this.users = new Map();
this.usersDB = new Map();
}
onconnection(wsa: WebSocketAdapter, ws: WebSocket, req: http.IncomingMessage) {
let wsuser = new WebSocketUser({ req: req });
this.users.set(ws, wsuser);
console.log('New one arrived!');
console.log('ip: ' + wsuser.conn.ip);
console.log('agent: ' + wsuser.conn.agent);
ws.send(JSON.stringify({
type: 'handshake',
data: { id: wsuser.user.id }
}));
}
onmessage(wsa: WebSocketAdapter, ws: WebSocket, type: string, data: any) {
console.log(type, data);
console.log('There are ' + this.users.size + ' users');
switch (type) {
case 'registrationChallenge':
let ok = true;
// check dup
//if (!this.usersDB.has(data.id)) {
// let dup = Array.prototype.some.call(this.users, (user: WebSocketUser) => {
// return user.name === data.userName;
// });
//}
ws.send(JSON.stringify({
type: 'registrationResponse',
data: {
isOK: ok,
id: data.id,
userName: data.userName
}
}));
break;
case 'handshake':
let wsuser = this.users.get(ws);
if (wsuser && data.userName) {
const exists = this.isExistsID(data.id);
if (this.usersDB.has(data.id)) {
wsuser.user = this.usersDB.get(data.id);
}
let user = wsuser.user;
user.id = data.id;
user.name = data.userName;
this.usersDB.set(user.id, user);
ws.send(JSON.stringify({
type: 'acceptHandshake',
data: { id: wsuser.user.id }
}));
console.log(user);
if (!exists) {
this.broadcast(wsa, JSON.stringify({
type: 'logMessage',
data: {
userName: '#system',
text: user.name + ' has entered the room'
}
}));
}
}
break;
default:
break;
}
}
ondisconnection(wsa: WebSocketAdapter, ws: WebSocket, e?: Error) {
console.log('disconnection')
let user = this.users.get(ws).user;
this.users.delete(ws);
if (!this.isExistsID(user.id) && user.isUser) {
this.broadcast(wsa, JSON.stringify({
type: 'logMessage',
data: {
userName: '#system',
text: user.name + ' has left the room'
}
}));
}
console.log('There are ' + this.users.size + ' users');
}
broadcast(wsa: WebSocketAdapter, data: string) {
console.log('broadcast: ', data);
this.users.forEach((wsuser: WebSocketUser, ws: WebSocket) => {
if (wsuser.user.isUser) {
wsa.send(ws, data);
}
});
}
isExistsID(id: string) {
return Array
.from(this.users.values())
.some((wsuser: WebSocketUser) => {
return wsuser.user.id === id && wsuser.user.isUser;
});
}
}
export { BoardApp }
|
hungcat/boardgameLocal
|
src/client/src/app/shared/utils.ts
|
export * from '../../../../common/utils'
import { ElementRef } from '@angular/core';
import { Card } from './models';
declare var $: any;
declare type jQueryObj = any;
let draggableOptionsBase = {
containment:'#baseBoard',
scroll: false,
};
export function makeDraggable($target: ElementRef | jQueryObj, option: any = {}) {
if ($target instanceof ElementRef) {
$target = $($target.nativeElement);
}
$target.draggable(Object.assign({}, draggableOptionsBase, option));
$target.mousedown(updateDraggableZIndex);
updateDraggableZIndex.call($target.get(0));
return $target;
}
let droppableOptionsBase = {
drop: (e, ui) => {},
tolerance: 'pointer',
};
export function makeDroppable($target: ElementRef | jQueryObj, option: any = {}) {
if ($target instanceof ElementRef) {
$target = $($target.nativeElement);
}
let op = Object.assign(
{},
droppableOptionsBase,
option
);
let dropOption = op.drop;
delete op.drop;
$target.topDroppable({ drop: dropOption }).droppable(op);
return $target;
}
export function updateDraggableZIndex() {
let boxes = [],
self = this,
minZIndex = 2, // 1はboard
isFront = false;
$('.ui-draggable').each(function (i) {
if (this !== self) {
boxes.push({
box: this,
zIndex: Number($(this).css('z-index'))
});
} else {
isFront = true;
}
});
boxes.sort((a, b) => a.zIndex - b.zIndex);
if (isFront) boxes.push({ box: this });
boxes.forEach(function (item, i) {
$(item.box).css('z-index', i + minZIndex);
});
}
export function createTrumpCards(suits: Array<string> = [], option = {}) {
return ['c', 'd', 'h', 's']
.filter(function(n) {
return suits.indexOf(n) !== -1;
}).reduce((result, suit) => {
Array.prototype.push.apply(result,
Array
.from({ length: 13 }, (v, i) => i + 1)
.map((i) => {
return new Card(Object.assign({
face: 'trump/' + suit + ('00' + i).slice(-2),
back: 'trump/z01',
isFace: false,
}, option))
})
);
return result;
}, []);
}
|
hungcat/boardgameLocal
|
src/client/src/app/board/board.component.ts
|
import {
Component,
OnInit,
ComponentFactoryResolver,
ViewChild,
ViewContainerRef,
} from '@angular/core';
import { Router } from '@angular/router';
import { DynamicComponentService } from "../shared/dynamic-component.service";
import { WebSocketService } from "../shared/websocket.service";
import { makeDroppable, createTrumpCards, isUUID } from "../shared/utils";
import { ItemBase, Deck, Player } from "../shared/models";
import { AreaComponent } from "./items/area/area.component";
import { CardComponent } from "./items/card/card.component";
import { DeckComponent } from "./items/deck/deck.component";
import { PlayerComponent } from "./items/player/player.component";
import { AreaGeneratorComponent } from "./items/area-generator/area-generator.component";
/**
* 赤ずきん
*
* おやすみカードトラップカード
* 赤ずきんカードオオカミカード母豚カード子豚カード
* スコアリング
*/
declare var $: any;
let storage = sessionStorage;
interface Message {
userName: string;
text: string;
};
@Component({
selector: 'app-board',
templateUrl: './board.component.html',
styleUrls: ['./board.component.css'],
providers: [
DynamicComponentService,
]
})
export class BoardComponent implements OnInit {
log: Array<Message> = [];
@ViewChild('container', { read: ViewContainerRef }) _vcr;
constructor(
private _router: Router,
private _dcs: DynamicComponentService,
private _ws: WebSocketService,
){}
ngOnInit() {
if (storage.getItem("userName") === null){
this._router.navigate(['/login']);
} else {
this._ws.on('messageParsed', this.messageHandler.bind(this));
this.makeBoardDroppable();
let plComp = this.createComponent(PlayerComponent);
this.createComponent(DeckComponent, (compRef) => {
let ins = compRef.instance;
ins.setDeck(new Deck({ cards: createTrumpCards(['d', 'h', 's']) }));
ins.setCss({ top: plComp.getFullOffset().bottom });
});
this.createComponent(AreaComponent, (compRef) => {
let ins = compRef.instance;
ins.setCards(createTrumpCards(['c'], { isFace: true }));
});
}
}
messageHandler(type: string, data: any) {
switch (type) {
case 'logMessage':
this.log.push(data);
break;
case 'handshake':
let id = storage.getItem('id');
if (!isUUID(id)) id = null;
this._ws.send({
type: 'handshake',
data: {
'id': id,
'userName': storage.getItem("userName")
}
});
if (!id) storage.setItem('id', data.id);
break;
}
}
makeBoardDroppable() {
makeDroppable($('#baseBoard'), {
drop: (e, ui) => {
console.log('dropped to board');
let isSameArea = ui.draggable.parent().get(0) === $('#baseBoard').get(0);
switch (ui.draggable.attr('data-item-type')) {
case 'Card':
if (!isSameArea) {
this.createComponent(CardComponent, (compRef) => {
let newCard = compRef.instance;
newCard.setCard(ui.draggable.data('getCard')());
newCard.setCss(ui.offset);
});
ui.draggable.data('removeCard')();
}
break;
case 'Deck':
if (ui.draggable.hasClass('fixed')) {
this.createComponent(CardComponent, (compRef) => {
let newCard = compRef.instance;
newCard.setCard(ui.draggable.data('popCard')());
newCard.setCss(ui.offset);
});
}
break;
}
},
});
}
createComponent(comp: any, callback?: (compRef: any) => void) {
return this._dcs.createComponent(this._vcr, comp, callback);
}
loadComponents(items: Array<ItemBase>) {
items.forEach(item => {
switch (item.itemType) {
case 'Card':
this.createComponent(CardComponent, (comp) => {
comp.setCard(item);
comp.setCss(item.offset);
});
break;
case 'Deck':
this.createComponent(DeckComponent, (comp) => {
comp.setDeck(item);
comp.setCss(item.offset);
});
break;
case 'Player':
this.createComponent(PlayerComponent, (comp) => {
comp.setPlayer(item);
comp.setCss(item.offset);
});
if (item._id === storage.getItem('playerID')) {
}
break;
}
});
}
}
|
hungcat/boardgameLocal
|
src/common/config.tmp.ts
|
<gh_stars>0
// put here as config.ts
export module ClientConfig {
export const wsDestination: string = '';
};
export module ServerConfig {
export const serverPort: string = '';
export const isHTTPS: boolean = false;
export const httpsKey: string = '';
export const httpsCert: string = '';
};
|
hungcat/boardgameLocal
|
src/server/routes/ws.ts
|
import { Router } from "express";
import * as expressWs from "express-ws";
import { WrapWebSocketAdapter } from "../shared/websocket-adapter";
import { BoardApp } from "../shared/board";
let router: any = Router();
expressWs(router);
/* GET users listing. */
router.ws('/', WrapWebSocketAdapter([new BoardApp()]));
export = router;
|
hungcat/boardgameLocal
|
src/client/src/app/app.module.ts
|
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { APP_BASE_HREF } from "@angular/common";
import { AppComponent } from './app.component';
import { AppRoutingModule } from './app.routing';
import { UserRegistrationComponent } from './user-registration/user-registration.component';
import { BoardComponent } from './board/board.component';
import { CardComponent } from './board/items/card/card.component';
import { DeckComponent } from './board/items/deck/deck.component';
import { PlayerComponent } from './board/items/player/player.component';
import { AreaComponent } from './board/items/area/area.component';
import { AreaGeneratorComponent } from './board/items/area-generator/area-generator.component';
import { WebSocketService, WSHOST } from './shared/websocket.service';
import { ClientConfig } from "../config";
@NgModule({
declarations: [
AppComponent,
UserRegistrationComponent,
BoardComponent,
CardComponent,
DeckComponent,
PlayerComponent,
AreaComponent,
AreaGeneratorComponent
],
imports: [
AppRoutingModule,
BrowserModule,
FormsModule
],
providers: [
WebSocketService,
{ provide: WSHOST, useValue: ClientConfig.wsHost },
],
bootstrap: [AppComponent],
entryComponents: [
CardComponent,
DeckComponent,
PlayerComponent,
AreaComponent,
AreaGeneratorComponent
]
})
export class AppModule { }
|
laojun/website
|
src/config/erda.ts
|
<reponame>laojun/website
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import i18n from '~/i18n';
export const terminusDomain = 'https://terminus.io';
export const docDomain = 'https://docs.erda.cloud';
export const docVersion = 'latest';
export const docUrl = `${docDomain}/${docVersion}/manual`;
export const temrUrl = `${docDomain}/${docVersion}/manual`;
export const cliUrl = `${docDomain}/${docVersion}/manual/cli/explain-args.html`;
export const extendUrl = `${docDomain}/${docVersion}/manual/addons/out-of-the-box.html`;
export const securifyUrl = `${docDomain}/${docVersion}/manual/safe/identity-management.html`;
export const changeLogUrl = `${docDomain}/changeLog.html`;
export interface IHeaderItem {
name: string;
url?: string;
jumpOut?: boolean;
status?: string;
subList?: any[];
}
export const headerMenus: IHeaderItem[] = [
// { name: 'Why Erda Cloud？', url: '/why-erda' },
{
name: i18n.t('product'),
subList: [
{ name: i18n.t('DevOps Platform'), img: 'dev', description: i18n.t('header devOps desc') },
{ name: i18n.t('Microservice Platform'), img: 'microservice', description: i18n.t('header ms desc') },
{ name: i18n.t('Cloud Management Platform'), img: 'duoyun', description: i18n.t('header multi-cloud desc') },
{ name: i18n.t('FastData Platform'), img: 'fdp', description: i18n.t('header fdp desc') },
],
},
{ name: i18n.t('pricing'), url: '/price' },
{ name: i18n.t('Documentation'), url: docUrl, jumpOut: true },
{ name: i18n.t('Marketplace'), url: '/market/addon' },
{ name: i18n.t('Success Story'), url: '/customer-case' },
{ name: 'GitHub', url: 'https://github.com/erda-project/erda', jumpOut: true },
];
export interface ISubItem {
name: string;
value?: string;
img?: string;
width?: number;
height?: number;
url?: string;
className?: string;
jumpOut?: boolean;
props?: object;
}
export interface IFooterItem {
name: string;
icon?: string;
subList: ISubItem[];
}
export interface Ifooter {
left: {
[k: string]: IFooterItem;
};
right: {
mainLink: Array<{
name: string;
img: {
src: string;
className?: string;
width?: number;
height?: number;
};
description: string;
}>;
subLink: Array<{ name: string; url: string; jumpOut: true; icon: string }>;
};
}
export const footerMenus: Ifooter = {
left: {
about: {
name: i18n.t('about us'),
// icon: 'gy',
subList: [
{ name: i18n.t('join us'), url: '/join' },
],
},
resource: {
name: i18n.t('resource'),
// icon: 'zy',
subList: [
{
name: i18n.t('training and support'),
url: docUrl,
jumpOut: true,
},
],
},
contactUs: {
name: i18n.t('contact us'),
subList: [{
name: i18n.t('telephone'),
value: '',
}, {
name: i18n.t('email'),
value: '',
}, {
name: i18n.t('address'),
value: i18n.t('company address'),
}],
},
},
right: {
mainLink: [
{
name: 'wechat',
img: {
src: '/images/common/wechat.jpg',
className: 'mb8',
width: 110,
height: 110,
},
description: i18n.t('scan and follow WeChat Official Account'),
},
],
subLink: [],
},
};
|
laojun/website
|
src/pages/join/config.tsx
|
<gh_stars>0
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import React from 'react';
import delivery from '~/images/join/delivery.png';
import filter from '~/images/join/filter.png';
import interview from '~/images/join/interview.png';
import hire from '~/images/join/hire.png';
export type IJobCategory = 'productExpert' | 'operationsExpert' | 'design' | 'developer' | 'testDeveloper';
export interface IJob {
name: string;
code: string;
teamDesc?: string;
responsibilities: React.ReactNode[];
requirements: string[];
prioritize?: string[];
}
export type IJobs = {
[jobCategory in IJobCategory]: {
name: string;
logo: string;
description: string;
list: IJob[];
}
};
export const jobs: IJobs = {
productExpert: {
name: '产品',
logo: 'chanpinzhuanjia',
description: '',
list: [
{
name: 'PaaS 平台产品',
code: 'P1',
responsibilities: [
'通过市场调研、用户分析、竞品试用以及与一线同事交流进行产品需求调研与分析',
'结合用户需求和产品技术架构，完成产品的需求文档和原型设计',
'跟踪产品的上线效果、用户反馈，主动挖掘需求，根据业务需要持续改进产品，提升用户体验',
],
requirements: [
'3年以上 PaaS 平台产品经理工作经验',
'具备产品创新意识，学习能力强，有强责任心，愿意接受挑战',
'具备良好的沟通协调能力，有很强的竞品分析、客户需求调研、逻辑分析场景分析、产品策划运营的能力',
'具备良好的项目管理能力，能够制定、协调合理的产品开发计划，推动产品持续迭代',
'了解云计算领域。对容器、运维监控、微服务治理技术有一定基础知识',
],
},
],
},
design: {
name: '设计',
logo: 'sheji',
description: '',
list: [],
},
developer: {
name: '开发',
logo: 'kaifagongchengshi',
description: '',
list: [
{
name: '前端开发专家',
code: 'D1',
teamDesc: 'Erda 前端团队专注于打造国内专业可靠的 PaaS 平台，支持平台功能开发，负责对接多个后端团队的功能，同时开发维护相关的前端技术工具和产品。加入我们，你将能够了解并塑造 PaaS 平台前端的技术架构，建设丰富平台的前端体系，掌握专业的敏捷研发流程，探索 UI 自动化测试、前端微服务等有难度的领域，借助 Erda 开源项目建立个人品牌',
responsibilities: [
'负责讨论设计、开发包括 DevOps 平台、微服务平台、快数据平台以及云管平台等多个平台的前端架构和产品实现',
'负责推动团队的技术栈优化，周边工具生态的建设',
'带领部分团队人员挑战并解决有难度的问题，优化团队内的知识沉淀分享机制',
'探索调研业界优秀的竞品，学习并探索我们实现业界领先的路径',
],
requirements: [
'基础扎实，具备良好的工作及编码习惯，有丰富的前端页面开发经验，熟悉业界的技术发展方向',
'熟悉 Webpack 打包构建原理，能够进行深度性能分析优化，有大型项目架构经验',
'熟练掌握 React、Typescript、Node、移动端等主流技术栈，对业界流行技术栈都有比较详细的认识，对后端、容器技术有一定了解',
'能够深刻理解产品背后的业务逻辑，对产品发展方向有建设性意见',
'积极乐观，责任心强，工作认真细致，具备良好的服务意识，具有带团队经验',
'有优秀开源作品或积极参与维护大型开源项目经验者优先',
'有丰富的前端性能优化、安全管控或 UI 自动化测试经验者优先',
],
},
{
name: 'PaaS 平台研发工程师/专家',
code: 'D2',
responsibilities: [
<>从事开源相关工作，参与开源云原生 PaaS 平台 <a href="https://github.com/erda-project/erda" target="_blank" rel="noopener noreferrer">Erda Project</a> 的架构设计、核心代码和框架的开发，打造稳定、高效的平台服务</>,
'参与基于开源 PaaS 的 Erda Cloud 开发者平台的核心功能开发',
'负责 Erda DevOps 平台的研发，提供 DevOps 落地方案 (可选)',
'负责 Erda 微服务治理平台的研发，提供高可用的微服务引擎托管方案 (可选)',
'负责 Erda 多云管理平台的研发，改进和完善混合云管平台的架构和工具链 (可选)',
],
requirements: [
'操作系统/数据库/网络基础知识扎实',
'熟练掌握 Go、Java、C、C++ 其中任一语言，熟悉常见数据结构和算法',
'有良好的编程习惯，对代码质量和性能有一定的自我要求',
'熟悉云原生 DevOps、可观测性、容器服务、Service Mesh 等任一方向的开源项目',
],
prioritize: [
'熟悉容器技术，如 Docker、Kubernetes、Mesos 等，深入源码者优先',
'有基于 Istio 做微服务治理的项目经验 （微服务架构方向）',
'熟悉 Prometheus、InfluxData、SkyWalking 等开源监控系统（监控方向）',
'熟悉 Linux 内核、网络、分布式存储、中间件（其中一项）',
'在开源社群活跃并有积极贡献者优先',
],
},
{
name: '监控平台开发专家',
code: 'D3',
teamDesc: 'Erda 监控团队专注建设稳定的监控和日志基础设施，为 SaaS 化可观测性 APM，日志服务，服务治理，数据治理和 IT 运维等领域提供智能化驱动和管理加入该团队，你将参与大规模数据挑战下的云原生监控和日志系统的落地实践，从 0-1 构建企业级场景下的智能运维和大规模弹性 PaaS 平台',
responsibilities: [
'负责 SaaS 化监控和日志平台的基础设施设计和核心代码实现',
'负责时序存储的核心代码实现 (可选)',
'负责流分析平台的核心代码实现 (可选)',
'负责 MPP 查询引擎的核心代码实现 (可选)',
],
requirements: [
'熟练掌握 Go、Java、C、C++ 其中任一语言，熟悉常见数据结构和算法',
'熟悉操作系统、网络、存储和分布式系统的基础理论',
'了解 Prometheus、InfluxData 等开源监控系统，并了解其 TSDB 的实现',
'了解 ElasticSearch、Cassandra、Clickhouse、Presto 等数据中间件的使用、架构实现和调优',
],
prioritize: [
'负责过具有一定规模的存储、查询引擎实现',
'熟悉开源，为任一开源时序数据库、查询引擎项目贡献过代码',
],
},
{
name: '流式计算开发工程师/专家',
code: 'D4',
responsibilities: [
'负责数据基础设施的搭建，为快数据平台、监控和日志平台提供计算能力支撑',
'负责搭建流数据计算平台，设计并开发监控和日志类数据的实时聚合引擎',
'负责设计 Flink、Sprak 等数据框架在 Kubernetes 环境的自动化部署和运维工具',
],
requirements: [
'熟练掌握 Java 或 Golang 开发语言，熟悉数据结构和算法',
'熟练掌握 Spark/Flink 等主流的流式处理引擎的工作原理并有实际使用经验',
'了解 Kafka、ElasticSearch、Cassandra、Presto 等数据中间件的使用和架构实现',
],
prioritize: [
'有流处理计算引擎实现的经历',
'熟悉开源，为开源流处理项目贡献过代码',
'熟悉或了解 AIOps 平台的架构设计和落地实现(日志聚类、根因分析等)',
],
},
{
name: '云原生中间件平台工程师/专家',
code: 'D5',
responsibilities: [
'开发基于 Kubernetes 的中间件自动化部署和运维平台',
'负责中间件（包括但不限于 Redis、ElasticSearch、Cassandra、Kafka）的日常运维、故障分析和稳定性优化',
],
requirements: [
'熟练掌握 Java 或 Golang 开发语言，熟悉数据结构和算法',
'熟悉 Docker、Kubernetes 相关的技术，有相关的使用、运维经验',
'熟悉分布式系统的设计和建设，熟悉分布式缓存（Memcached，Redis 等）、存储（Minio、Glusterfs、Cassandra、ElasticSearch 等）、消息（RocketMQ、Kafka 等）等主流中间件其中至少 2 个',
],
prioritize: [
'熟悉容器技术，如 Docker、Kubernetes、Mesos 等，深入了解源码',
'熟悉 Linux 内核、网络、分布式存储、中间件（其中一项），做过相关开发',
'了解任一主流中间件背后的原理，能对分布式常用技术进行合理应用，解决线上问题，提升服务平台稳定性，有源码 Debug 能力',
'有自动化运维平台开发经验',
],
},
{
name: 'SRE 工程师/专家',
code: 'D6',
responsibilities: [
'负责容器云/大数据平台基础设施的稳定性，可靠性',
'负责优化运维体系，提升团队的自动化运维水平和问题处理效率',
'负责优化平台技术架构，从运维角度改进架构体系，提高平台稳定性',
'负责相关中间件疑难问题排查，深入源代码、操作系统及硬件特性，对问题根因进行定位分析',
'提供相关产品的最佳实践，帮助企业客户提高业务架构的高效与稳定性',
],
requirements: [
'本科以上学历，计算机相关专业，有 3 年及以上工作经验',
'熟悉 C/C++/Go/Java/Python 一种或者多种语言，熟悉常见数据结构和算法',
'丰富的 Linux 系统运维、优化经验，对常见问题故障有处理经验，并能系统性总结',
'熟悉 Docker、Kubernetes 相关的技术，有相关的使用、运维经验',
'熟悉分布式系统的设计和建设，熟悉分布式缓存（Memcached，Redis 等）、存储（Minio、Glusterfs、Cassandra、ElasticSearch 等）、消息（RocketMQ、Kafka 等）等主流中间件其中至少 2 个',
'有 Owner 意识，具备较强的逻辑思考、学习能力，有强烈的责任心，抗压能力强',
],
prioritize: [
'熟悉容器技术，如 Docker、Kubernetes、Mesos 等，深入了解源码',
'熟悉 Linux 内核、网络、分布式存储、中间件（其中一项），做过相关开发',
'了解任一主流中间件背后的原理，能对分布式常用技术进行合理应用，解决线上问题，提升服务平台稳定性，有源码 Debug 能力',
'有自动化运维平台开发经验',
],
},
{
name: 'Java 开发工程师（SaaS 方向）',
code: 'D7',
responsibilities: [
'负责 Cloud 平台运营功能的设计与开发实现',
'负责进行相关产品需求分析、详细设计以及开发实现',
'负责相关产品的服务接口开发和维护',
],
requirements: [
'本科及以上学历，2年及以上 Java 相关技术背景',
'熟练进行 Java 的代码编写，良好的代码编写素养，良好的数据结构算法技能',
'熟悉 SpringBoot、Mybatis、Dubbo、MQ、Redis 等，熟悉前后端分离开发流程',
'有相关平台开发经验优先，包括但不限于计费系统、审计系统、用户组织管理、运营后台等',
],
},
],
},
testDeveloper: {
name: '测试',
logo: 'ceshikaifagongchengshi',
description: '',
list: [
{
name: '测试开发工程师',
code: 'T1',
responsibilities: [
'参与 PaaS 平台的需求分析，制定测试计划和测试方案',
'独立设计和执行设计用例，进行缺陷跟踪，根据测试结果完成测试报告',
'对测试过程中发现的软件质量问题进行分析和定位、与开发人员、需求人员积极有效沟通，推动问题解决',
'参与平台相关自动化测试、性能、稳定性测试',
'把控测试进度、识别并预防测试风险、建立并优化测试过程,提升测试效率和产品质量',
],
requirements: [
'本科或以上学历，计算机相关专业优先，两年以上软件开发或测试相关工作经验',
'熟悉软件测试方法和流程，能独立编写测试方案、测试计划、测试用例，能迅速定位 bug，缺陷跟踪并编写测试报告',
'熟悉 Java/Python/Go 其中至少一种语言，熟悉 MySQL，SQL Server，Oracle 其中至少一种数据库，能够熟练编写 SQL',
],
},
],
},
operationsExpert: {
name: '运营',
logo: 'yunyingzhuanjia',
description: '',
list: [],
},
};
export const applicationProcess = [
{
key: 'delivery',
img: delivery,
name: '简历投递',
},
{
key: 'filter',
img: filter,
name: '简历筛选',
},
{
key: 'interview',
img: interview,
name: '面试(含笔试)',
},
{
key: 'hire',
img: hire,
name: '录用',
},
];
export const vitaeEmail = '<EMAIL>';
|
laojun/website
|
src/pages/join/detail.tsx
|
<gh_stars>0
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import React, { useRef } from 'react';
import { withRouter } from 'react-router-dom';
import PageContent from 'layout/common/page-content';
import { RouteComponentProps } from 'react-router';
import envStore from '~/models/env';
import { jobs, vitaeEmail, IJobCategory } from 'pages/join/config';
import { IF } from 'common';
import { Button, Popover } from 'antd';
import addEventListener, { IReturn } from 'rc-util/lib/Dom/addEventListener';
import { getScrollTop, useMobile } from 'common/utils';
import { useUpdate } from 'common/utils/hooks';
import classNames from 'classnames';
const Item = ({ title, list }: {title: string; list: React.ReactNode[]}) => {
if (!list.length) {
return null;
}
return (
<>
<p className="text-0D0C22 text-20-28 my-2 font-semibold md:text-16-28">{title}</p>
<ul>
{
list.map((item, index) => {
return <li key={index} className="text-2F3C5F text-16-28 md:text-14-28">{index + 1}、{item}</li>;
})
}
</ul>
</>
);
};
const JobDetail = (props: RouteComponentProps<{categoryId: IJobCategory}>) => {
const { categoryId } = props.match.params;
const currentCategory = jobs[categoryId];
const [{ jobIndex, isFixed, showMore, showMoreBtn }, updater, update] = useUpdate({
jobIndex: currentCategory.list[0]?.code,
isFixed: false,
showMore: false,
showMoreBtn: true,
});
const eventRef = useRef<IReturn>();
const isMobile = useMobile();
const wrapRef = useRef<HTMLDivElement>();
React.useEffect(() => {
eventRef.current = addEventListener(window, 'scroll', () => {
updater.isFixed(getScrollTop() > 20);
});
envStore.reducers.setHeaderInfo({
whiteHeader: true,
});
return () => {
eventRef.current?.remove();
envStore.reducers.resetHeaderInfo();
};
}, []);
React.useLayoutEffect(() => {
// 移动端职位描述卡片高度大于580时，显示"显示更多"按钮
const isOverHeight = (wrapRef.current?.offsetHeight || 0) > 580;
updater.showMore(isOverHeight && showMoreBtn);
}, [jobIndex, showMoreBtn]);
const [currentJob, otherPositionList] = React.useMemo(() => {
const current = currentCategory.list.find((item) => item.code === jobIndex);
const otherPositions = currentCategory.list;
return [current, otherPositions];
}, [jobIndex]);
const jobListCls = React.useMemo(() => {
const fixed = isFixed && !isMobile;
return classNames('bg-white shadow-card08 px-5 py-4 -mt-18 w-p260 md:w-full', {
fixed,
'top-18': fixed,
});
}, [isFixed, isMobile]);
if (!currentJob) {
return <div className="gray-bg"><div className="no-banner-body" /></div>;
}
const handleShowMore = () => {
updater.showMoreBtn(false);
};
const handleChangeJob = (code: string) => {
if (code === jobIndex) {
return;
}
update({
jobIndex: code,
showMoreBtn: true,
});
};
const handleApplyPosition = () => {
location.href = `mailto:${vitaeEmail}?subject=应聘${currentJob.name}&body=你好，我从贵公司官网看到此招聘职位。附上我的简历，请查收。`;
};
const applyPositionBtn = (
<Popover content={`发送简历到：${vitaeEmail}`}>
<Button className={`${isMobile ? 'w-full mb-5' : ''}`} type="primary" onClick={handleApplyPosition}>申请职位</Button>
</Popover>
);
return (
<div className="bg-F5F7FE">
<PageContent className="no-banner-body">
<div className={`w-5/6 mx-auto pt-6 flex mb-5 md:w-full md:flex-col ${otherPositionList.length ? 'justify-between' : 'justify-center'}`}>
<div
className={`w-p720 relative bg-white shadow-card08 p-10 md:w-full md:mb-5 md:p-5 ${showMore && isMobile ? 'h-p580 overflow-hidden' : ''}`}
ref={wrapRef as unknown as React.RefObject<HTMLDivElement>}
>
<div className="flex justify-between items-center pb-8 mb-8 border-b border-solid border-gray-200 md:pb-4 md:mb-4">
<div>
<div className="text-0D0C22 text-30-38 font-semibold">{currentJob.name}</div>
</div>
{
isMobile ? null : applyPositionBtn
}
</div>
<div>
<IF check={currentJob.teamDesc}>
<p className="text-0D0C22 text-20-28 my-2 font-semibold">团队介绍</p>
<p className="text-2F3C5F text-16-28">{currentJob.teamDesc}</p>
</IF>
<Item list={currentJob.responsibilities} title="岗位职责" />
<Item list={currentJob.requirements} title="岗位要求" />
<Item list={currentJob.prioritize || []} title="优先考虑" />
</div>
{
showMore && showMoreBtn && isMobile ? (
<div onClick={handleShowMore} className="absolute w-full bottom-0 left-0 right-0 h-16 bg-gradient-more text-primary flex justify-center items-center">
查看更多
</div>
) : null
}
</div>
{
otherPositionList.length ? (
<div className="w-p260 md:w-full">
<div className={jobListCls}>
<p className="text-14-28 text-0D0C22 mb-2 font-semibold">其他职位</p>
{
<ul>
{
otherPositionList.map((item) => {
const isCurrent = jobIndex === item.code;
const cls = classNames('text-14-28 cursor-pointer hover:text-primary', {
'text-primary font-semibold': isCurrent,
'text-2F3C5F': !isCurrent,
});
return (<li className={cls} key={item.code} onClick={() => { handleChangeJob(item.code); }}>{item.name}</li>);
})
}
</ul>
}
</div>
</div>
) : null
}
</div>
{
isMobile ? applyPositionBtn : null
}
</PageContent>
</div>
);
};
export default withRouter(JobDetail);
|
laojun/website
|
src/layout/common/error-page.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as React from 'react';
import { Link } from 'react-router-dom';
import i18n from '~/i18n';
import notFound from '~/images/common/404.png';
import envStore from '~/models/env';
import './error-page.scss';
import { useMobile } from 'common/utils';
const NotFound = () => {
const isMobile = useMobile();
React.useEffect(() => {
envStore.reducers.setHeaderInfo({
whiteHeader: true,
});
return () => {
envStore.reducers.resetHeaderInfo();
};
}, []);
return (
<div className="not-found-page basic-error-page">
<div className="info gray-bg no-banner-body">
<img className={isMobile ? '' : 'mr40'} width={220} src={notFound} alt="" />
<div className="desc">
<span>{i18n.t('page not found')}</span>
<Link aria-label="go back to home page" to="/"> {i18n.t('back to homepage')} </Link>
</div>
</div>
</div>
);
};
export {
NotFound,
};
|
laojun/website
|
src/pages/price/config.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import { ColumnsType } from 'interface/common';
import { Icon } from 'common';
import { Button } from 'antd';
import React from 'react';
import { goTo } from 'common/utils';
export type IVersion = 'freeVersion' | 'enterpriseEdition' | 'privateDeploymentVersion';
export type abilityScope = 'devOps' | 'microService' | 'multi-cloudManagement';
export type ISpecType = 'mini' | 'normal' | 'pro' | 'plus';
export const versionMap: { [k in IVersion]: string } = {
freeVersion: '免费版',
enterpriseEdition: '企业版',
privateDeploymentVersion: '私有部署版',
};
export type Item = {
[k in IVersion]: boolean;
} & {
scope: abilityScope;
name: string;
key: string;
};
export interface SpecItem {
key: string;
name: string;
freeVersion: string;
enterpriseEdition: {
[k in ISpecType]: string | Array<string>;
};
privateDeploymentVersion: string;
}
interface IAbilitiesTreeItem {
children: Item[];
name: string;
key: abilityScope;
}
const render = (dataIndex: string, value: boolean, record: IAbilitiesTreeItem, _index?: number): React.ReactNode => {
if (record.children?.length) {
return record.children.every((t) => t[dataIndex]) ? '包含' : record.children.filter((t) => t[dataIndex]).length ? '部分包含' : null;
}
return value ? <Icon className="able-mark" type="check" /> : null;
};
const renderSpec = (cellData: any, record: SpecItem): React.ReactNode => {
if (record.key === 'cpu') {
const [value, description] = cellData;
return (
<>
<p>{value}</p>
{
description ? <p className="dark-6">（{description}）</p> : null
}
</>
);
}
return cellData;
};
const enterpriseEditionSpec: { [k in ISpecType]: {
key: k;
cpuCore: Array<string>;
price: string;
monitorStorage: string;
} } = {
mini: {
key: 'mini',
cpuCore: ['<= 80 Core', '按 8 核算，10 节点'],
price: '88,999',
monitorStorage: '600 G',
},
normal: {
key: 'normal',
cpuCore: ['<= 240 Core', '按 8 核算，30 节点'],
price: '233,700',
monitorStorage: '1500 G',
},
pro: {
key: 'pro',
cpuCore: ['<= 400 Core', '按 8 核算，50 节点'],
price: '369,500',
monitorStorage: '2400 G',
},
plus: {
key: 'plus',
cpuCore: ['<= 800 Core', '按 8 核算，100 节点'],
price: '699,500',
monitorStorage: '4000 G',
},
};
const versionInfo: {
[k in IVersion]: {
name: string;
LinkComp?: React.ReactNode;
bottomComp: React.ReactNode;
tip?: string;
pricingStrategies: Array<{ key: string; priceInPc?: React.ReactNode; price?: React.ReactNode; specification: React.ReactNode; gift?: React.ReactNode }>;
}
} = {
freeVersion: {
name: versionMap.freeVersion,
bottomComp: <Button type="primary" onClick={() => { window.open('/login-erda'); }}>立即体验</Button>,
tip: 'DevOps 平台部分内容',
pricingStrategies: [{
key: 'A',
priceInPc: <div className="price-in-pc pa20"><p><span className="small">￥</span><span className="large">0</span></p><span className="tips">免费功能将持续增加</span></div>,
price: '始终免费、免费功能将持续增加',
specification: '用户数 <= 50人',
}],
},
enterpriseEdition: {
name: versionMap.enterpriseEdition,
bottomComp: <Button type="primary" onClick={() => { window.open('/contact'); }}>申请试用</Button>,
pricingStrategies: Object.values(enterpriseEditionSpec).map((t) => {
return {
key: t.key,
price: `￥${t.price}/年`,
priceInPc: <div className="price-in-pc pa20"><p className=""><span className="small">￥</span><span className="large">{t.price}</span><span className="small">起</span></p><span className="tips">每年</span></div>,
specification: `CPU 核数 ${t.cpuCore.join('，')}`,
gift: `监控存储${t.monitorStorage}`,
};
}),
},
privateDeploymentVersion: {
name: versionMap.privateDeploymentVersion,
bottomComp: <Button type="primary" onClick={() => { goTo('/contact'); }}>商务咨询</Button>,
tip: '在企业版的基础之上还包含',
pricingStrategies: [{
key: 'A',
priceInPc: <div className="price-in-pc pa20">如需定价信息<br />请询问我们的商务</div>,
price: '如需定价信息，请询问我们的商务',
specification: '无人员数和节点数限制',
}],
},
};
const versionColumns: ColumnsType<IAbilitiesTreeItem> = [
{
title: '功能与服务',
dataIndex: 'name',
width: 600,
}, {
title: versionMap.freeVersion,
dataIndex: 'freeVersion',
width: 200,
render: (...rest) => render('freeVersion', ...rest),
}, {
title: versionMap.enterpriseEdition,
dataIndex: 'enterpriseEdition',
width: 200,
render: (...rest) => render('enterpriseEdition', ...rest),
}, {
title: versionMap.privateDeploymentVersion,
dataIndex: 'privateDeploymentVersion',
width: 200,
render: (...rest) => render('privateDeploymentVersion', ...rest),
},
];
export const specData: SpecItem[] = [
{
key: 'price',
name: '价格',
freeVersion: '-',
enterpriseEdition: {
mini: `￥${enterpriseEditionSpec.mini.price}`,
normal: `￥${enterpriseEditionSpec.normal.price}`,
pro: `￥${enterpriseEditionSpec.pro.price}`,
plus: `￥${enterpriseEditionSpec.plus.price}`,
},
privateDeploymentVersion: '-',
},
{
key: 'cpu',
name: '总 CPU 核数',
freeVersion: '-',
enterpriseEdition: {
mini: enterpriseEditionSpec.mini.cpuCore,
normal: enterpriseEditionSpec.normal.cpuCore,
pro: enterpriseEditionSpec.pro.cpuCore,
plus: enterpriseEditionSpec.plus.cpuCore,
},
privateDeploymentVersion: '-',
},
{
key: 'monitorStorage',
name: '监控和日志存储',
freeVersion: '-',
enterpriseEdition: {
mini: enterpriseEditionSpec.mini.monitorStorage,
normal: enterpriseEditionSpec.normal.monitorStorage,
pro: enterpriseEditionSpec.pro.monitorStorage,
plus: enterpriseEditionSpec.plus.monitorStorage,
},
privateDeploymentVersion: '-',
},
];
export const specColumns: ColumnsType<SpecItem> = [
{
title: '规格&价格',
dataIndex: 'name',
align: 'center',
},
{
title: versionMap.freeVersion,
dataIndex: 'freeVersion',
align: 'center',
},
{
title: versionMap.enterpriseEdition,
align: 'center',
children: [
{
title: 'MINI',
align: 'center',
dataIndex: ['enterpriseEdition', 'mini'],
render: renderSpec,
},
{
title: 'NORMAL',
align: 'center',
dataIndex: ['enterpriseEdition', 'normal'],
render: renderSpec,
},
{
title: 'PRO',
align: 'center',
dataIndex: ['enterpriseEdition', 'pro'],
render: renderSpec,
},
{
title: 'PLUS',
align: 'center',
dataIndex: ['enterpriseEdition', 'plus'],
render: renderSpec,
},
],
},
{
title: versionMap.privateDeploymentVersion,
align: 'center',
dataIndex: 'privateDeploymentVersion',
},
];
const abilities: Item[] = [
{ scope: 'devOps', freeVersion: true, enterpriseEdition: true, privateDeploymentVersion: true, name: '敏捷项目协同', key: 'agileProjectCollaboration' },
{ scope: 'devOps', freeVersion: true, enterpriseEdition: true, privateDeploymentVersion: true, name: '手工测试管理', key: 'manualTestManagement' },
{ scope: 'devOps', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '自动化测试管理', key: 'automatedTestManagement' },
{ scope: 'devOps', freeVersion: true, enterpriseEdition: true, privateDeploymentVersion: true, name: '代码托管', key: 'codeHosting' },
{ scope: 'devOps', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '代码扫描、分析', key: 'codeScanningAnalysis' },
{ scope: 'devOps', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: 'API 全生命周期管理', key: 'apiFullLifeCycleManagement' },
{ scope: 'devOps', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '图形化流水线编排', key: 'Graphical pipeline orchestration' },
{ scope: 'devOps', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '自动化CI/CD', key: 'automatedCICD' },
{ scope: 'devOps', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '制品管理', key: 'productManagement' },
{ scope: 'microService', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '配置中心', key: 'configurationCenter' },
{ scope: 'microService', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '注册中心', key: 'registryCenter' },
{ scope: 'microService', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: 'API 网关管理', key: 'apiGatewayManagement' },
{ scope: 'microService', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: 'APM （应用拓扑、主动监控、全链路诊断和追踪、可视化大盘和告警）', key: 'apm' },
{ scope: 'microService', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '日志服务', key: 'logService' },
{ scope: 'multi-cloudManagement', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '混合云管理', key: 'hybridCloudManagement' },
{ scope: 'multi-cloudManagement', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '多集群管理', key: 'multiClusterManagement' },
{ scope: 'multi-cloudManagement', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '资源调度管理', key: 'resourceSchedulingManagement' },
{ scope: 'multi-cloudManagement', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '安全审计', key: 'securityAudit' },
{ scope: 'multi-cloudManagement', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '数字资产运维、运营', key: 'digitalAssetOperationMaintenanceOperation' },
{ scope: 'multi-cloudManagement', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '白屏化运维 Kubernetes', key: 'whiteScreenOperationAndMaintenanceKubernetes' },
{ scope: 'multi-cloudManagement', freeVersion: false, enterpriseEdition: true, privateDeploymentVersion: true, name: '服务市场', key: 'serviceMarket' },
];
export const abilitiesTree: IAbilitiesTreeItem[] = [
{
name: 'DevOps 平台',
key: 'devOps',
children: abilities.filter((t) => t.scope === 'devOps'),
},
{
name: '微服务治理平台',
key: 'microService',
children: abilities.filter((t) => t.scope === 'microService'),
},
{
name: '多云管理平台',
key: 'multi-cloudManagement',
children: abilities.filter((t) => t.scope === 'multi-cloudManagement'),
},
];
const showVersion: IVersion[] = ['freeVersion', 'enterpriseEdition', 'privateDeploymentVersion'];
const abilitiesByVersion = showVersion.map((item) => {
return {
type: item,
...versionInfo[item],
};
});
export { abilities, versionColumns, abilitiesByVersion };
|
laojun/website
|
src/pages/home/index.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import React from 'react';
import Banner from './banner';
import MainCard from './main-card';
import ProjectManagement from './project-manage';
import TestManage from './test-manage';
import PageContent from '~/layout/common/page-content';
import { CopmFadeInUp } from 'pages/component/animate-comp';
import HomeConfig from 'pages/home/config';
import DoubleWing from 'pages/home/double-wing';
import { Link } from 'react-router-dom';
import i18n from '~/i18n';
import './index.scss';
const Home = () => {
return (
<div className="erda-home pt0">
<Banner />
<MainCard />
<ProjectManagement />
<DoubleWing {...HomeConfig.codeRepositories} />
<DoubleWing {...HomeConfig.api} />
<TestManage {...HomeConfig.testManage} />
<DoubleWing {...HomeConfig.cicd} />
<DoubleWing {...HomeConfig.monitor} />
<DoubleWing {...HomeConfig.log} />
<DoubleWing {...HomeConfig.multiCloud} />
<DoubleWing {...HomeConfig.fdp} />
<div className="contact-trial">
<PageContent>
<CopmFadeInUp>
<p className="title">{i18n.t('what difficulties does your team have in the application development process?')}</p>
</CopmFadeInUp>
<CopmFadeInUp>
<div className="center-flex-box btns mt36">
<div
className="btn-item free-trial center-flex-box"
onClick={() => {
window.open('/login-erda');
}}
>{i18n.t('common:free trial')}
</div>
<Link className="btn-item contact center-flex-box" to="/contact">{i18n.t('default:contact us')}</Link>
</div>
</CopmFadeInUp>
</PageContent>
</div>
</div>
);
};
export default Home;
|
laojun/website
|
src/layout/common/loginPanel.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as React from 'react';
import userStore from '~/models/user';
import './loginPanel.scss';
import i18n from '~/i18n';
const LoginPanel = () => {
const handleLogin = () => {
userStore.effects.login();
};
return (
<div className="site-loginpanel">
<span className="login-item">
<a onClick={handleLogin} className="bold" target="_blank" rel="noopener noreferrer">{i18n.t('common:Sign In')}</a>
</span>
{/* go to the login page temporarily, confirmed with PM */}
{/* <a onClick={handleLogin} className="bold free-registration ml20">{i18n.t('common:Sign Up')}</a> */}
</div>
);
};
export default LoginPanel;
|
laojun/website
|
src/layout/common/user-info.tsx
|
<reponame>laojun/website
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import React from 'react';
import { Avatar, Popover } from 'antd';
import userStore from '~/models/user';
import { Icon as CustomIcon } from 'common';
import { getParentContainer } from 'common/utils';
import defaultOrgIcon from '~/images/common/default-org-icon.svg';
import i18n from '~/i18n';
import './user-info.scss';
const UserInfo = () => {
const [visible, setVisible] = React.useState(false);
const [org, user] = userStore.useStore((s) => [s.orgList, s.user]);
const logout = () => {
userStore.effects.logout();
setVisible(false);
};
const goToPlatform = (targetUrl: string) => {
setVisible(false);
window.open(targetUrl);
};
const content = (
<div className="py4">
{
org.length ? (
<div className="pb4 org-wrapper">
<ul className="org-list">
{
org.map((item) => {
const { domain, displayName, id, logo, name } = item;
const targetUrl = `//${domain}/${name}`;
return (
<li key={id} className="org-item flex-box px16 my8" onClick={() => { goToPlatform(targetUrl); }}>
<Avatar shape="square" className="mr8" src={logo || defaultOrgIcon}>
{displayName.slice(0, 1).toUpperCase()}
</Avatar>
<span className="flex-1 nowrap">{displayName}</span>
</li>
);
})
}
</ul>
</div>
) : (
<div className="pb4 org-wrapper px16">
<p onClick={() => {
window.open('/login-erda');
}} className="hover:text-primary cursor-pointer">
探索组织
<CustomIcon className="ml-1" type="Rightarrow"/>
</p>
</div>
)
}
<div className="erda-user-info-menu-item px16 py4 logout" onClick={logout}>{i18n.t('sign out')}</div>
</div>
);
return (
<div className="erda-header-user-wrap">
<Popover
visible={visible}
placement="bottomRight"
className="user-info flex-box"
trigger="click"
title={<p className="py4">{user.nick}</p>}
content={content}
overlayClassName="action-wrapper"
onVisibleChange={setVisible}
getPopupContainer={getParentContainer}
>
<Avatar className="mr8" src={user.avatar}>
{user.nick.slice(0, 1).toUpperCase()}
</Avatar>
<CustomIcon className="unfold fz12" type="unfold" />
</Popover>
</div>
);
};
export default UserInfo;
|
laojun/website
|
interface/style.d.ts
|
<gh_stars>0
declare module '*.module.scss' {
const content: any;
export = content;
}
declare module '*.png' {
const content: any;
export = content;
}
declare module '*.svg' {
export function ReactComponent(
props: React.SVGProps<SVGSVGElement>,
): React.ReactElement;
const url: string;
export default url;
}
|
laojun/website
|
src/types/org.d.ts
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Copyright (c) number; Terminus, Inc.
//
// Licensed under the Apache License, Version number;.number; (the string;);
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-number;.number;
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
declare namespace ORG{
interface IOrgItem{
id: number;
creator: string;
desc: string;
logo: string;
name: string;
displayName: string;
locale: string;
config: {
enableMS: boolean;
smtpHost: string;
smtpUser: string;
smtpPassword: string;
smtpPort: number;
smtpIsSSL: boolean;
smsKeyID: string;
smsKeySecret: string;
smsSignName: string;
smsMonitorTemplateCode: string;
vmsKeyID: string;
vmsKeySecret: string;
vmsMonitorTtsCode: string;
vmsMonitorCalledShowNumber: string;
auditInterval: number;
};
blockoutConfig: {
blockDev: boolean;
blockTest: boolean;
blockStage: boolean;
blockProd: boolean;
};
enableReleaseCrossCluster: boolean;
selected: boolean;
operation: string;
status: string;
type: string;
publisherId: number;
domain: string;
openFdp: boolean;
version: number;
createdAt: string;
updatedAt: string;
}
}
|
laojun/website
|
src/models/user.ts
|
<gh_stars>0
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import { getCurrentUser, login, logout } from '~/services/login';
import { getOrgList } from '~/services/org';
import { createStore } from '~/cube';
interface IState {
user: USER.IUser;
orgList: ORG.IOrgItem[];
orgHasMore: boolean;
}
const initState: IState = {
user: {} as USER.IUser,
orgList: [],
orgHasMore: false,
};
const userStore = createStore({
name: 'user',
state: initState,
effects: {
async login({ call }) {
const data = await call(login);
if (data && data.url) {
window.localStorage.setItem('lastPath', window.location.href);
window.location.href = data.url;
}
},
async getCurrentUser({ call, update }) {
const res = await call(getCurrentUser);
if (res.success) {
update({ user: res.data });
userStore.effects.getOrgs({ pageNo: 1, pageSize: 100 });
}
},
async getOrgs({ call, update }, { pageNo, pageSize }: {pageNo: number; pageSize: number}) {
const res = await call(getOrgList, { pageSize, pageNo });
const { list } = res.data;
update({
orgList: list || [],
});
},
async logout({ call }) {
const data = await call(logout);
if (data && data.url) {
const url = new URL(data.url);
userStore.reducers.clearUser();
userStore.reducers.clearOrg();
// temporary: specify the redirectUrl by the FE
window.location.href = `${url.origin}${url.pathname}?redirectUrl=${window.location.href}`;
}
},
},
reducers: {
clearUser(state) {
state.user = {} as USER.IUser;
},
clearOrg(state) {
state.orgList = [];
},
},
});
export default userStore;
|
laojun/website
|
src/pages/join/index.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import React from 'react';
import PageContent from '~/layout/common/page-content';
import { map } from 'lodash';
import { Icon as CustomIcon } from 'common';
import { jobs, applicationProcess } from 'pages/join/config';
import './index.scss';
import { useMobile, goTo } from 'common/utils';
const JoinUs = () => {
const isMobile = useMobile();
return (
<div className="join-erda gray-bg pt0">
<div className="full-width-header v-flex-box">
<div className="title">加入我们</div>
</div>
<PageContent className="py-10 body md:py-4">
<div className="text-center mb-8">
<span className="text-32-44 relative sub-title px-9">开放职位</span>
</div>
<div className="flex w-3/4 mx-auto flex-wrap md:w-full">
{
map(jobs, (item, key) => {
const { list, name, logo } = item;
if (list.length) {
return (
<div key={key} className="mb-5 mx-2.5 w-p430 h-40 shadow-card08 p-10 relative overflow-hidden cursor-pointer rounded md:mx-0 hover:shadow-card2" onClick={() => { goTo(`/join/${key}`); }}>
<p className="text-28-36 mb-4 text-0D0C22">{name}</p>
<p className="text-20-28 text-0D0C22 text-opacity-60">查看岗位详情</p>
<div className="absolute -bottom-4 right-0">
<CustomIcon className="text-E1DEFB text-100" type={logo} />
</div>
</div>
);
} else {
return null;
}
})
}
</div>
<div className="text-center mb-8 mt-14">
<span className="text-32-44 relative sub-title px-9">应聘流程</span>
</div>
<div className="flex w-3/4 mx-auto flex-wrap justify-between items-center md:w-full md:flex-col">
{
applicationProcess.map(((item, index) => {
return (
<>
<div className="flex flex-col items-center">
<img width={98} height={98} src={item.img} alt="" />
<p className="text-20-28 text-0D0C22 text-center mt-3 md:mb-10">{item.name}</p>
</div>
{
isMobile || index === applicationProcess.length - 1 ? null : <div className="arrows -mt-6" />
}
</>
);
}))
}
</div>
</PageContent>
</div>
);
};
export default JoinUs;
|
laojun/website
|
src/pages/home/images.ts
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import { isZh } from '~/i18n';
import mainLeft from '~/images/home/main-l.png';
import mainRight from '~/images/home/main-r.png';
import mainCenter from '~/images/home/main-c.png';
import mainCenterEn from '~/images/home/main-c-en.png';
import projectManagement from '~/images/home/Pic2.png';
import projectManagementEn from '~/images/home/Pic2-en.png';
import projectManagementMale from '~/images/home/Pic2-1.png';
import projectManagementFemale from '~/images/home/Pic2-2.png';
import codeRepo from '~/images/home/Pic3.png';
import api from '~/images/home/Pic7.png';
import cicd from '~/images/home/Pic4.png';
import monitor from '~/images/home/Pic5.png';
import monitorEn from '~/images/home/Pic5-en.png';
import log from '~/images/home/Pic-log.png';
import logEn from '~/images/home/Pic-log-en.png';
import multiCloud from '~/images/home/Pic9.png';
import multiCloudEn from '~/images/home/Pic9-en.png';
import banner from '~/images/home/banner/earth.png';
import fdp from '~/images/home/fdp.png';
const zhImgMap = {
banner,
mainLeft,
mainRight,
mainCenter,
projectManagement,
projectManagementMale,
projectManagementFemale,
codeRepo,
api,
cicd,
monitor,
log,
multiCloud,
fdp,
};
const enImgMap = {
banner,
mainLeft,
mainRight,
mainCenter: mainCenterEn,
projectManagement: projectManagementEn,
projectManagementMale,
projectManagementFemale,
codeRepo,
api,
cicd,
monitor: monitorEn,
log: logEn,
multiCloud: multiCloudEn,
fdp,
};
export default isZh() ? zhImgMap : enImgMap;
|
laojun/website
|
src/pages/contact-us/constant.ts
|
<filename>src/pages/contact-us/constant.ts
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import i18n from '~/i18n';
export const COMPANY_SIZE = [
{ value: i18n.t('20 people or less'), name: i18n.t('20 people or less') },
{ value: i18n.t('21-100 people'), name: i18n.t('21-100 people') },
{ value: i18n.t('101-500 people'), name: i18n.t('101-500 people') },
{ value: i18n.t('501-1000 people'), name: i18n.t('501-1000 people') },
{ value: i18n.t('More than 1000 people'), name: i18n.t('More than 1000 people') },
];
export const IT_SIZE = [
{ value: i18n.t('10 people or less'), name: i18n.t('10 people or less') },
{ value: i18n.t('11-50 people'), name: i18n.t('11-50 people') },
{ value: i18n.t('51-100 people'), name: i18n.t('51-100 people') },
{ value: i18n.t('101-200 people'), name: i18n.t('101-200 people') },
{ value: i18n.t('More than 200 people'), name: i18n.t('More than 200 people') },
];
export const PURPOSE = {
advisory: { value: i18n.t('corporate business consulting'), name: i18n.t('corporate business consulting') },
partner: { value: i18n.t('join as a partner'), name: i18n.t('join as a partner') },
study: { value: i18n.t('personal study'), name: i18n.t('personal study') },
other: { value: i18n.t('other'), name: i18n.t('other') },
};
export const NAME_MAP = {
realname: i18n.t('actual name'),
mobile: i18n.t('phone number'),
position: i18n.t('position'),
email: i18n.t('business email address'),
company: i18n.t('company name'),
company_size: i18n.t('enterprise size'),
it_size: i18n.t('IT department size'),
purpose: i18n.t('purpose of application'),
otherPurpose: i18n.t('purpose of application'),
};
|
laojun/website
|
src/layout/common/header.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as React from 'react';
import { throttle, isEmpty } from 'lodash';
import classNames from 'classnames';
import IntroMenu from './menu';
import IntroMobileMenu from './menu-mobile';
import LoginPanel from './loginPanel';
import { Link } from 'react-router-dom';
import { getScrollTop } from '~/common/utils';
import UserInfo from '~/layout/common/user-info';
import userStore from '~/models/user';
import { useSiteEnv } from '~/models/env';
import { Icon } from 'common';
import './header.scss';
let mobileMenuOpen = false;
interface IProps {
onChangeVisible: (vis: boolean) => void;
path: string;
isWhite?: boolean;
}
const Header = ({ onChangeVisible, path }: IProps) => {
const lastTop = React.useRef(getScrollTop());
const [showHeaderDrawer, setShowHeaderDrawer] = React.useState(false);
const [visible, setVisible] = React.useState(true);
const [flexHeader, setFlexHeader] = React.useState(lastTop.current !== 0);
const userData = userStore.useStore((s) => s.user);
const { getCurrentUser } = userStore.effects;
const [{ whiteHeader, headerShadow }] = useSiteEnv();
React.useEffect(() => {
getCurrentUser();
lastTop.current = getScrollTop();
// 刷新页面保留了滚动高度时，延时检查
setTimeout(() => {
setFlexHeader(lastTop.current !== 0);
setVisible(true);
}, 0);
const onScroll = throttle(() => {
if (mobileMenuOpen) {
setFlexHeader(lastTop.current !== 0);
setVisible(true);
return;
}
const currentTop = Math.max(getScrollTop(), 0); // safari向上拉动时为负
setFlexHeader(currentTop > 10);
const direction = currentTop > lastTop.current ? 'down' : 'up';
const distance = Math.abs(lastTop.current - currentTop);
const shouldChange = distance > 5;
// 显示状态时，向上滚动显示，否则隐藏；隐藏状态时，向下滚动显示，否则隐藏
const nextVisible = visible ? (direction === 'up') : (direction === 'down');
shouldChange && setVisible(nextVisible);
lastTop.current = currentTop;
}, 200);
window.addEventListener('scroll', onScroll, { passive: true });
return () => {
window.removeEventListener('scroll', onScroll);
};
}, []);
React.useEffect(() => {
onChangeVisible(visible);
}, [visible]);
const toggleMenu = (flag: boolean) => {
setFlexHeader(flag || lastTop.current !== 0);
};
const handlevisibleChange = (flag: boolean) => {
setShowHeaderDrawer(flag);
};
const cls = classNames({
'site-header': true,
unselectable: true,
'flex-header': flexHeader,
'white-header': whiteHeader || showHeaderDrawer,
'no-shadow': showHeaderDrawer || !headerShadow,
});
// const logo = flexHeader || whiteHeader ? 'logo-colorful' : 'logo-white'
return (
<header className={cls} onMouseEnter={() => toggleMenu(true)} onMouseLeave={() => toggleMenu(false)}>
<div className="site-header-wrap">
<Link className="logo" aria-label="go to home page" to="/">
<Icon className="site-logo" type="logo2" />
</Link>
<IntroMenu page={path} handlevisibleChange={handlevisibleChange} />
{isEmpty(userData) ? <LoginPanel /> : <UserInfo/>}
{/* since the Marketplace and case don't support i18n, hide this button first */}
{/* <Popover content={i18n.t('common:switch language')} placement="bottom" getPopupContainer={(e) => e.parentElement}> */}
{/* <Icon onClick={switchLocale} className="switch-lang ml12" type="i18n" /> */}
{/* </Popover> */}
<IntroMobileMenu onToggle={(v: boolean) => { mobileMenuOpen = v; }} />
</div>
</header>
);
};
export default Header;
|
laojun/website
|
src/pages/home/banner.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import React from 'react';
import PageContent from '~/layout/common/page-content';
import { Button } from 'antd';
import { CopmFadeInUp } from 'pages/component/animate-comp';
import i18n from '~/i18n';
import images from './images';
const Banner = () => {
return (
<div className="erda-home-banner">
<div className="erda-home-banner-mask" />
<PageContent>
<CopmFadeInUp delay={0}>
<div className="erda-home-banner-title">Erda Cloud</div>
</CopmFadeInUp>
<CopmFadeInUp delay={100}>
<div className="erda-home-banner-desc mt16">{i18n.t('a one-stop enterprise digital platform based')}</div>
</CopmFadeInUp>
<CopmFadeInUp delay={200}>
<Button
className="erda-home-banner-free-trial mt24"
onClick={() => {
window.open('/login-erda');
}}
>{i18n.t('free trial')}
</Button>
</CopmFadeInUp>
<div className="earth">
<img width={550} height={550} src={images.banner} alt="" />
</div>
</PageContent>
</div>
);
};
export default Banner;
|
laojun/website
|
src/services/login.ts
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import axios from 'axios';
import { getCookies } from 'common/utils';
export const login = (): Promise<{ url: string }> => {
return axios({
url: '/api/openapi/login',
method: 'get',
}).then((res) => {
return res.data;
});
};
export const getCurrentUser = (): Promise<IResponse<USER.IUser>> => {
return axios({
url: '/api/users/me',
params: {
HIDDEN_MESSAGE_REQUEST: true,
},
method: 'get',
}).then((res) => res.data).catch((e) => e);
};
export const logout = (): Promise<{ url: string }> => {
const OPENAPICSRFTOKEN = getCookies('OPENAPI-CSRF-TOKEN');
return axios({
url: '/api/openapi/logout',
method: 'post',
headers: {
'OPENAPI-CSRF-TOKEN': OPENAPICSRFTOKEN,
},
}).then((res) => res.data);
};
|
laojun/website
|
src/layout/common/menu.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as React from 'react';
import { Menu, Popover, Drawer } from 'antd';
import { map } from 'lodash';
import { Link } from 'react-router-dom';
import { SpriteIcons } from 'common';
import { config } from '~/config';
import { getParentContainer } from 'common/utils';
import PageContent from '~/layout/common/page-content';
import i18n from '~/i18n';
import './menu.scss';
const { Item: MenuItem, SubMenu } = Menu;
interface IPropsMenuDrawer {
name: string;
subList: any[];
handlevisibleChange: (data: boolean) => void;
page: string;
}
const MenuDrawer = ({ name, subList, handlevisibleChange, page }: IPropsMenuDrawer) => {
const [visible, setVisible] = React.useState(false);
React.useEffect(() => {
close();
}, [page]);
const handleClick = () => {
setVisible((pre) => {
handlevisibleChange(!pre);
return !pre;
});
};
const close = () => {
setVisible(false);
handlevisibleChange(false);
};
return (
<>
<a onClick={handleClick} className="bold-600">{name}</a>
<Drawer
getContainer={document.getElementsByClassName('erda-default-layout')[0] as HTMLElement}
className="menu-drawer"
placement="top"
visible={visible}
closable={false}
onClose={close}
>
<div className="items">
<div className=" item-wraper">
<PageContent className="flex-box">
{
subList.map((subMenu) => {
return (
<div key={subMenu.name} className="item">
{subMenu.img ? <SpriteIcons path="common" className={`site-sub-menu-img ${subMenu.img}`} /> : null}
<div className="name">{subMenu.name}</div>
<div className="desc">{subMenu.description}</div>
</div>
);
})
}
</PageContent>
</div>
</div>
</Drawer>
</>
);
};
interface IMenu {
handlevisibleChange: (v: boolean) => void;
page: string;
}
const IntroMenu = ({ handlevisibleChange, page }: IMenu) => {
const menuList = config.headerMenus;
return (
<nav className="site-menu">
<Menu mode="horizontal" selectedKeys={[]}>
{map(menuList, (menu: any, index: number) => {
const { name, subList, url, jumpOut, props, status } = menu;
const isFirst = index === 0;
if (status === 'unrealized') {
return (
<MenuItem key={name}>
<Popover placement="bottom" content={<p className="nowrap">{ i18n.t('comming soon') }</p>} getPopupContainer={getParentContainer}>
<a className="bold-600">{name}</a>
</Popover>
</MenuItem>
);
} else if (subList) {
return (
<MenuItem key={name}>
<MenuDrawer page={page} name={name} subList={subList} handlevisibleChange={handlevisibleChange} />
</MenuItem>
);
return (
<SubMenu popupClassName="flex-children-menu" key={name} title={name} className={`bold-600 ${isFirst ? 'first-menu' : ''}`} popupOffset={[12, -8]}>
{map(subList, (subMenu: any) => {
return (
<MenuItem className="site-sub-menu-item" key={subMenu.url}>
{subMenu.img ? <SpriteIcons path="common" className={`site-sub-menu-img ${subMenu.img}`} /> : null}
<div className="name">{subMenu.name}</div>
<div className="desc">{subMenu.description}</div>
</MenuItem>
);
})}
</SubMenu>
);
} else {
return (
<MenuItem key={url}>
{
jumpOut
? <a className="bold-600" href={url} {...props} target="_blank" rel="noopener noreferrer">{name}</a>
: <Link className="bold-600" aria-label={`open ${name}`} to={url}> {name} </Link>
}
</MenuItem>
);
}
})}
</Menu>
</nav>
);
};
export default IntroMenu;
|
laojun/website
|
src/layout/common/footer.tsx
|
// Copyright (c) 2021 Terminus, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import React from 'react';
import PageContent from '~/layout/common/page-content';
import { Icon as CustomIcon } from 'common';
import { config } from '~/config';
import { Popover } from 'antd';
import i18n from '~/i18n';
import './footer.scss';
const leftConf = [
{ name: '© 2021 erda.cloud', url: config.terminusDomain },
{ name: 'Term', url: config.temrUrl },
{ name: 'Extend', url: config.extendUrl },
{ name: 'Cli', url: config.cliUrl },
{ name: 'Securify', url: config.securifyUrl },
{ name: 'ChangeLog', url: config.changeLogUrl },
{ name: i18n.t('join us'), url: '/join' },
{ name: i18n.t('Zhejiang ICP No. 13004315-6'), url: 'https://beian.miit.gov.cn' },
{ name: i18n.t('Zhejiang Public Network Security No. 33010802003150'), url: 'http://www.beian.gov.cn/portal/registerSystemInfo?recordcode=33010802003150' },
];
const rightConf = [
{
name: 'DDGroup',
comp: <img src="/images/common/dd-group.jpg" width={100} height={120} />,
icon: 'dingding-o',
},
{
name: 'WeChat',
comp: <img src="/images/common/wechat.png" width={120} height={120} />,
icon: 'wechat',
},
{ name: 'GitHub', url: 'https://github.com/erda-project', icon: 'github' },
];
const Footer = () => {
return (
<div className="erda-temp-footer">
<PageContent className="full-height flex-box v-flex">
<div className="link-wrap flex-start">
{
leftConf.map((item) => {
return item.url ? (
<a className="ml16 fz12" target="_blank" rel="noopener noreferrer" key={item.name} href={item.url}>{item.name}</a>
) : (
<span className="ml16 fz12" key={item.name}>{item.name}</span>
);
})
}
</div>
<div className="right-wrapper">
{
rightConf.map((item) => {
const { url, comp } = item;
return url ? (
<a className="ml16" target="_blank" rel="noopener noreferrer" key={item.name} href={item.url}>
<CustomIcon className="fz24" type={item.icon} />
</a>
) : (
<Popover key={item.name} content={comp}>
<CustomIcon className="fz24 ml16" type={item.icon} />
</Popover>
);
})
}
</div>
</PageContent>
</div>
);
};
export default Footer;
|
ismile/syaro
|
src/modules/booru/BooruInfo.tsx
|
import React from 'react';
import { Linking, ScrollView, StyleSheet, View } from "react-native";
import { Appbar, List } from 'react-native-paper';
import { NavigationScreenProps } from 'react-navigation';
import { IPost } from '../../Services/Moebooru.api';
export default class BooruInfo extends React.PureComponent<NavigationScreenProps, any> {
style = StyleSheet.create({
container : { flex: 1, flexDirection: 'column', alignContent: 'flex-start',flexGrow: 10 },
scrollView : { flex: 1, backgroundColor: 'black'}
})
render() {
let data:IPost = this.props.navigation.state.params;
return <View style={this.style.container}>
<ScrollView style={this.style.scrollView}>
<List.Item
title='Tags'
description={data.tags} />
<List.Item
title='Source'
onPress={()=> Linking.openURL(data.source)}
description={data.source} />
<List.Item
title='Author'
description={data.author} />
<List.Item
title='Rating'
description={data.rating} />
<List.Item
title='Size'
description={`${data.file_size} (${data.width} x ${data.height})`} />
<List.Item
title='JPEG Size'
description={`${data.jpeg_file_size} (${data.jpeg_width} x ${data.jpeg_height})`} />
<List.Item
title='Image Url'
onPress={()=> Linking.openURL(data.file_url)}
description={data.file_url} />
<List.Item
title='JPEG Url'
onPress={()=> Linking.openURL(data.jpeg_url)}
description={data.jpeg_url} />
</ScrollView>
<Appbar.Header>
<Appbar.Action icon="arrow-back" accessibilityLabel='Back' onPress={()=> {this.props.navigation.goBack(null)}} />
</Appbar.Header>
</View>
}
}
|
ismile/syaro
|
src/modules/booru/BooruSetting.tsx
|
import React from 'react';
import { View } from "react-native";
import { Text } from 'react-native-paper';
export default class BooruSetting extends React.PureComponent {
render() {
return <View style={{ flex: 1, alignItems: "center", justifyContent: "center" }}>
<Text>Setting </Text>
</View>
}
}
|
ismile/syaro
|
src/modules/booru/BooruMenu.tsx
|
<reponame>ismile/syaro
import React from 'react';
import { StyleSheet, View, TouchableHighlight } from "react-native";
import { Appbar, List, FAB, Portal, Dialog, Button, TextInput } from 'react-native-paper';
import { NavigationScreenProps } from 'react-navigation';
import AsyncStorage from '@react-native-community/async-storage';
import { produce } from 'immer';
import theme from '../../configs/theme';
import uuid from 'uuid/v4'
export default class BooruMenu extends React.PureComponent<NavigationScreenProps, any> {
listConstant = '@syaro_data_booru_list'
state = {
showForm : false,
dialogTitle : 'Add Booru',
nameInput : '',
hostInput : '',
idInput : '',
showDelete : false,
data : [{
id : '11111111-1111-1111-1111-111111111111',
name : 'Konachan',
host : 'konachan.com'
}, {
id : '11111111-1111-1111-1111-111111111112',
name : 'Yandere',
host : 'yande.re'
}]
}
style = StyleSheet.create({
container : { flex: 1, flexDirection: 'column', alignContent: 'flex-start',flexGrow: 10 },
view : { flex: 1, backgroundColor: 'black'},
fabContainer : { position: 'absolute', top: 0, left: 0, right: 0, bottom: 0, justifyContent: 'center', alignItems: 'center'},
fab : { position: 'absolute', margin: 'auto', bottom: 28, right: 20, alignItems: 'center' },
buttonDialog : { marginLeft: 10, marginRight: 10, marginBottom: 10}
})
async componentDidMount() {
var itemJSON = await AsyncStorage.getItem(this.listConstant)
if(itemJSON != null) {
this.setState(produce(this.state, state => { state.data = JSON.parse(itemJSON)}))
} else {
await AsyncStorage.setItem(this.listConstant, JSON.stringify(this.state.data))
}
}
render() {
return <View style={this.style.container}>
<View style={this.style.view}>
{this.state.data.map((v, i) => {
return <List.Item
key={i}
title={v.name}
right={() => <TouchableHighlight onPress={(e)=> {e.stopPropagation(); this.handleEdit(v)}}><List.Icon color='white' icon="edit" /></TouchableHighlight>}
onPress={()=> this.handlePress(v)}
description={v.host} />
})}
</View>
<Appbar.Header>
<Appbar.Action icon="arrow-back" accessibilityLabel='Back' onPress={()=> {this.props.navigation.goBack(null)}} />
</Appbar.Header>
<View style={this.style.fabContainer}>
<FAB
style={this.style.fab}
icon="add"
onPress={() => this.setState(produce(this.state, state => {state.showForm = true; state.showDelete = false; state.idInput = uuid()}))}
/>
</View>
<Portal>
<Dialog
visible={this.state.showForm}
onDismiss={()=> this.setState(produce(this.state, state => {state.showForm = false}))}>
<Dialog.Title>{this.state.dialogTitle}</Dialog.Title>
<Dialog.Content>
<TextInput
// mode='flat'
label='Name'
value={this.state.nameInput}
onChangeText={text => this.setState(produce(this.state, state => {state.nameInput = text}))}
/>
<TextInput
// mode='outlined'
label='Host'
value={this.state.hostInput}
onChangeText={text => this.setState(produce(this.state, state => {state.hostInput = text}))}
/>
</Dialog.Content>
<Dialog.Actions>
{this.state.showDelete && <Button style={this.style.buttonDialog} onPress={()=> this.handleDelete()}>Delete</Button>}
<Button style={this.style.buttonDialog} onPress={()=> this.setState(produce(this.state, state => {state.showForm = false}))}>close</Button>
<Button style={this.style.buttonDialog} mode='contained' color={theme.colors.primary} onPress={()=> this.handleSave()}>Save</Button>
</Dialog.Actions>
</Dialog>
</Portal>
</View>
}
async handleSave() {
await this.setState(produce(this.state, state => {
state.showForm = false;
state.dialogTitle = 'Add Booru'
var index = state.data.findIndex(x => x.id === state.idInput)
if(index != -1) {
state.data[index] = {
id: state.idInput,
name: state.nameInput,
host: state.hostInput
}
} else {
state.data.push({
id: state.idInput,
name: state.nameInput,
host: state.hostInput
})
}
}))
await AsyncStorage.setItem(this.listConstant, JSON.stringify(this.state.data))
}
async handleEdit(data) {
await this.setState(produce(this.state, state => {
state.showForm = true;
state.showDelete = true,
state.dialogTitle = 'Edit '+data.name;
state.hostInput = data.host;
state.nameInput = data.name;
state.idInput = data.id;
}))
}
async handleDelete() {
await this.setState(produce(this.state, state => {
var index = state.data.findIndex(x => x.id === state.idInput)
state.data.splice(index, 1);
state.showForm = false
}))
await AsyncStorage.setItem(this.listConstant, JSON.stringify(this.state.data))
}
handlePress = async (v)=> {
await this.props.navigation.navigate('Gallery', v);
this.props.navigation.state.params.fetch()
}
}
|
ismile/syaro
|
src/configs/theme.ts
|
import React from 'react';
import { DefaultTheme, DarkTheme, Provider as PaperProvider, Theme } from 'react-native-paper';
const theme:Theme = {
...DarkTheme,
dark: true,
colors: {
...DarkTheme.colors,
primary: '#3498db',
accent: '#f1c40f',
}
};
export default theme;
|
ismile/syaro
|
src/components/iconize.tsx
|
<filename>src/components/iconize.tsx
import React, {useState} from 'react';
import Icon from 'react-native-vector-icons/MaterialIcons';
export const Iconize = name => ({ tintColor }) => (
<Icon
style={{ backgroundColor: 'transparent' }}
name={name}
color={tintColor}
size={24}
/>
);
export default Iconize;
|
ismile/syaro
|
src/modules/booru/BooruImage.tsx
|
import React from 'react';
import { View, StyleSheet } from "react-native";
import FastImage from 'react-native-fast-image';
import Image, { createImageProgress } from 'react-native-image-progress';
import ImageViewer from 'react-native-image-zoom-viewer';
import { Appbar, FAB } from 'react-native-paper';
import ProgressBar from 'react-native-progress/Bar';
import { NavigationScreenProps } from 'react-navigation';
import RNFetchBlob from 'rn-fetch-blob';
import theme from '../../configs/theme';
import { IPost } from '../../Services/Moebooru.api';
export default class BooruImage extends React.PureComponent<NavigationScreenProps, any> {
state = {
open: false
}
style = StyleSheet.create({
container : { flex: 1, flexDirection: 'column', alignContent: 'flex-start' },
fabContainer : { position: 'absolute', top: 0, left: 0, right: 0, bottom: 0, justifyContent: 'center', alignItems: 'center'},
fab : { position: 'absolute', margin: 'auto', bottom: 28, right: 20, alignItems: 'center' }
})
render() {
let data:IPost = this.props.navigation.state.params.data;
return <View style={this.style.container}>
<ImageViewer imageUrls={[{
url: data.sample_url,
width: data.sample_width,
height: data.sample_height}]}
renderImage={ImageView}
renderIndicator={() => {}}
/>
<Appbar.Header>
<Appbar.Action icon="arrow-back" accessibilityLabel='Back' onPress={()=> {this.props.navigation.goBack(null)}} />
<Appbar.Action icon="archive" accessibilityLabel='Download jpg image' disabled={!data.jpeg_url || data.jpeg_url == ''} onPress={() => this.download('jpg') } />
<Appbar.Action icon="info" accessibilityLabel='Info' onPress={() => this.props.navigation.navigate('Info', data) } />
</Appbar.Header>
<View style={this.style.fabContainer}>
<FAB
style={this.style.fab}
icon="file-download"
onPress={() => this.download()}
/>
</View>
</View>
}
async download(type='ori') {
let data:IPost = this.props.navigation.state.params.data;
let site = this.props.navigation.state.params.site
var url = data.file_url;
switch (type) {
case 'jpg':
url = data.jpeg_url
break;
case 'sample':
url = data.sample_url
break;
}
var ext:String = url.split('.').pop();
var mime = 'image/jpeg';
if(ext.toLowerCase() == 'png') mime = 'image/png'
try {
let d = await RNFetchBlob
.config({
fileCache: true,
addAndroidDownloads : {
useDownloadManager : true,
notification : true,
description : `Downloading Konachan - ${data.id}.${ext}`,
mime: mime,
path : `${RNFetchBlob.fs.dirs.DownloadDir}/syaro_tmp/${site.name} - ${data.id}.${ext}`
}
})
.fetch('GET', url)
if(!(await RNFetchBlob.fs.exists(`${RNFetchBlob.fs.dirs.PictureDir}/syaro`))) {
await RNFetchBlob.fs.mkdir(`${RNFetchBlob.fs.dirs.PictureDir}/syaro`)
}
// mv file to prevent files being deleted after uninstalling app
if(await RNFetchBlob.fs.exists(d.path())) {
await RNFetchBlob.fs.mv(d.path(), `${RNFetchBlob.fs.dirs.PictureDir}/syaro/${site.name} - ${data.id}.${ext}`)
}
} catch (error) {
console.log(error)
}
}
}
const ImageProgress = createImageProgress(FastImage);
const ImageView = function(props:any) {
return <Image indicator={ProgressBar} indicatorProps={{color: theme.colors.accent}} {...props} />
}
|
ismile/syaro
|
src/modules/booru/BooruGallery.tsx
|
import { produce } from 'immer';
import React from 'react';
import { PermissionsAndroid, StyleSheet, View, Dimensions, ProgressBarAndroid, Linking } from "react-native";
import { WaterfallList } from 'react-native-largelist-v3';
import { Appbar, Button, Dialog, Divider, FAB, Menu, Portal, TextInput, ProgressBar, List } from 'react-native-paper';
import { NavigationTransitionProps } from 'react-navigation';
import { IPost, MoebooruApi } from '../../Services/Moebooru.api';
import BooruGalleryDetail from './BooruGalleryDetail';
import theme from '../../configs/theme';
const { width } = Dimensions.get( "window" );
const space = 5;
const columnWidth = ( width ) / 2 - space;
export default class BooruGallery extends React.PureComponent<NavigationTransitionProps, {posts:Array<IPost>}> {
gallery: WaterfallList;
api:MoebooruApi = new MoebooruApi('konachan.com');
defaultData = {
name : 'Konachan',
host : 'konachan.com'
}
state = {
open : false,
showFilter : false,
filterTextValue : '',
posts : [],
isRefreshing : false,
params : {
page : 1
}
}
style = StyleSheet.create({
cont : { flex: 1, flexDirection: 'column', alignContent: 'flex-start' },
gallery : { backgroundColor: 'black', padding: space/2},
fabContainer : { position: 'absolute', top: 0, left: 0, right: 0, bottom: 0, justifyContent: 'center', alignItems: 'center' },
fab : { position: 'absolute', margin: 'auto', bottom: 28, alignItems: 'center' }
})
render() {
return <View style={this.style.cont}>
<WaterfallList
ref={ref => (this.gallery = ref)}
data={this.state.posts}
numColumns={2}
preferColumnWidth={columnWidth}
heightForItem={item => (columnWidth / item.preview_width * item.preview_height)+space}
style={this.style.gallery}
onRefresh={this.handleOnRefresh}
onLoading={this.handleOnEndReached}
renderItem={(item:IPost)=> <BooruGalleryDetail data={item} handleGoToDetail={this.handleGoToDetail} />}
/>
<AppBarView
showProgress={this.state.isRefreshing}
params={this.props.navigation.state.params}
handleShowFilter={this.handleShowFilter}
/>
<View style={this.style.fabContainer}>
<FAB
style={this.style.fab}
icon="apps"
onPress={() => this.props.navigation.navigate('Menu', {fetch: this._fetchData.bind(this), forceUpdate: this.forceUpdate.bind(this)}) }
/>
</View>
<FilterView
filterTextValue={this.state.filterTextValue}
showFilter={this.state.showFilter}
handleTextFilterChange={this.handleTextFilterChange}
handleHideFilter={this.handleHideFilter}
handleFilter={this.handleFilter}
handleClearFilter={this.handleClearFilter} />
</View>
}
async componentDidMount() {
await this._fetchData()
this.handleRequestPermission()
}
handleOnEndReached = ()=> this._fetchData({page: this.state.params.page+1})
handleOnRefresh = ()=> this._fetchData()
handleGoToDetail = (item)=> {
this.props.navigation.navigate('Image', {
data: item,
site: this.props.navigation.state.params? this.props.navigation.state.params: this.defaultData
})
}
handleOpenMenu = () => this.setState(produce(this.state, state => { state.showMenu= true }));
handleCloseMenu = () => this.setState(produce(this.state, state => { state.showMenu = false }));
handleShowFilter = () => this.setState(produce(this.state, state => { state.showFilter = true }));
handleTextFilterChange = (text:string) => this.setState(produce(this.state, state => { state.filterTextValue = text }))
handleHideFilter = () => this.setState(produce(this.state, state => { state.showFilter = false }));
handleFilter = async () => {
var data = this.props.navigation.state.params ? this.props.navigation.state.params: this.defaultData
data = {...data, page: 1, tags: this.state.filterTextValue}
await this.props.navigation.navigate('Gallery', data)
this.handleHideFilter()
this._fetchData()
}
handleClearFilter = async () => {
var data = this.props.navigation.state.params ? this.props.navigation.state.params: this.defaultData
data = {...data, page: 1, tags: null}
await this.props.navigation.navigate('Gallery', data)
this.setState(produce(this.state, state => { state.filterTextValue = ''}));
this.handleHideFilter()
this._fetchData()
}
async handleRequestPermission() {
try {
let check = await PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE);
if(!check) {
const granted = await PermissionsAndroid.requestMultiple(
[PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE, PermissionsAndroid.PERMISSIONS.READ_EXTERNAL_STORAGE]
);
}
} catch (err) {
console.warn(err);
}
}
async _fetchData(params={page: 1}) {
this.setState(produce(this.state, state => {
state.isRefreshing = true
}))
var data = this.props.navigation.state.params? this.props.navigation.state.params:{...this.defaultData}
params.tags = data.tags;
var res = await this.api.post(params, data);
if(params.page == 1) this.setState(produce(this.state, state => {state.posts = []}))
await this.setState(produce(this.state, state => {
state.posts = state.posts.concat(res.data)
state.params = {
...state.params,
...params
}
state.isRefreshing = false
}))
this.gallery.endRefresh()
this.gallery.endLoading()
}
}
const FilterView = React.memo(function(props: {
showFilter : boolean,
handleHideFilter : ()=> any,
handleClearFilter : ()=> any,
handleFilter : ()=> any,
handleTextFilterChange : (text:string)=> any,
filterTextValue : string,
}) {
return <Portal>
<Dialog
visible={props.showFilter}
onDismiss={props.handleHideFilter}>
<Dialog.Title>Filter</Dialog.Title>
<Dialog.Content>
<TextInput
value={props.filterTextValue}
onChangeText={props.handleTextFilterChange}
/>
</Dialog.Content>
<Dialog.Actions>
<Button onPress={props.handleHideFilter}>Close</Button>
<Button onPress={props.handleClearFilter}>Clear</Button>
<Button onPress={props.handleFilter}>Filter</Button>
</Dialog.Actions>
</Dialog>
</Portal>
})
const AppBarView = React.memo(function(props:{
showProgress : boolean,
params : any,
handleShowFilter : () => any,
}) {
const [showMenu, setShowMenu] = React.useState(false)
const [showAbout, setAbout] = React.useState(false)
return <React.Fragment>
{props.showProgress && <ProgressBarAndroid styleAttr='Horizontal' color={theme.colors.accent} style={{backgroundColor: 'black'}} indeterminate={true} /> }
<Appbar.Header>
<Appbar.Content
title={props.params ? props.params.name : 'Konachan'}
subtitle={(props.params && props.params.tags) ? props.params.tags: 'All'}
/>
<Appbar.Action icon="filter-list" onPress={props.handleShowFilter} />
<Menu
visible={showMenu}
onDismiss={() => setShowMenu(false)}
anchor={
<Appbar.Action icon="more-vert" onPress={()=> setShowMenu(true)} />
}
>
<Menu.Item icon='settings' onPress={() => {}} title="Setting" />
<Divider />
<Menu.Item icon='info' onPress={() => setAbout(true)} title="About" />
</Menu>
</Appbar.Header>
<Portal>
<Dialog
visible={showAbout}
onDismiss={()=> setAbout(false)}>
<Dialog.Title>About</Dialog.Title>
<Dialog.Content>
<List.Item
title='Syaro V0.10.0'
onPress={()=> Linking.openURL('https://github.com/ismile')}
description={'\u00A9 2019 ismile|Bajiguri'} />
</Dialog.Content>
<Dialog.Actions>
<Button onPress={()=> setAbout(false)}>Close</Button>
</Dialog.Actions>
</Dialog>
</Portal>
</React.Fragment>
})
|
ismile/syaro
|
App.tsx
|
<reponame>ismile/syaro
/**
* @format
*/
import React, { Component } from 'react';
import { Platform, StyleSheet, StatusBar } from 'react-native';
import { Provider as PaperProvider } from 'react-native-paper';
import themeConfig from './src/configs/theme';
import BooruNavigator from './src/modules/booru/BooruNavigator';
import theme from './src/configs/theme';
export default class App extends Component {
render() {
return (
<PaperProvider theme={themeConfig}>
<StatusBar backgroundColor={theme.colors.primary} barStyle="light-content" />
<BooruNavigator />
</PaperProvider>
);
}
}
|
ismile/syaro
|
src/modules/booru/BooruNavigator.tsx
|
<reponame>ismile/syaro
import { createAppContainer, createStackNavigator } from "react-navigation";
import BooruGallery from './BooruGallery';
import BooruImage from './BooruImage';
import BooruInfo from './BooruInfo';
import BooruMenu from './BooruMenu';
const BooruNavigator = createStackNavigator({
Gallery: {
screen: BooruGallery
},
Image: {
screen: BooruImage
},
Info: {
screen: BooruInfo
},
Menu: {
screen: BooruMenu
}
},{
defaultNavigationOptions: {
header: () => null,
headerStyle: {
backgroundColor: '#f4511e',
},
headerTintColor: '#fff',
headerTitleStyle: {
fontWeight: 'bold',
}
}
});
export default createAppContainer(BooruNavigator);
|
ismile/syaro
|
src/Services/Moebooru.api.ts
|
<filename>src/Services/Moebooru.api.ts
import axios from 'axios';
export class MoebooruApi {
host:string = ''
http = axios;
constructor(host:string='') {
this.host = host;
}
async post(param:IPostParams={limit: 15}, config={host:this.host}) {
param = {
limit: 30,
page: 1,
...param
}
var res = this.http.get(`http://${config.host}/post.json`, {
params: param
})
return res;
}
}
export interface IPostParams {
limit?:number,
page?: number,
tags?: string
}
export interface IPost {
actual_preview_height: number,
actual_preview_width: number,
author: string,
change: number,
created_at: number,
creator_id: number,
file_size: number,
file_url: string,
frames: Array<any>,
frames_pending: Array<any>,
frames_pending_string: string,
frames_string: string,
has_children: boolean,
height: number,
id: number,
is_held: boolean,
is_shown_in_index: boolean,
jpeg_file_size: number,
jpeg_height: number,
jpeg_url: string,
jpeg_width: number,
md5: string,
parent_id: number,
preview_height: number,
preview_url: string,
preview_width: number,
rating: string,
sample_file_size: number,
sample_height: number,
sample_url: string,
sample_width: number,
score: number,
source: string,
status: string,
tags: string,
width: number
}
export default new MoebooruApi();
|
ismile/syaro
|
src/modules/booru/BooruGalleryDetail.tsx
|
<gh_stars>0
import React from 'react';
import { Dimensions, TouchableHighlight, View } from "react-native";
import FastImage from 'react-native-fast-image';
import { createImageProgress } from 'react-native-image-progress';
import ProgressBar from 'react-native-progress/Bar';
import theme from '../../configs/theme';
import { IPost } from '../../Services/Moebooru.api';
const Image = createImageProgress(FastImage);
const { width } = Dimensions.get( "window" );
const columnWidth = ( width ) / 2 - 5;
class BooruGalleryDetail extends React.PureComponent<{data:IPost, handleGoToDetail:Function}, {}> {
render() {
return <View
style={{ margin: 2.5, overflow: 'hidden' }}>
<TouchableHighlight onPress={()=> {this.props.handleGoToDetail(this.props.data)}} underlayColor="white">
<Image
source={{ uri: this.props.data.preview_url }}
indicator={ProgressBar}
indicatorProps={{color: theme.colors.accent}}
style={{
width: columnWidth,
height: columnWidth / this.props.data.preview_width * this.props.data.preview_height,
}}/>
</TouchableHighlight>
</View>
}
}
export default React.memo(BooruGalleryDetail)
|
Leenai0425/api
|
packages/rpc-core/src/packageInfo.ts
|
// Copyright 2017-2022 @polkadot/rpc-core authors & contributors
// SPDX-License-Identifier: Apache-2.0
// Do not edit, auto-generated by @polkadot/dev
export const packageInfo = { name: '@polkadot/rpc-core', path: 'auto', type: 'auto', version: '7.8.2-6' };
|
EstebanMarin/youandme
|
nestjs-task-management/src/tasks/pipes/task-status.pipe.ts
|
import { PipeTransform, BadRequestException } from "@nestjs/common";
import { TaskStatus } from "../task-status.enum";
export class TaskStatusValidationPipe implements PipeTransform {
readonly validOptions = new Set([TaskStatus.CLOSED, TaskStatus.DONE, TaskStatus.OPEN])
private checkIfInvalid(value: any){
return !this.validOptions.has(value);
}
transform(value: any){
value.toUpperCase();
if(this.checkIfInvalid(value)){
throw new BadRequestException(`status: ${value} is invalid`);
}
return value;
}
}
|
EstebanMarin/youandme
|
nestjs-task-management/src/tasks/tasks.controller.ts
|
import { Controller, Get, Post, Body, Param, Delete, Patch, Query, UsePipes, ValidationPipe, ParseIntPipe, UseGuards, Logger } from '@nestjs/common';
import { TasksService } from './tasks.service';
import { TaskStatus } from './task-status.enum';
import { CreateTaskDto } from './dto/create-task.dto';
import { GetTaskFilterDto } from './dto/get-tasks.dto';
import { TaskStatusValidationPipe } from './pipes/task-status.pipe';
import { Task } from './task.entity';
import { AuthGuard } from '@nestjs/passport';
import { GetUser } from 'src/auth/get-user.decorator';
import { User } from 'src/auth/user.entity';
@Controller('tasks')
@UseGuards(AuthGuard())
export class TasksController {
private logger = new Logger(`tasks.controller.ts`)
constructor(
private taskService: TasksService,
) {}
@Get()
getAllTasks(
@Query(ValidationPipe) filterDto: GetTaskFilterDto,
@GetUser() user : User,
) {
this.logger.verbose(`user: ${user.username}: retreiving all tasks filterDto: ${JSON.stringify(filterDto)}`)
return this.taskService.getTasks(filterDto, user);
}
@Get('/:id')
getTaskById(
@Param('id', ParseIntPipe) id: number,
@GetUser() user: User,
): Promise<Task> {
return this.taskService.getTaskById(id, user);
}
@Post()
@UsePipes(ValidationPipe)
createTask(
@Body() createTask: CreateTaskDto,
@GetUser() user: User,
): Promise<Task> {
return this.taskService.createTask(createTask, user);
}
@Delete('/:id')
deleteTaskById(
@Param('id', ParseIntPipe) id: number,
@GetUser() user: User,
): Promise<void> {
const found = this.taskService.deleteTaskById(id, user);
return found;
}
@Patch('/:id/status')
updateTaskStatus(
@Param('id', ParseIntPipe) id: number,
@Body('status', TaskStatusValidationPipe) status: TaskStatus,
@GetUser() user: User,
): Promise<Task> {
return this.taskService.updateTaskStatus(id, status, user);
}
}
|
Inchoker/dream
|
src/shared/mapper.ts
|
<filename>src/shared/mapper.ts<gh_stars>0
import { TaskDto } from '@todo/dto/task.dto';
import { TodoEntity } from '@todo/entity/todo.entity';
import { TodoDto } from '@todo/dto/todo.dto';
import { TaskEntity } from '@todo/entity/task.entity';
import { UserEntity } from '@user/entity/user.entity';
import { UserDto } from '@user/dto/user.dto';
export const toTodoDto = (data: TodoEntity): TodoDto => {
const { id, name, description, tasks, owner } = data;
let todoDto: TodoDto = {
id,
name,
description,
owner: owner ? toUserDto(owner) : null,
};
if (tasks) {
todoDto = {
...todoDto,
tasks: tasks.map((task: TaskEntity) => toTaskDto(task)),
};
}
return todoDto;
};
export const toTaskDto = (data: TaskEntity): TaskDto => {
const { id, name } = data;
let taskDto: TaskDto = {
id,
name,
};
return taskDto;
};
export const toUserDto = (data: UserEntity): UserDto => {
const { id, username, email } = data;
let userDto: UserDto = {
id,
username,
email,
};
return userDto;
};
|
iqbalansyor/react-native-notification-stack-card
|
Example/StackList.tsx
|
import * as React from 'react';
import {
FlatList,
Animated,
View,
StyleSheet,
TouchableOpacity,
TouchableHighlight,
} from 'react-native';
// import { TouchableWithoutFeedback } from 'react-native-gesture-handler';
// import {TouchableHighlight} from 'react-native-gesture-handler';
interface StackListProps {
visibleItems: number;
data: any[];
itemWidth: number;
itemHeight: number;
spacing: number;
closeButtonView: React.ReactElement;
renderItem: (item: any) => React.ReactElement;
}
export let setActiveIndex = (index: number) => {};
const StackList: React.FunctionComponent<StackListProps> = (
props: StackListProps,
) => {
const scrollXIndex = React.useRef(new Animated.Value(0)).current;
const scrollXAnimated = React.useRef(new Animated.Value(0)).current;
const [listIndex, setListIndex] = React.useState(0);
setActiveIndex = React.useCallback((activeIndex) => {
scrollXIndex.setValue(activeIndex);
setListIndex(activeIndex);
});
React.useEffect(() => {
Animated.timing(scrollXAnimated, {
toValue: scrollXIndex,
useNativeDriver: true,
}).start();
});
return (
<FlatList
data={props.data}
keyExtractor={(_, index) => String(index)}
horizontal
inverted
contentContainerStyle={{
flex: 1,
justifyContent: 'center',
marginTop: 0.05 * props.itemHeight * props.visibleItems,
}}
scrollEnabled={false}
removeClippedSubviews={false}
CellRendererComponent={(itemProps) => {
const {item, index, children, style, ...props} = itemProps;
const newStyle = [
style,
{
zIndex:
index < listIndex - 1
? -100
: props.parentProps.data.length - index,
},
];
return (
<View style={newStyle} index={index} {...props}>
{children}
</View>
);
}}
renderItem={(renderItemProps) => {
let {item, index} = renderItemProps;
let newRenderItemProps = {...renderItemProps, activeIndex: listIndex};
console.log('print', index, listIndex);
const inputRange = [index - 1, index, index + 1, index + 2];
const translateX = scrollXAnimated.interpolate({
inputRange,
outputRange: [0, 0, 0, 1000],
});
const translateY = scrollXAnimated.interpolate({
inputRange,
outputRange: [props.spacing, 0, 0, 1000],
});
const scale = scrollXAnimated.interpolate({
inputRange,
outputRange: [0.95, 1, 0, 0],
});
const opacity = scrollXAnimated.interpolate({
inputRange,
outputRange: [
index - listIndex >= props.visibleItems ? 0 : 1,
1,
0,
0,
],
});
return (
<Animated.View
style={{
position: 'absolute',
left: -props.itemWidth / 2,
opacity,
transform: [
{
translateX,
},
{translateY},
{scale},
],
}}>
<TouchableOpacity
activeOpacity={0.8}
onPress={(index) => {
console.log('printpress', index);
}}>
<View>
<View>{props.renderItem(newRenderItemProps)}</View>
{props.closeButtonView ? (
<TouchableOpacity
style={{
top: 20,
right: 20,
position: 'absolute',
}}
onPress={() => {
console.log('print', index);
setActiveIndex(index + 1);
}}>
{props.closeButtonView}
</TouchableOpacity>
) : null}
</View>
</TouchableOpacity>
</Animated.View>
);
}}
/>
);
};
export default StackList;
const styles = StyleSheet.create({
container: {
flex: 1,
justifyContent: 'center',
backgroundColor: '#fff',
},
title: {
fontSize: 28,
fontWeight: '900',
textTransform: 'uppercase',
letterSpacing: -1,
},
location: {
fontSize: 16,
},
date: {
fontSize: 12,
},
});
|
iqbalansyor/react-native-notification-stack-card
|
src/StackCardList.tsx
|
import * as React from 'react';
import {
FlatList,
Animated,
View,
StyleSheet,
TouchableOpacity,
TouchableHighlight,
} from 'react-native';
interface StackCardListProps {
visibleItems: number | 3;
stackType?: 'below' | 'above';
data: any[];
itemWidth: number | 100;
itemHeight: number | 100;
spacing: number | 10;
closeButtonView?: React.ReactElement;
renderItem: (item: any) => React.ReactElement;
onItemPress: (index: number, item: any) => void;
onEmpty?: () => void;
}
interface StackCardListState {
listIndex: number;
}
class StackCardList extends React.Component<
StackCardListProps,
StackCardListState
> {
scrollXIndex: Animated.Value;
scrollXAnimated: Animated.Value;
constructor(props) {
super(props);
this.scrollXIndex = new Animated.Value(0);
this.scrollXAnimated = new Animated.Value(0);
this.state = {
listIndex: 0,
};
}
componentDidMount() {
Animated.timing(this.scrollXAnimated, {
toValue: this.scrollXIndex,
useNativeDriver: true,
}).start();
}
next = () => {
this.scrollXIndex.setValue(this.state.listIndex + 1);
this.setState({ listIndex: this.state.listIndex + 1 });
if (this.state.listIndex === this.props.data.length - 1) {
this.props.onEmpty && this.props.onEmpty();
}
};
render() {
const { listIndex } = this.state;
const visibleItems = this.props.visibleItems || 3;
const stackType = this.props.stackType || 'above';
const itemWidth = this.props.itemWidth || 100;
const itemHeight = this.props.itemHeight || 100;
let spacing = this.props.spacing || 10;
return (
<FlatList
style={{
height: spacing * (visibleItems - 1) + itemHeight,
}}
data={this.props.data}
keyExtractor={(_, index) => String(index)}
horizontal
inverted
contentContainerStyle={{
flex: 1,
justifyContent: 'center',
marginBottom:
stackType === 'below' ? spacing * (visibleItems - 1) : 0,
marginTop: stackType === 'below' ? 0 : spacing * (visibleItems - 1),
}}
scrollEnabled={false}
removeClippedSubviews={false}
CellRendererComponent={(itemProps) => {
const { item, index, children, style, ...props } = itemProps;
const newStyle = [
style,
{
zIndex:
index < listIndex - 1
? -100
: props.parentProps.data.length - index,
},
];
return (
<View style={newStyle} index={index} {...props}>
{children}
</View>
);
}}
renderItem={(renderItemProps) => {
let newSpacing = spacing;
if (stackType === 'below') {
newSpacing = -spacing;
}
let { item, index } = renderItemProps;
let newRenderItemProps = {
...renderItemProps,
activeIndex: listIndex,
};
console.log('print', index, listIndex);
const inputRange = [index - 1, index, index + 1, index + 2];
const translateX = this.scrollXAnimated.interpolate({
inputRange,
outputRange: [0, 0, 0, 1000],
});
const translateY = this.scrollXAnimated.interpolate({
inputRange,
outputRange: [-newSpacing, 0, 0, 1000],
});
const scale = this.scrollXAnimated.interpolate({
inputRange,
outputRange: [0.95, 1, 0, 0],
});
const opacity = this.scrollXAnimated.interpolate({
inputRange,
outputRange: [index - listIndex >= visibleItems ? 0 : 1, 1, 0, 0],
});
return (
<Animated.View
style={{
position: 'absolute',
left: -itemWidth / 2,
opacity,
transform: [
{
translateX,
},
{ translateY },
{ scale },
],
}}
>
<TouchableOpacity
activeOpacity={0.8}
onPress={(event) => {
this.props.onItemPress && this.props.onItemPress(index, item);
}}
>
<View>
<View>{this.props.renderItem(newRenderItemProps)}</View>
{this.props.closeButtonView ? (
<TouchableOpacity
style={{
top: 20,
right: 20,
position: 'absolute',
}}
onPress={() => {
this.next();
}}
>
{this.props.closeButtonView}
</TouchableOpacity>
) : null}
</View>
</TouchableOpacity>
</Animated.View>
);
}}
/>
);
}
}
export default StackCardList;
|
SLS8h/DeborahKk
|
app/customers/customer.ts
|
export class Customer {
constructor(public firstName = '',
public lastName = '',
public email = '',
public phone = '',
public notification = 'email') {}
}
|
SLS8h/DeborahKk
|
app/customers/customer.component.ts
|
<reponame>SLS8h/DeborahKk
import { Component, OnInit, AfterViewInit, ViewChildren, ElementRef } from '@angular/core';
import { FormGroup, FormBuilder, Validators, AbstractControl, FormControlName } from '@angular/forms';
import 'rxjs/add/operator/debounceTime';
import 'rxjs/add/observable/fromEvent';
import 'rxjs/add/observable/merge';
import { Observable } from 'rxjs/Observable';
import { Customer } from './customer';
import { GenericValidator } from '../shared/generic-validator';
function emailMatcher(c: AbstractControl) {
let emailControl = c.get('email');
let confirmControl = c.get('confirmEmail');
if (emailControl.pristine || confirmControl.pristine) {
return null;
}
if (emailControl.value === confirmControl.value) {
return null;
}
return { 'match': true };
}
@Component({
selector: 'my-signup',
templateUrl: './app/customers/customer.component.html'
})
export class CustomerComponent implements OnInit, AfterViewInit {
@ViewChildren(FormControlName, { read: ElementRef }) formControls: ElementRef[];
customerForm: FormGroup;
customer: Customer = new Customer();
displayMessage: { [key: string]: string } = {};
genericValidator: GenericValidator;
private validationMessages: { [key: string]: { [key: string]: string } } = {
firstName: {
required: 'Please enter your first name.',
minlength: 'The first name must be longer than 3 characters.'
},
lastName: {
required: 'Please enter your last name.',
maxlength: 'The last name must be less than 50 characters.',
},
email: {
required: 'Please enter your email address.',
pattern: 'Please enter a valid email address.'
}
};
constructor(private fb: FormBuilder) {
// Create an instance of the generic validator
this.genericValidator = new GenericValidator(this.validationMessages);
}
ngOnInit(): void {
this.customerForm = this.fb.group({
firstName: [null, [Validators.required, Validators.minLength(3)]],
lastName: [null, [Validators.required, Validators.maxLength(50)]],
emailGroup: this.fb.group({
email: [null, [Validators.required, Validators.pattern('[a-z0-9._%+-]+@[a-z0-9.-]+')]],
confirmEmail: [null, Validators.required]
}, { validator: emailMatcher }),
phone: null,
notification: 'email'
});
this.customerForm.get('notification').valueChanges.subscribe(value => {
this.setNotification(value);
});
}
ngAfterViewInit() {
let controlBlurs: Observable<any>[] = this.formControls
.map((formControl: ElementRef) => Observable.fromEvent(formControl.nativeElement, 'blur'));
Observable.merge(this.customerForm.valueChanges, ...controlBlurs).debounceTime(1000).subscribe(value => {
this.displayMessage = this.genericValidator.processMessages(this.customerForm);
});
}
save(): void {
console.log('Saved: ' + JSON.stringify(this.customerForm.value));
}
setNotification(notifyVia: string): void {
let phoneControl = this.customerForm.get('phone');
if (notifyVia === 'text') {
phoneControl.setValidators(Validators.required);
} else {
phoneControl.clearValidators();
}
phoneControl.updateValueAndValidity();
}
}
|
effortcheep/vue3-mobile-template
|
src/router/index.ts
|
import { createRouter, createWebHashHistory } from 'vue-router'
// import routes from './router'
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import routes from 'virtual:generated-pages'
console.log(routes)
export default createRouter({
routes,
history: createWebHashHistory(),
})
|
effortcheep/vue3-mobile-template
|
src/service/request/interceptors.ts
|
<gh_stars>1-10
import type { AxiosRequestConfig, AxiosResponse } from 'axios'
export const requestInterceptor = (
config: AxiosRequestConfig,
): AxiosRequestConfig => {
return config
}
export const responseInterceptor = (res: AxiosResponse): AxiosResponse => {
return res
}
|
effortcheep/vue3-mobile-template
|
src/views/home/home.api.ts
|
<reponame>effortcheep/vue3-mobile-template
import http from '@/service'
export declare interface Type {
a: number
}
export function foo(): Promise<Type> {
return http.get<Type>({
url: '/get',
params: { a: 1, b: 1 },
})
}
|
effortcheep/vue3-mobile-template
|
src/service/request/index.ts
|
import axios from 'axios'
import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'
interface SJRequestInterceptors<T = AxiosResponse> {
requestInterceptor?: (config: AxiosRequestConfig) => AxiosRequestConfig
requestInterceptorCatch?: (error: any) => any
responseInterceptor?: (res: T) => T
responseInterceptorCatch?: (error: any) => any
}
interface SJRequestConfig<T = AxiosResponse> extends AxiosRequestConfig {
interceptors?: SJRequestInterceptors<T>
}
class SJRequest {
instance: AxiosInstance
interceptors?: SJRequestInterceptors
constructor(config: SJRequestConfig) {
this.instance = axios.create(config)
this.interceptors = config.interceptors
this.instance.interceptors.request.use(
this.interceptors?.requestInterceptor,
this.interceptors?.requestInterceptorCatch,
)
this.instance.interceptors.response.use(
this.interceptors?.responseInterceptor,
this.interceptors?.responseInterceptorCatch,
)
this.instance.interceptors.request.use(
config => {
return config
},
err => {
return err
},
)
this.instance.interceptors.response.use(
res => {
return res.data
},
err => {
return err
},
)
}
request<T>(config: SJRequestConfig<T>): Promise<T> {
return new Promise((resolve, reject) => {
if (config.interceptors?.requestInterceptor) {
config = config.interceptors.requestInterceptor(config)
}
this.instance
.request<any, T>(config)
.then(res => {
if (config.interceptors?.responseInterceptor) {
res = config.interceptors?.responseInterceptor(res)
}
resolve(res)
})
.catch(err => {
reject(err)
return err
})
})
}
get<T>(config: SJRequestConfig<T>): Promise<T> {
return this.request({ ...config, method: 'GET' })
}
post<T>(config: SJRequestConfig<T>): Promise<T> {
return this.request({ ...config, method: 'POST' })
}
}
export default SJRequest
|
effortcheep/vue3-mobile-template
|
src/store/counter.ts
|
import { defineStore } from 'pinia'
export const useCounterStore = defineStore('counter', {
state() {
return {}
},
getters: {},
actions: {},
})
|
effortcheep/vue3-mobile-template
|
src/service/index.ts
|
<reponame>effortcheep/vue3-mobile-template
import SJRequest from './request'
import { requestInterceptor, responseInterceptor } from './request/interceptors'
const baseURL = import.meta.env.VITE_APP_HOST || 'http://baidu1.com'
const http = new SJRequest({
baseURL,
timeout: 30 * 1000,
interceptors: {
requestInterceptor,
responseInterceptor,
},
})
export default http
|
effortcheep/vue3-mobile-template
|
vite.config.ts
|
<reponame>effortcheep/vue3-mobile-template<filename>vite.config.ts<gh_stars>1-10
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import styleImport, { VantResolve } from 'vite-plugin-style-import'
import viteCompression from 'vite-plugin-compression'
import importToCDN from 'vite-plugin-cdn-import'
import vueJsx from '@vitejs/plugin-vue-jsx'
import WindiCSS from 'vite-plugin-windicss'
import Pages from 'vite-plugin-pages'
import { resolve } from 'path'
// https://vitejs.dev/config/
export default defineConfig({
plugins: [
vue(),
// vant css 自动引入
styleImport({
resolves: [VantResolve()],
}),
// 引入 CDN
importToCDN({
modules: [
{
name: 'vue',
var: 'Vue',
path: 'https://unpkg.com/vue@next',
},
{
name: 'vant',
var: 'vant',
path: 'https://cdn.bootcdn.net/ajax/libs/vant/3.4.1/vant.min.js',
css: 'https://cdn.bootcdn.net/ajax/libs/vant/3.4.1/index.min.css',
},
],
}),
// windicss
WindiCSS(),
// 文件路由
Pages({
dirs: 'src/views',
exclude: ['**/components/*.vue'],
extensions: ['vue', 'md', 'tsx'],
}),
vueJsx(),
// gzip 压缩
viteCompression(),
],
resolve: {
alias: {
'@': resolve(__dirname, 'src'),
},
},
build: {
minify: 'terser',
terserOptions: {
compress: {
drop_debugger: true,
},
},
},
})
|
effortcheep/vue3-mobile-template
|
src/router/router.ts
|
import type { RouteRecordRaw } from 'vue-router'
const pages = import.meta.glob('../views/*/*.vue')
const routes = Object.keys(pages).map(pathToRoute).filter(notEmpty)
export default routes
function notEmpty<T>(value: T | null | undefined): value is T {
return value !== null && value !== undefined
}
function pathToRoute(path: string): RouteRecordRaw | null {
const names = path.match(/\.\.\/views\/(.*)\/(.*)\.vue$/)
if (names && names.length > 1) {
const name = names[1].toLocaleLowerCase()
return {
path: `/${name}`,
name: name,
component: pages[path],
}
}
return null
}
|
pixijs/gif
|
src/AnimatedGIF.ts
|
import { Sprite } from '@pixi/sprite';
import { Texture, Renderer } from '@pixi/core';
import { settings } from '@pixi/settings';
import { SCALE_MODES } from '@pixi/constants';
import { Ticker, UPDATE_PRIORITY } from '@pixi/ticker';
import { parseGIF, decompressFrames } from 'gifuct-js';
/**
* Frame object.
*/
interface FrameObject {
/** Image data for the current frame */
imageData: ImageData;
/** The start of the current frame, in milliseconds */
start: number;
/** How long this frame lasts, in milliseconds */
end: number;
}
/**
* Options for the AnimatedGIF constructor.
*/
interface AnimatedGIFOptions {
/** Whether to start playing right away */
autoPlay: boolean;
/** Scale Mode to use for the texture */
scaleMode: SCALE_MODES;
/** To enable looping */
loop: boolean;
/** Speed of the animation */
animationSpeed: number;
/** Set to `false` to manage updates yourself */
autoUpdate: boolean;
/** The completed callback, optional */
onComplete: () => void;
/** The loop callback, optional */
onLoop: () => void;
/** The frame callback, optional */
onFrameChange: (currentFrame: number) => void;
/** Fallback FPS if GIF contains no time information */
fps?: number;
}
/**
* Runtime object to play animated GIFs. This object is similar to an AnimatedSprite.
* It support playback (seek, play, stop) as well as animation speed and looping.
* @memberof PIXI.gif
* @see Thanks to {@link https://github.com/matt-way/gifuct-js/ gifuct-js}
*/
class AnimatedGIF extends Sprite
{
/**
* Default options for all AnimatedGIF objects.
* @property [scaleMode=SCALE_MODES.LINEAR] {SCALE_MODES} - Scale mode to use for the texture.
* @property [loop=true] {boolean} - To enable looping.
* @property [animationSpeed=1] {number} - Speed of the animation.
* @property [autoUpdate=true] {boolean} - Set to `false` to manage updates yourself.
* @property [autoPlay=true] {boolean} - To start playing right away.
* @property [onComplete=null] {function} - The completed callback, optional.
* @property [onLoop=null] {function} - The loop callback, optional.
* @property [onFrameChange=null] {function} - The frame callback, optional.
*/
public static defaultOptions: AnimatedGIFOptions = {
scaleMode: SCALE_MODES.LINEAR,
fps: Ticker.shared.FPS,
loop: true,
animationSpeed: 1,
autoPlay: true,
autoUpdate: true,
onComplete: null,
onFrameChange: null,
onLoop: null,
};
/**
* The speed that the animation will play at. Higher is faster, lower is slower.
* @default 1
*/
public animationSpeed: number;
/**
* Whether or not the animate sprite repeats after playing.
* @default true
*/
public loop: boolean;
/**
* User-assigned function to call when animation finishes playing. This only happens
* if loop is set to `false`.
*
* @example
* animation.onComplete = () => {
* // finished!
* };
*/
public onComplete?: () => void;
/**
* User-assigned function to call when animation changes which texture is being rendered.
*
* @example
* animation.onFrameChange = () => {
* // updated!
* };
*/
public onFrameChange?: (currentFrame: number) => void;
/**
* User-assigned function to call when `loop` is true, and animation is played and
* loops around to start again. This only happens if loop is set to `true`.
*
* @example
* animation.onLoop = () => {
* // looped!
* };
*/
public onLoop?: () => void;
/** The total duration of animation in milliseconds. */
public readonly duration: number;
/** Whether to play the animation after constructing. */
public readonly autoPlay: boolean;
/** Collection of frame to render. */
private _frames: FrameObject[];
/** Drawing context reference. */
private _context: CanvasRenderingContext2D;
/** Dirty means the image needs to be redrawn. Set to `true` to force redraw. */
public dirty: boolean;
/** The current frame number (zero-based index). */
private _currentFrame: number;
/** `true` uses PIXI.Ticker.shared to auto update animation time.*/
private _autoUpdate: boolean;
/** `true` if the instance is currently connected to PIXI.Ticker.shared to auto update animation time. */
private _isConnectedToTicker: boolean;
/** If animation is currently playing. */
private _playing: boolean;
/** Current playback position in milliseconds. */
private _currentTime: number;
/**
* Create an animated GIF animation from a GIF image's ArrayBuffer. The easiest way to get
* the buffer is to use the Loader.
* @example
* const loader = new PIXI.Loader();
* loader.add('myFile', 'file.gif');
* loader.load((loader, resources) => {
* const gif = resources.myFile.animation;
* // add to the stage...
* });
* @param buffer - GIF image arraybuffer from loader.
* @param options - Options to use.
* @returns
*/
static fromBuffer(buffer: ArrayBuffer, options?: Partial<AnimatedGIFOptions>): AnimatedGIF
{
if (!buffer || buffer.byteLength === 0)
{
throw new Error('Invalid buffer');
}
const gif = parseGIF(buffer);
const gifFrames = decompressFrames(gif, true);
const frames: FrameObject[] = [];
// Temporary canvases required for compositing frames
const canvas = document.createElement('canvas');
const context = canvas.getContext('2d');
const patchCanvas = document.createElement('canvas');
const patchContext = patchCanvas.getContext('2d');
canvas.width = gifFrames[0].dims.width;
canvas.height = gifFrames[0].dims.height;
let time = 0;
// Some GIFs have a non-zero frame delay, so we need to calculate the fallback
const { fps } = Object.assign({}, AnimatedGIF.defaultOptions, options);
const defaultDelay = 1000 / fps;
// Precompute each frame and store as ImageData
for (let i = 0; i < gifFrames.length; i++)
{
// Some GIF's omit the disposalType, so let's assume clear if missing
const { disposalType = 2, delay = defaultDelay, patch, dims: { width, height, left, top } } = gifFrames[i];
patchCanvas.width = width;
patchCanvas.height = height;
patchContext.clearRect(0, 0, width, height);
const patchData = patchContext.createImageData(width, height);
patchData.data.set(patch);
patchContext.putImageData(patchData, 0, 0);
context.drawImage(patchCanvas, left, top);
const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
if (disposalType === 2 || disposalType === 3)
{
context.clearRect(left, top, width, height);
}
frames.push({
start: time,
end: time + delay,
imageData,
});
time += delay;
}
// clear the canvases
canvas.width = canvas.height = 0;
patchCanvas.width = patchCanvas.height = 0;
return new AnimatedGIF(frames, options);
}
/**
* @param buffer - Data of the GIF image.
* @param options - Options for the AnimatedGIF
* @param [options.scaleMode=SCALE_MODES.LINEAR] - How to scale the image.
* @param [options.loop=true] - Whether to loop the animation.
* @param [options.animationSpeed=1] - The speed that the animation will play at.
* @param [options.autoPlay=true] - Whether to start playing the animation right away.
* @param [options.autoUpdate=true] - Whether to use PIXI.Ticker.shared to auto update animation time.
* @param [options.onComplete=null] - Function to call when the animation finishes playing.
* @param [options.onFrameChange=null] - Function to call when the frame changes.
* @param [options.onLoop=null] - Function to call when the animation loops.
*/
constructor(frames: FrameObject[], options?: Partial<AnimatedGIFOptions>)
{
// Get the options, apply defaults
const { scaleMode, ...rest } = Object.assign({},
AnimatedGIF.defaultOptions,
options
);
// Create the texture
const canvas = document.createElement('canvas');
const context = canvas.getContext('2d');
canvas.width = frames[0].imageData.width;
canvas.height = frames[0].imageData.height;
super(Texture.from(canvas, { scaleMode }));
this.duration = frames[frames.length - 1].end;
this._frames = frames;
this._context = context;
this._playing = false;
this._currentTime = 0;
this._isConnectedToTicker = false;
Object.assign(this, rest);
// Draw the first frame
this.currentFrame = 0;
if (this.autoPlay)
{
this.play();
}
}
/** Stops the animation. */
public stop(): void
{
if (!this._playing)
{
return;
}
this._playing = false;
if (this._autoUpdate && this._isConnectedToTicker)
{
Ticker.shared.remove(this.update, this);
this._isConnectedToTicker = false;
}
}
/** Plays the animation. */
public play(): void
{
if (this._playing)
{
return;
}
this._playing = true;
if (this._autoUpdate && !this._isConnectedToTicker)
{
Ticker.shared.add(this.update, this, UPDATE_PRIORITY.HIGH);
this._isConnectedToTicker = true;
}
// If were on the last frame and stopped, play should resume from beginning
if (!this.loop && this.currentFrame === this._frames.length - 1)
{
this._currentTime = 0;
}
}
/**
* Get the current progress of the animation from 0 to 1.
* @readonly
*/
public get progress(): number
{
return this._currentTime / this.duration;
}
/** `true` if the current animation is playing */
public get playing(): boolean
{
return this._playing;
}
/**
* Updates the object transform for rendering. You only need to call this
* if the `autoUpdate` property is set to `false`.
*
* @param deltaTime - Time since last tick.
*/
update(deltaTime: number): void
{
if (!this._playing)
{
return;
}
const elapsed = this.animationSpeed * deltaTime / settings.TARGET_FPMS;
const currentTime = this._currentTime + elapsed;
const localTime = currentTime % this.duration;
const localFrame = this._frames.findIndex((frame) =>
frame.start <= localTime && frame.end > localTime);
if (currentTime >= this.duration)
{
if (this.loop)
{
this._currentTime = localTime;
this.updateFrameIndex(localFrame);
this.onLoop?.();
}
else
{
this._currentTime = this.duration;
this.updateFrameIndex(this._frames.length - 1);
this.onComplete?.();
this.stop();
}
}
else
{
this._currentTime = localTime;
this.updateFrameIndex(localFrame);
}
}
/**
* Redraw the current frame, is necessary for the animation to work when
*/
private updateFrame(): void
{
if (!this.dirty)
{
return;
}
// Update the current frame
const { imageData } = this._frames[this._currentFrame];
this._context.putImageData(imageData, 0, 0);
// Workaround hack for Safari & iOS
// which fails to upload canvas after putImageData
// See: https://bugs.webkit.org/show_bug.cgi?id=229986
this._context.fillStyle = 'transparent';
this._context.fillRect(0, 0, 0, 1);
this.texture.update();
// Mark as clean
this.dirty = false;
}
/**
* Renders the object using the WebGL renderer
*
* @param {PIXI.Renderer} renderer - The renderer
* @private
*/
_render(renderer: Renderer): void
{
this.updateFrame();
super._render(renderer);
}
/**
* Renders the object using the WebGL renderer
*
* @param {PIXI.CanvasRenderer} renderer - The renderer
* @private
*/
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
_renderCanvas(renderer: any): void
{
this.updateFrame();
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
super._renderCanvas(renderer);
}
/**
* Whether to use PIXI.Ticker.shared to auto update animation time.
* @default true
*/
get autoUpdate(): boolean
{
return this._autoUpdate;
}
set autoUpdate(value: boolean)
{
if (value !== this._autoUpdate)
{
this._autoUpdate = value;
if (!this._autoUpdate && this._isConnectedToTicker)
{
Ticker.shared.remove(this.update, this);
this._isConnectedToTicker = false;
}
else if (this._autoUpdate && !this._isConnectedToTicker && this._playing)
{
Ticker.shared.add(this.update, this);
this._isConnectedToTicker = true;
}
}
}
/** Set the current frame number */
get currentFrame(): number
{
return this._currentFrame;
}
set currentFrame(value: number)
{
this.updateFrameIndex(value);
this._currentTime = this._frames[value].start;
}
/** Internally handle updating the frame index */
private updateFrameIndex(value: number): void
{
if (value < 0 || value >= this._frames.length)
{
throw new Error(`Frame index out of range, expecting 0 to ${this.totalFrames}, got ${value}`);
}
if (this._currentFrame !== value)
{
this._currentFrame = value;
this.dirty = true;
this.onFrameChange?.(value);
}
}
/**
* Get the total number of frame in the GIF.
*/
get totalFrames(): number
{
return this._frames.length;
}
/** Destroy and don't use after this. */
destroy(): void
{
this.stop();
super.destroy(true);
this._context = null;
this._frames = null;
this.onComplete = null;
this.onFrameChange = null;
this.onLoop = null;
}
/**
* Cloning the animation is a useful way to create a duplicate animation.
* This maintains all the properties of the original animation but allows
* you to control playback independent of the original animation.
* If you want to create a simple copy, and not control independently,
* then you can simply create a new Sprite, e.g. `const sprite = new Sprite(animation.texture)`.
*/
clone(): AnimatedGIF
{
return new AnimatedGIF([...this._frames], {
autoUpdate: this._autoUpdate,
loop: this.loop,
autoPlay: this.autoPlay,
scaleMode: this.texture.baseTexture.scaleMode,
animationSpeed: this.animationSpeed,
onComplete: this.onComplete,
onFrameChange: this.onFrameChange,
onLoop: this.onLoop,
});
}
}
export { AnimatedGIF };
export type { AnimatedGIFOptions };
|
pixijs/gif
|
test/AnimatedGIF.tests.ts
|
import { AnimatedGIF } from '../src';
import fs from 'fs';
import { expect } from 'chai';
import path from 'path';
function toArrayBuffer(buffer: Buffer): ArrayBuffer
{
const ab = new ArrayBuffer(buffer.length);
const view = new Uint8Array(ab);
for (let i = 0; i < buffer.length; ++i)
{
view[i] = buffer[i];
}
return ab;
}
describe('AnimatedGIF', function ()
{
before(async function ()
{
this.arrayBuffer = toArrayBuffer(
await fs.promises.readFile(path.join(__dirname, './resources/example.gif'))
);
});
after(function ()
{
this.arrayBuffer = null;
});
describe('fromBuffer()', function ()
{
it('should return an instance of AnimatedGIF', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer);
expect(animation).to.be.an.instanceof(AnimatedGIF);
animation.destroy();
});
it('should throw an error if missing', function ()
{
expect(() => (AnimatedGIF as any).fromBuffer()).to.throw();
expect(() => (AnimatedGIF as any).fromBuffer(new ArrayBuffer(0))).to.throw();
});
it('should handle options', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer, {
autoPlay: false,
loop: false,
autoUpdate: false,
});
expect(animation.loop).equals(false);
expect(animation.autoPlay).equals(false);
expect(animation.autoUpdate).equals(false);
animation.destroy();
});
});
describe('currentFrame', function ()
{
it('should throw frames out-of-bounds', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer);
expect(() => animation.currentFrame = -1).to.throw();
expect(() => animation.currentFrame = animation.totalFrames).to.throw();
animation.destroy();
});
it('should change dirty current frame', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer, { autoPlay: false });
animation.dirty = false;
animation.currentFrame = 0;
expect(animation.dirty).equals(false);
animation.currentFrame = 1;
expect(animation.dirty).equals(true);
animation.destroy();
});
});
describe('play()', function ()
{
it('should do nothing when playing twice', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer);
expect(animation.playing).equals(true);
animation.play();
animation.play();
expect(animation.playing).equals(true);
animation.destroy();
});
it('should change play state', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer, { autoPlay: false });
expect(animation.playing).equals(false);
animation.play();
expect(animation.playing).equals(true);
animation.destroy();
});
});
describe('stop()', function ()
{
it('should stop playing', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer);
expect(animation.playing).equals(true);
animation.stop();
expect(animation.playing).equals(false);
animation.destroy();
});
it('should stop playing on destroy', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer);
expect(animation.playing).equals(true);
animation.destroy();
expect(animation.playing).equals(false);
});
});
describe('clone()', function ()
{
it('should clone the original', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer);
const clone = animation.clone();
expect(clone).to.be.an.instanceof(AnimatedGIF);
expect(clone.totalFrames).equals(animation.totalFrames);
expect(clone.duration).equals(animation.duration);
animation.destroy();
clone.destroy();
});
it('should clone the original preserving options', function ()
{
this.slow(500);
const options = {
autoPlay: false,
loop: false,
autoUpdate: false,
animationSpeed: 0.5,
onComplete: () => {},
onLoop: () => {},
onFrameChange: () => {},
};
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer, options);
const clone = animation.clone();
expect(clone).to.be.an.instanceof(AnimatedGIF);
expect(clone.playing).equals(false);
expect(clone.loop).equals(animation.loop);
expect(clone.autoPlay).equals(animation.autoPlay);
expect(clone.autoUpdate).equals(animation.autoUpdate);
expect(clone.onComplete).equals(animation.onComplete);
expect(clone.animationSpeed).equals(animation.animationSpeed);
expect(clone.onLoop).equals(animation.onLoop);
expect(clone.onFrameChange).equals(animation.onFrameChange);
animation.destroy();
clone.destroy();
});
it('should not preserve play status', function ()
{
this.slow(500);
const animation = AnimatedGIF.fromBuffer(this.arrayBuffer);
animation.stop();
expect(animation.playing).equals(false);
const clone = animation.clone();
expect(clone.playing).equals(true);
animation.destroy();
clone.destroy();
});
});
});
|
pixijs/gif
|
global.d.ts
|
declare namespace GlobalMixins
{
interface LoaderResource
{
/** Texture reference for loading images and other textures. */
animation?: import('./').AnimatedGIF;
}
}
|
pixijs/gif
|
scripts/fix-types.ts
|
import fs from 'fs';
import path from 'path';
const prepend = `/// <reference path="./global.d.ts" />`;
// Patch global.d.ts into the api-extractor output
// because api doesn't support exporting global definitions (ambient types)
(async () =>
{
const typesFile = path.resolve(__dirname, '../index.d.ts');
const buffer = await fs.promises.readFile(typesFile, 'utf8');
if (!buffer.startsWith(prepend))
{
await fs.promises.writeFile(typesFile, `${prepend}\n${buffer}`);
// eslint-disable-next-line no-console
console.log('Patched types.');
}
else
{
// eslint-disable-next-line no-console
console.log('Types already patched.');
}
})();
|
pixijs/gif
|
test/AnimatedGIFLoader.tests.ts
|
<gh_stars>10-100
import { AnimatedGIFLoader, AnimatedGIF } from '../src';
import { expect } from 'chai';
import { Loader } from '@pixi/loaders';
import { createServer } from './resources';
describe('AnimatedGIFLoader', function ()
{
before(function ()
{
Loader.registerPlugin(AnimatedGIFLoader);
this.server = createServer(54311);
this.baseUrl = 'http://localhost:54311';
});
after(function ()
{
this.server.close();
this.server = null;
this.baseUrl = null;
});
describe('use', function ()
{
it('should have a loader', function ()
{
expect(AnimatedGIFLoader).to.be.a('object');
});
it('should load a gif file', function (done)
{
this.slow(1000);
const loader = new Loader();
const url = `${this.baseUrl}/example.gif`;
loader.add('test', url);
loader.load(() =>
{
expect(loader.resources.test);
expect(loader.resources.test.data).to.be.instanceOf(ArrayBuffer);
expect(loader.resources.test.animation).to.be.instanceOf(AnimatedGIF);
// Check for default values
const { animation } = loader.resources.test;
expect(animation.loop).to.be.true;
expect(animation.currentFrame).equals(0);
expect(animation.autoUpdate).to.be.true;
expect(animation.playing).to.be.true;
expect(animation.totalFrames).greaterThan(0);
expect(animation.progress).equals(0);
expect(animation.width).greaterThan(0);
expect(animation.height).greaterThan(0);
expect(animation.onComplete).equals(null);
expect(animation.onFrameChange).equals(null);
expect(animation.onLoop).equals(null);
loader.destroy();
done();
});
});
});
});
|
pixijs/gif
|
src/index.ts
|
<gh_stars>10-100
/**
* @namespace PIXI
*/
/**
* @namespace PIXI.gif
*/
export * from './AnimatedGIFLoader';
export * from './AnimatedGIF';
|
pixijs/gif
|
src/AnimatedGIFLoader.ts
|
<filename>src/AnimatedGIFLoader.ts<gh_stars>10-100
import { LoaderResource } from '@pixi/loaders';
import type { ILoaderPlugin } from '@pixi/loaders';
import { AnimatedGIF } from './AnimatedGIF';
/** Default extension for GIF images */
const GIF_EXTENSION = 'gif';
// Satsify the LoaderResource interface
declare global {
// eslint-disable-next-line @typescript-eslint/no-namespace
namespace GlobalMixins {
interface LoaderResource {
animation?: AnimatedGIF;
}
}
}
/**
* Handle the loading of GIF images. Registering this loader plugin will
* load all `.gif` images as an ArrayBuffer and transform into an
* AnimatedGIF object. Use Resource's `animation` property to access the object.
* @memberof PIXI.gif
* @class AnimatedGIFLoader
* @example
* import { Loader } from '@pixi/loaders';
* import { AnimatedGIFLoader } from '@pixi/gif';
*
* Loader.registerPlugin(AnimatedGIFLoader);
*/
const AnimatedGIFLoader: ILoaderPlugin = {
/** For loading methods */
add()
{
LoaderResource.setExtensionXhrType(
GIF_EXTENSION,
LoaderResource.XHR_RESPONSE_TYPE.BUFFER
);
LoaderResource.setExtensionLoadType(
GIF_EXTENSION,
LoaderResource.LOAD_TYPE.XHR
);
},
/** Implement loader */
use(resource: LoaderResource, next: (...args: any[]) => void): void
{
if (resource.extension === GIF_EXTENSION)
{
resource.animation = AnimatedGIF.fromBuffer(resource.data);
}
next();
}
};
export { AnimatedGIFLoader };
|
pixijs/gif
|
test/resources/index.ts
|
<reponame>pixijs/gif<filename>test/resources/index.ts
/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
import * as http from 'http';
import * as fs from 'fs';
import * as path from 'path';
const mimeTypes: Record<string, string> = {
'.gif': 'image/gif',
};
/**
* Very HTTP server to requesting files.
*/
const createServer = (port: number) =>
{
const server = http.createServer((request, response) =>
{
const filePath = path.join(__dirname, request.url);
const extname = path.extname(filePath);
const contentType = mimeTypes[extname] || 'text/html';
const stream = fs.createReadStream(filePath);
stream.once('open', () =>
{
response.writeHead(200, { 'Content-Type': contentType });
stream.pipe(response);
});
stream.once('error', (error) =>
{
response.writeHead(404);
response.end(`File not found: ${error.code} ..\n`);
response.end();
});
});
server.listen(port);
return server;
};
export { createServer };
|
pixijs/gif
|
test/index.ts
|
import './AnimatedGIF.tests';
import './AnimatedGIFLoader.tests';
|
0xBeaver/snarkswap-client
|
src/lib/swap.spec.ts
|
<gh_stars>1-10
import test from 'ava';
import { toWei } from 'web3-utils';
import { Note } from './note';
import { hideSwap, SwapType } from './swap';
import { privToPubKey } from './utils';
test('hideSwap & verifySwap', async (t) => {
const privKey =
'1020304050607080900010203040506070809000102030405060708090001';
const pubKey = privToPubKey(privKey);
const DAI = '0x6b175474e89094c44da98b954eedeac495271d0f';
const WETH = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
// value @ 1614930738
const reserve0 = '63639638836841424649744903';
const reserve1 = '43372742079468723273929';
const sourceA: Note = {
address: WETH,
amount: toWei('50000'),
pubKey,
salt: 1,
};
const sourceB: Note = {
address: DAI,
amount: toWei('10000000'),
pubKey,
salt: 2,
};
const result = await hideSwap(
privKey,
reserve0,
reserve1,
sourceA,
sourceB,
DAI,
WETH,
toWei('5000000'),
SwapType.Token0In,
{ numerator: 3, denominator: 1000 },
16
);
t.log(result);
t.not(result, undefined);
});
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.