type
stringclasses 7
values | content
stringlengths 4
9.55k
| repo
stringlengths 7
96
| path
stringlengths 4
178
| language
stringclasses 1
value |
|---|---|---|---|---|
ArrowFunction |
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<VerifySecurityPhraseResponse>;
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: StrictHttpResponse<VerifySecurityPhraseResponse>) => r.body as VerifySecurityPhraseResponse | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<Blob>;
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: StrictHttpResponse<Blob>) => r.body as Blob | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<SearchResults>;
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: StrictHttpResponse<SearchResults>) => r.body as SearchResults | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<Array<RegistrantProfile>>;
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: StrictHttpResponse<Array<RegistrantProfile>>) => r.body as Array<RegistrantProfile> | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: HttpResponse<any>) => {
return r as StrictHttpResponse<Array<EvacuationFileSearchResult>>;
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
ArrowFunction |
(r: StrictHttpResponse<Array<EvacuationFileSearchResult>>) => r.body as Array<EvacuationFileSearchResult> | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Gets a Registrant Profile.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsGetRegistrantProfile()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetRegistrantProfile$Response(params: {
/**
* RegistrantId
*/
registrantId: string;
}): Observable<StrictHttpResponse<RegistrantProfile>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsGetRegistrantProfilePath, 'get');
if (params) {
rb.path('registrantId', params.registrantId, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrantProfile>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Gets a Registrant Profile.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsGetRegistrantProfile$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetRegistrantProfile(params: {
/**
* RegistrantId
*/
registrantId: string;
}): Observable<RegistrantProfile> {
return this.registrationsGetRegistrantProfile$Response(params).pipe(
map((r: StrictHttpResponse<RegistrantProfile>) => r.body as RegistrantProfile)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Updates a Registrant Profile.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsUpdateRegistrantProfile()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsUpdateRegistrantProfile$Response(params: {
/**
* RegistrantId
*/
registrantId: string;
/**
* Registrant
*/
body: RegistrantProfile
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsUpdateRegistrantProfilePath, 'post');
if (params) {
rb.path('registrantId', params.registrantId, {});
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Updates a Registrant Profile.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsUpdateRegistrantProfile$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsUpdateRegistrantProfile(params: {
/**
* RegistrantId
*/
registrantId: string;
/**
* Registrant
*/
body: RegistrantProfile
}): Observable<RegistrationResult> {
return this.registrationsUpdateRegistrantProfile$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Creates a Registrant Profile.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsCreateRegistrantProfile()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsCreateRegistrantProfile$Response(params: {
/**
* Registrant
*/
body: RegistrantProfile
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsCreateRegistrantProfilePath, 'post');
if (params) {
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Creates a Registrant Profile.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsCreateRegistrantProfile$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsCreateRegistrantProfile(params: {
/**
* Registrant
*/
body: RegistrantProfile
}): Observable<RegistrationResult> {
return this.registrationsCreateRegistrantProfile$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Sets the Registrant Profile Verified flag to the supplied value.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsSetRegistrantVerified()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSetRegistrantVerified$Response(params: {
/**
* RegistrantId
*/
registrantId: string;
/**
* Verified
*/
verified: boolean;
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsSetRegistrantVerifiedPath, 'post');
if (params) {
rb.path('registrantId', params.registrantId, {});
rb.path('verified', params.verified, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Sets the Registrant Profile Verified flag to the supplied value.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsSetRegistrantVerified$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSetRegistrantVerified(params: {
/**
* RegistrantId
*/
registrantId: string;
/**
* Verified
*/
verified: boolean;
}): Observable<RegistrationResult> {
return this.registrationsSetRegistrantVerified$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Get security questions for a registrant.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsGetSecurityQuestions()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetSecurityQuestions$Response(params: {
/**
* registrant id
*/
registrantId: string;
}): Observable<StrictHttpResponse<GetSecurityQuestionsResponse>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsGetSecurityQuestionsPath, 'get');
if (params) {
rb.path('registrantId', params.registrantId, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<GetSecurityQuestionsResponse>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Get security questions for a registrant.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsGetSecurityQuestions$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetSecurityQuestions(params: {
/**
* registrant id
*/
registrantId: string;
}): Observable<GetSecurityQuestionsResponse> {
return this.registrationsGetSecurityQuestions$Response(params).pipe(
map((r: StrictHttpResponse<GetSecurityQuestionsResponse>) => r.body as GetSecurityQuestionsResponse)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* verify answers for security questions.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsVerifySecurityQuestions()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsVerifySecurityQuestions$Response(params: {
/**
* registrant id
*/
registrantId: string;
/**
* array of questions and their answers
*/
body: VerifySecurityQuestionsRequest
}): Observable<StrictHttpResponse<VerifySecurityQuestionsResponse>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsVerifySecurityQuestionsPath, 'post');
if (params) {
rb.path('registrantId', params.registrantId, {});
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<VerifySecurityQuestionsResponse>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* verify answers for security questions.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsVerifySecurityQuestions$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsVerifySecurityQuestions(params: {
/**
* registrant id
*/
registrantId: string;
/**
* array of questions and their answers
*/
body: VerifySecurityQuestionsRequest
}): Observable<VerifySecurityQuestionsResponse> {
return this.registrationsVerifySecurityQuestions$Response(params).pipe(
map((r: StrictHttpResponse<VerifySecurityQuestionsResponse>) => r.body as VerifySecurityQuestionsResponse)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Gets a File.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsGetFile()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetFile$Response(params: {
/**
* fileId
*/
fileId: string;
}): Observable<StrictHttpResponse<EvacuationFile>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsGetFilePath, 'get');
if (params) {
rb.path('fileId', params.fileId, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<EvacuationFile>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Gets a File.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsGetFile$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetFile(params: {
/**
* fileId
*/
fileId: string;
}): Observable<EvacuationFile> {
return this.registrationsGetFile$Response(params).pipe(
map((r: StrictHttpResponse<EvacuationFile>) => r.body as EvacuationFile)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Updates a File.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsUpdateFile()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsUpdateFile$Response(params: {
/**
* fileId
*/
fileId: string;
/**
* file
*/
body: EvacuationFile
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsUpdateFilePath, 'post');
if (params) {
rb.path('fileId', params.fileId, {});
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Updates a File.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsUpdateFile$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsUpdateFile(params: {
/**
* fileId
*/
fileId: string;
/**
* file
*/
body: EvacuationFile
}): Observable<RegistrationResult> {
return this.registrationsUpdateFile$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Search files.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsGetFiles()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetFiles$Response(params?: {
/**
* fileId
*/
registrantId?: string;
}): Observable<StrictHttpResponse<Array<EvacuationFileSummary>>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsGetFilesPath, 'get');
if (params) {
rb.query('registrantId', params.registrantId, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<Array<EvacuationFileSummary>>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Search files.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsGetFiles$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetFiles(params?: {
/**
* fileId
*/
registrantId?: string;
}): Observable<Array<EvacuationFileSummary>> {
return this.registrationsGetFiles$Response(params).pipe(
map((r: StrictHttpResponse<Array<EvacuationFileSummary>>) => r.body as Array<EvacuationFileSummary>)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Creates a File.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsCreateFile()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsCreateFile$Response(params: {
/**
* file
*/
body: EvacuationFile
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsCreateFilePath, 'post');
if (params) {
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Creates a File.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsCreateFile$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsCreateFile(params: {
/**
* file
*/
body: EvacuationFile
}): Observable<RegistrationResult> {
return this.registrationsCreateFile$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Create a File Note.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsCreateFileNote()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsCreateFileNote$Response(params: {
/**
* fileId
*/
fileId: string;
/**
* note
*/
body: Note
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsCreateFileNotePath, 'post');
if (params) {
rb.path('fileId', params.fileId, {});
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Create a File Note.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsCreateFileNote$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsCreateFileNote(params: {
/**
* fileId
*/
fileId: string;
/**
* note
*/
body: Note
}): Observable<RegistrationResult> {
return this.registrationsCreateFileNote$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Updates a File Note's content.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsUpdateFileNoteContent()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsUpdateFileNoteContent$Response(params: {
/**
* fileId
*/
fileId: string;
/**
* noteId
*/
noteId: string;
/**
* note
*/
body: Note
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsUpdateFileNoteContentPath, 'post');
if (params) {
rb.path('fileId', params.fileId, {});
rb.path('noteId', params.noteId, {});
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Updates a File Note's content.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsUpdateFileNoteContent$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsUpdateFileNoteContent(params: {
/**
* fileId
*/
fileId: string;
/**
* noteId
*/
noteId: string;
/**
* note
*/
body: Note
}): Observable<RegistrationResult> {
return this.registrationsUpdateFileNoteContent$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Sets a File Note's isHidden field.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsSetFileNoteHiddenStatus()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSetFileNoteHiddenStatus$Response(params: {
/**
* fileId
*/
fileId: string;
/**
* noteId
*/
noteId: string;
/**
* isHidden
*/
isHidden?: boolean;
}): Observable<StrictHttpResponse<RegistrationResult>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsSetFileNoteHiddenStatusPath, 'post');
if (params) {
rb.path('fileId', params.fileId, {});
rb.path('noteId', params.noteId, {});
rb.query('isHidden', params.isHidden, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<RegistrationResult>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Sets a File Note's isHidden field.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsSetFileNoteHiddenStatus$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSetFileNoteHiddenStatus(params: {
/**
* fileId
*/
fileId: string;
/**
* noteId
*/
noteId: string;
/**
* isHidden
*/
isHidden?: boolean;
}): Observable<RegistrationResult> {
return this.registrationsSetFileNoteHiddenStatus$Response(params).pipe(
map((r: StrictHttpResponse<RegistrationResult>) => r.body as RegistrationResult)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* get the security phrase of an evacuation file.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsGetSecurityPhrase()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetSecurityPhrase$Response(params: {
/**
* file id
*/
fileId: string;
}): Observable<StrictHttpResponse<GetSecurityPhraseResponse>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsGetSecurityPhrasePath, 'get');
if (params) {
rb.path('fileId', params.fileId, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<GetSecurityPhraseResponse>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* get the security phrase of an evacuation file.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsGetSecurityPhrase$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsGetSecurityPhrase(params: {
/**
* file id
*/
fileId: string;
}): Observable<GetSecurityPhraseResponse> {
return this.registrationsGetSecurityPhrase$Response(params).pipe(
map((r: StrictHttpResponse<GetSecurityPhraseResponse>) => r.body as GetSecurityPhraseResponse)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* verify an evacuation file's security phrase.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsVerifySecurityPhrase()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsVerifySecurityPhrase$Response(params: {
/**
* file id
*/
fileId: string;
/**
* security phrase to verify
*/
body: VerifySecurityPhraseRequest
}): Observable<StrictHttpResponse<VerifySecurityPhraseResponse>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsVerifySecurityPhrasePath, 'post');
if (params) {
rb.path('fileId', params.fileId, {});
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<VerifySecurityPhraseResponse>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* verify an evacuation file's security phrase.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsVerifySecurityPhrase$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsVerifySecurityPhrase(params: {
/**
* file id
*/
fileId: string;
/**
* security phrase to verify
*/
body: VerifySecurityPhraseRequest
}): Observable<VerifySecurityPhraseResponse> {
return this.registrationsVerifySecurityPhrase$Response(params).pipe(
map((r: StrictHttpResponse<VerifySecurityPhraseResponse>) => r.body as VerifySecurityPhraseResponse)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsLinkRegistrantToHouseholdMember()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsLinkRegistrantToHouseholdMember$Response(params: {
fileId: string;
body: RegistrantLinkRequest
}): Observable<StrictHttpResponse<Blob>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsLinkRegistrantToHouseholdMemberPath, 'post');
if (params) {
rb.path('fileId', params.fileId, {});
rb.body(params.body, 'application/json');
}
return this.http.request(rb.build({
responseType: 'blob',
accept: 'application/octet-stream'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<Blob>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsLinkRegistrantToHouseholdMember$Response()` instead.
*
* This method sends `application/json` and handles request body of type `application/json`.
*/
registrationsLinkRegistrantToHouseholdMember(params: {
fileId: string;
body: RegistrantLinkRequest
}): Observable<Blob> {
return this.registrationsLinkRegistrantToHouseholdMember$Response(params).pipe(
map((r: StrictHttpResponse<Blob>) => r.body as Blob)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Search evacuation files and profiles matching the search parameters.
*
*
*
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsSearch()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSearch$Response(params?: {
firstName?: string;
lastName?: string;
dateOfBirth?: string;
}): Observable<StrictHttpResponse<SearchResults>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsSearchPath, 'get');
if (params) {
rb.query('firstName', params.firstName, {});
rb.query('lastName', params.lastName, {});
rb.query('dateOfBirth', params.dateOfBirth, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<SearchResults>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* Search evacuation files and profiles matching the search parameters.
*
*
*
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsSearch$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSearch(params?: {
firstName?: string;
lastName?: string;
dateOfBirth?: string;
}): Observable<SearchResults> {
return this.registrationsSearch$Response(params).pipe(
map((r: StrictHttpResponse<SearchResults>) => r.body as SearchResults)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsSearchMatchingRegistrants()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSearchMatchingRegistrants$Response(params?: {
firstName?: string;
lastName?: string;
dateOfBirth?: string;
}): Observable<StrictHttpResponse<Array<RegistrantProfile>>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsSearchMatchingRegistrantsPath, 'get');
if (params) {
rb.query('firstName', params.firstName, {});
rb.query('lastName', params.lastName, {});
rb.query('dateOfBirth', params.dateOfBirth, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<Array<RegistrantProfile>>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsSearchMatchingRegistrants$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSearchMatchingRegistrants(params?: {
firstName?: string;
lastName?: string;
dateOfBirth?: string;
}): Observable<Array<RegistrantProfile>> {
return this.registrationsSearchMatchingRegistrants$Response(params).pipe(
map((r: StrictHttpResponse<Array<RegistrantProfile>>) => r.body as Array<RegistrantProfile>)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* This method provides access to the full `HttpResponse`, allowing access to response headers.
* To access only the response body, use `registrationsSearchMatchingEvacuationFiles()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSearchMatchingEvacuationFiles$Response(params?: {
firstName?: string;
lastName?: string;
dateOfBirth?: string;
}): Observable<StrictHttpResponse<Array<EvacuationFileSearchResult>>> {
const rb = new RequestBuilder(this.rootUrl, RegistrationsService.RegistrationsSearchMatchingEvacuationFilesPath, 'get');
if (params) {
rb.query('firstName', params.firstName, {});
rb.query('lastName', params.lastName, {});
rb.query('dateOfBirth', params.dateOfBirth, {});
}
return this.http.request(rb.build({
responseType: 'json',
accept: 'application/json'
})).pipe(
filter((r: any) => r instanceof HttpResponse),
map((r: HttpResponse<any>) => {
return r as StrictHttpResponse<Array<EvacuationFileSearchResult>>;
})
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
MethodDeclaration | /**
* This method provides access to only to the response body.
* To access the full response (for headers, for example), `registrationsSearchMatchingEvacuationFiles$Response()` instead.
*
* This method doesn't expect any request body.
*/
registrationsSearchMatchingEvacuationFiles(params?: {
firstName?: string;
lastName?: string;
dateOfBirth?: string;
}): Observable<Array<EvacuationFileSearchResult>> {
return this.registrationsSearchMatchingEvacuationFiles$Response(params).pipe(
map((r: StrictHttpResponse<Array<EvacuationFileSearchResult>>) => r.body as Array<EvacuationFileSearchResult>)
);
} | SodhiA1/embc-ess-mod | responders/src/UI/embc-responder/src/app/core/api/services/registrations.service.ts | TypeScript |
InterfaceDeclaration |
export interface ISentinelValidatorDelegate {
(): ISentinelValidatorFn;
} | yield-wf/sentinel | src/interfaces/sentinel-validator-delegate.ts | TypeScript |
ClassDeclaration |
@Component({
selector: 'ngx-update-timetables',
templateUrl: './update-timetables.component.html',
styleUrls: ['./update-timetables.component.scss']
})
export class UpdateTimetablesComponent implements OnInit {
constructor() { }
ngOnInit() {
}
} | vinayaknode2017/TTM | src/app/pages/timetables/update-timetables/update-timetables.component.ts | TypeScript |
ClassDeclaration |
@Schema({ timestamps: true, _id: false })
export class Rating {
@Prop()
rate: number;
@Prop()
comments: string;
@Prop()
accounted: boolean;
@Prop()
createdAt: Date;
} | LuisAlbertoPerezDeLaCruz/parolie-api | src/reservations/schemas/rating.schema.ts | TypeScript |
ArrowFunction |
() => {
observable.logUnsubscribedFrame(index);
} | Guardiannw/RxJS | src/testing/ColdObservable.ts | TypeScript |
ArrowFunction |
({message, subscriber}) => { message.notification.observe(subscriber); } | Guardiannw/RxJS | src/testing/ColdObservable.ts | TypeScript |
ClassDeclaration |
export class ColdObservable<T> extends Observable<T> implements SubscriptionLoggable {
public subscriptions: SubscriptionLog[] = [];
scheduler: Scheduler;
logSubscribedFrame: () => number;
logUnsubscribedFrame: (index: number) => void;
constructor(public messages: TestMessage[],
scheduler: Scheduler) {
super(function (subscriber: Subscriber<any>) {
const observable: ColdObservable<T> = this;
const index = observable.logSubscribedFrame();
subscriber.add(new Subscription(() => {
observable.logUnsubscribedFrame(index);
}));
observable.scheduleMessages(subscriber);
return subscriber;
});
this.scheduler = scheduler;
}
scheduleMessages(subscriber: Subscriber<any>) {
const messagesLength = this.messages.length;
for (let i = 0; i < messagesLength; i++) {
const message = this.messages[i];
subscriber.add(
this.scheduler.schedule(({message, subscriber}) => { message.notification.observe(subscriber); },
message.frame,
{message, subscriber})
);
}
}
} | Guardiannw/RxJS | src/testing/ColdObservable.ts | TypeScript |
MethodDeclaration |
scheduleMessages(subscriber: Subscriber<any>) {
const messagesLength = this.messages.length;
for (let i = 0; i < messagesLength; i++) {
const message = this.messages[i];
subscriber.add(
this.scheduler.schedule(({message, subscriber}) => { message.notification.observe(subscriber); },
message.frame,
{message, subscriber})
);
}
} | Guardiannw/RxJS | src/testing/ColdObservable.ts | TypeScript |
ArrowFunction |
(name: string): string | undefined => {
let result: string | undefined = undefined;
if (typeof this.options.colorMap === 'function') {
result = this.options.colorMap(name);
}
if (!result) result = defaultColorMap(name);
return result;
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(name: string): string | undefined => {
let result: string | undefined = undefined;
if (typeof this.options.backgroundColorMap === 'function') {
result = this.options.backgroundColorMap(name);
}
if (!result && typeof this.options.colorMap === 'function') {
result = this.options.colorMap(name);
}
if (!result) result = defaultBackgroundColorMap(name);
return result;
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(command) => this.executeCommand(command) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(text: string): void => onTypedText(this, text) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(ev: ClipboardEvent) => {
// Ignore if in read-only mode
if (this.options.readOnly) {
this.model.announce('plonk');
return;
}
// Snapshot the undo state
this.snapshot();
// Copy to the clipboard
ModeEditor.onCopy(this, ev);
// Clearing the selection will have the side effect of clearing the
// content of the textarea. However, the textarea value is what will
// be copied to the clipboard (in some cases), so defer the clearing of the selection
// to later, after the cut operation has been handled.
setTimeout(() => {
deleteRange(this.model, range(this.model.selection));
requestUpdate(this);
}, 0);
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => {
deleteRange(this.model, range(this.model.selection));
requestUpdate(this);
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(ev: ClipboardEvent) => ModeEditor.onCopy(this, ev) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(ev: ClipboardEvent) => {
// Ignore if in read-only mode
if (this.options.readOnly) {
this.model.announce('plonk');
return;
}
ModeEditor.onPaste(this.model.at(this.model.position).mode, this, ev);
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(keystroke, event) => onKeystroke(this, keystroke, event) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(composition: string) =>
this.onCompositionStart(composition) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(composition: string) =>
this.onCompositionUpdate(composition) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(composition: string) =>
this.onCompositionEnd(composition) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender: ModelPrivate): void =>
this.options.onContentDidChange(this) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender: ModelPrivate): void =>
this._onSelectionDidChange() | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(): void => this.options.onContentWillChange(this) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(): void =>
this.options.onSelectionWillChange(this) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(
_sender: ModelPrivate,
placeholderId: string
): void => this.options.onPlaceholderDidChange(this, placeholderId) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(
_sender: Mathfield,
command: string,
previousPosition: number,
atoms: Atom[]
): void =>
this.options.onAnnounce?.(this, command, previousPosition, atoms) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender, direction): boolean =>
this.options.onMoveOutOf(this, direction) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender, direction): boolean =>
this.options.onTabOutOf(this, direction) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender: ModelPrivate) =>
this.options.onContentDidChange(this) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender: ModelPrivate) =>
this._onSelectionDidChange() | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => this.options.onContentWillChange(this) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => this.options.onSelectionWillChange(this) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender, placeholderId) =>
this.options.onPlaceholderDidChange(this, placeholderId) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(
_sender: Mathfield,
command: string,
previousPosition: number | undefined,
atoms: Atom[]
) => this.options.onAnnounce?.(this, command, previousPosition, atoms) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender, direction) =>
this.options.onMoveOutOf(this, direction) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender, direction) => this.options.onTabOutOf(this, direction) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => render(this) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(e) => {
if (typeof this.options.onError === 'function') {
this.options.onError({
code: 'invalid-keybinding',
arg: e.join('\n'),
});
}
console.error(e.join('\n'));
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(_sender: Mathfield, command, previousPosition, atoms) =>
this.options.onAnnounce?.(this, command, previousPosition, atoms) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => isValidMathfield(this) && this.onResize() | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(x) => x?.release() | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => {
this.resetKeystrokeBuffer();
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(): boolean => {
let contentChanged = false;
this.resetKeystrokeBuffer();
// Suppress (temporarily) smart mode if switching to/from text or math
// This prevents switching to/from command mode from suppressing smart mode.
this.smartModeSuppressed =
/text|math/.test(this.mode) && /text|math/.test(mode);
if (prefix && mode !== 'latex') {
const atoms = parseLatex(prefix, {
parseMode: { math: 'text', text: 'math' }[mode as ParseMode],
});
model.collapseSelection('forward');
const cursor = model.at(model.position);
model.position = model.offsetOf(
cursor.parent!.addChildrenAfter(atoms, cursor)
);
contentChanged = true;
}
this.mode = mode;
if (mode === 'latex') {
let wasCollapsed = model.selectionIsCollapsed;
// We can have only a single latex group at a time.
// If a latex group is open, close it first
complete(this, 'accept');
// Switch to the command mode keyboard layer
if (this.virtualKeyboard?.visible) {
this.executeCommand(['switchKeyboardLayer', 'latex-lower']);
}
// Insert a latex group atom
let latex: string;
let cursor = model.at(model.position);
if (wasCollapsed) {
latex = '\\';
} else {
const selRange = range(model.selection);
latex = this.model.getValue(selRange, 'latex');
const extractedAtoms = this.model.extractAtoms(selRange);
if (
extractedAtoms.length === 1 &&
extractedAtoms[0] instanceof PlaceholderAtom
) {
// If we just had a placeholder selected, pretend we had an empty
// selection
latex = prefix;
wasCollapsed = true;
}
cursor = model.at(selRange[0]);
}
const atom = new LatexGroupAtom(latex);
cursor.parent!.addChildAfter(atom, cursor);
if (wasCollapsed) {
model.position = model.offsetOf(atom.lastChild);
} else {
model.setSelection(
model.offsetOf(atom.firstChild),
model.offsetOf(atom.lastChild)
);
}
} else {
// Remove any error indicator on the current command sequence (if there is one)
getLatexGroupBody(model).forEach((x) => {
x.isError = false;
});
}
if (suffix) {
const atoms = parseLatex(suffix, {
parseMode: { math: 'text', text: 'math' }[mode],
});
model.collapseSelection('forward');
const cursor = model.at(model.position);
model.position = model.offsetOf(
cursor.parent!.addChildrenAfter(atoms, cursor)
);
contentChanged = true;
}
// Notify of mode change
if (typeof this.options.onModeChange === 'function') {
this.options.onModeChange(this, this.mode);
}
requestUpdate(this);
return contentChanged;
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(x) => {
x.isError = false;
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => {
if (options.range === undefined) {
this.model.selection.ranges.forEach((range) =>
applyStyle(this.model, range, style, { operation })
);
} else {
applyStyle(this.model, options.range, style, { operation });
}
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(range) =>
applyStyle(this.model, range, style, { operation }) | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(v) => {
const container = this.field?.querySelector(
`[data-placeholder-id=${v.atom.placeholderId}]`
) as HTMLElement;
if (container) {
const placeholderPosition = container.getBoundingClientRect();
const parentPosition = this.field?.getBoundingClientRect();
const scaleDownFontsize =
parseInt(window.getComputedStyle(container).fontSize) * 0.6;
if (
!v.field.style.fontSize ||
Math.abs(scaleDownFontsize - parseFloat(v.field.style.fontSize)) >=
0.2
) {
needsUpdate = true;
v.field.style.fontSize = `${scaleDownFontsize}px`;
}
const newTop =
(placeholderPosition?.top ?? 0) -
(parentPosition?.top ?? 0) +
(this.element?.offsetTop ?? 0);
const newLeft =
(placeholderPosition?.left ?? 0) -
(parentPosition?.left ?? 0) +
(this.element?.offsetLeft ?? 0);
if (
!v.field.style.left ||
Math.abs(newLeft - parseFloat(v.field.style.left)) >= 1
) {
needsUpdate = true;
v.field.style.left = `${newLeft}px`;
}
if (
!v.field.style.top ||
Math.abs(newTop - parseFloat(v.field.style.top)) >= 1
) {
needsUpdate = true;
v.field.style.top = `${newTop}px`;
}
console.log('attaching', !!v.field.style.left, !!v.field.style.top);
}
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(mf, reason): void => {
this.virtualKeyboard?.executeCommand([
'onUndoStateChanged',
this.canUndo(),
this.canRedo(),
]);
this.options.onUndoStateDidChange(mf, reason);
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
(mf, reason): void => {
this.virtualKeyboard!.executeCommand([
'onUndoStateChanged',
this.canUndo(),
this.canRedo(),
]);
this.options.onUndoStateDidChange(mf, reason);
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
ArrowFunction |
() => {
render(this); // Recalculate the position of the caret
// Synchronize the location and style of textarea
// so that the IME candidate window can align with the composition
const caretPoint = getCaretPoint(this.field!);
if (!caretPoint) return;
this.keyboardDelegate!.moveTo(caretPoint.x, caretPoint.y);
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
MethodDeclaration |
setOptions(config: Partial<MathfieldOptionsPrivate>): void {
this.options = updateOptions(this.options, config);
this.model.setListeners({
onContentDidChange: (_sender: ModelPrivate) =>
this.options.onContentDidChange(this),
onSelectionDidChange: (_sender: ModelPrivate) =>
this._onSelectionDidChange(),
onContentWillChange: () => this.options.onContentWillChange(this),
onSelectionWillChange: () => this.options.onSelectionWillChange(this),
onError: this.options.onError,
onPlaceholderDidChange: (_sender, placeholderId) =>
this.options.onPlaceholderDidChange(this, placeholderId),
});
this.model.setHooks({
announce: (_sender: Mathfield, command, previousPosition, atoms) =>
this.options.onAnnounce?.(this, command, previousPosition, atoms),
moveOut: (_sender, direction) =>
this.options.onMoveOutOf(this, direction),
tabOut: (_sender, direction) => this.options.onTabOutOf(this, direction),
});
this.model.options.macros = this.options
.macros as NormalizedMacroDictionary;
if (!this.options.locale.startsWith(getActiveKeyboardLayout().locale)) {
setKeyboardLayoutLocale(this.options.locale);
}
this._keybindings = undefined;
this.plonkSound = this.options.plonkSound as HTMLAudioElement;
if (
this.options.keypressSound &&
typeof this.options.keypressSound !== 'string' &&
!(this.options.keypressSound instanceof HTMLAudioElement)
) {
this.keypressSound = this.options.keypressSound
.default as HTMLAudioElement;
this.spacebarKeypressSound = this.options.keypressSound
.spacebar as HTMLAudioElement;
this.returnKeypressSound = this.options.keypressSound
.return as HTMLAudioElement;
this.deleteKeypressSound = this.options.keypressSound
.delete as HTMLAudioElement;
}
if (this.options.readOnly) {
this.onBlur();
this.element!.classList.add('ML__isReadOnly');
} else {
this.element!.classList.remove('ML__isReadOnly');
}
if (this.options.defaultMode === 'inline-math') {
this.element!.classList.add('ML__isInline');
} else {
this.element!.classList.remove('ML__isInline');
}
this.virtualKeyboard?.setOptions(this.options);
if (
!this.options.readOnly &&
this.options.virtualKeyboardMode === 'manual'
) {
this.virtualKeyboardToggle?.classList.add('is-visible');
} else {
this.virtualKeyboardToggle?.classList.remove('is-visible');
}
if ('virtualKeyboardToggleGlyph' in config) {
const toggle = this.element?.querySelector(
'.ML__virtual-keyboard-toggle'
);
if (toggle) {
toggle.innerHTML = this.options.createHTML(
this.options.virtualKeyboardToggleGlyph
);
}
}
this.colorMap = (name: string): string | undefined => {
let result: string | undefined = undefined;
if (typeof this.options.colorMap === 'function') {
result = this.options.colorMap(name);
}
if (!result) result = defaultColorMap(name);
return result;
};
this.backgroundColorMap = (name: string): string | undefined => {
let result: string | undefined = undefined;
if (typeof this.options.backgroundColorMap === 'function') {
result = this.options.backgroundColorMap(name);
}
if (!result && typeof this.options.colorMap === 'function') {
result = this.options.colorMap(name);
}
if (!result) result = defaultBackgroundColorMap(name);
return result;
};
// Changing some config options (i.e. `macros`) may
// require the content to be reparsed and re-rendered
const content = Atom.serialize(this.model.root, {
expandMacro: false,
defaultMode: this.options.defaultMode,
});
if ('macros' in config || this.model.getValue() !== content) {
ModeEditor.insert('math', this.model, content, {
insertionMode: 'replaceAll',
selectionMode: 'after',
format: 'latex',
suppressChangeNotifications: true,
});
}
requestUpdate(this);
} | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
MethodDeclaration |
getOptions<K extends keyof MathfieldOptionsPrivate>(
keys: K[]
): Pick<MathfieldOptionsPrivate, K>; | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |
MethodDeclaration |
getOptions(): MathfieldOptionsPrivate; | zeyad-ahmad-aql/mathlive | src/editor-mathfield/mathfield-private.ts | TypeScript |