type
stringclasses 7
values | content
stringlengths 4
9.55k
| repo
stringlengths 7
96
| path
stringlengths 4
178
| language
stringclasses 1
value |
|---|---|---|---|---|
MethodDeclaration |
getCurrentRenderTarget(variable: Variable): RenderTarget; | DefinitelyMaybe/threejs_4_deno | examples/jsm/misc/GPUComputationRenderer.d.ts | TypeScript |
MethodDeclaration |
getAlternateRenderTarget(variable: Variable): RenderTarget; | DefinitelyMaybe/threejs_4_deno | examples/jsm/misc/GPUComputationRenderer.d.ts | TypeScript |
MethodDeclaration |
addResolutionDefine(materialShader: ShaderMaterial): void; | DefinitelyMaybe/threejs_4_deno | examples/jsm/misc/GPUComputationRenderer.d.ts | TypeScript |
MethodDeclaration |
createRenderTarget(
sizeXTexture: number,
sizeYTexture: number,
wrapS: Wrapping,
wrapT: number,
minFilter: TextureFilter,
magFilter: TextureFilter,
): RenderTarget; | DefinitelyMaybe/threejs_4_deno | examples/jsm/misc/GPUComputationRenderer.d.ts | TypeScript |
MethodDeclaration |
createTexture(): DataTexture; | DefinitelyMaybe/threejs_4_deno | examples/jsm/misc/GPUComputationRenderer.d.ts | TypeScript |
MethodDeclaration |
renderTexture(input: Texture, output: Texture): void; | DefinitelyMaybe/threejs_4_deno | examples/jsm/misc/GPUComputationRenderer.d.ts | TypeScript |
MethodDeclaration |
doRenderTarget(material: Material, output: RenderTarget): void; | DefinitelyMaybe/threejs_4_deno | examples/jsm/misc/GPUComputationRenderer.d.ts | TypeScript |
ArrowFunction |
data => {
let section = data.section as Section;
this.sectionName = section.name;
this.sectionId = section.id;
this.pinnedThreads = section.topics.filter(x => x.isPinned);
this.unpinnedThreads = section.topics.filter(x => !x.isPinned);
if(section.topics?.length == 0) this.isEmpty = true;
} | HokaHelal/Madrasa | angular/src/app/forum/section-page/section-page.component.ts | TypeScript |
ArrowFunction |
x => x.isPinned | HokaHelal/Madrasa | angular/src/app/forum/section-page/section-page.component.ts | TypeScript |
ArrowFunction |
x => !x.isPinned | HokaHelal/Madrasa | angular/src/app/forum/section-page/section-page.component.ts | TypeScript |
ClassDeclaration |
@Component({
selector: 'app-section-page',
templateUrl: './section-page.component.html',
styleUrls: ['./section-page.component.scss']
})
export class SectionPageComponent implements OnInit {
pinnedThreads: TopicMain[];
unpinnedThreads: TopicMain[];
sectionName: string;
sectionId: number;
isEmpty = false;
bsModalRef: BsModalRef;
constructor(private route: ActivatedRoute,
private modalService: BsModalService,
) { }
ngOnInit() {
this.route.data.subscribe(data => {
let section = data.section as Section;
this.sectionName = section.name;
this.sectionId = section.id;
this.pinnedThreads = section.topics.filter(x => x.isPinned);
this.unpinnedThreads = section.topics.filter(x => !x.isPinned);
if(section.topics?.length == 0) this.isEmpty = true;
});
}
openNewThreadModal() {
const config = {
class: 'modal-dialog-centered modal-lg',
initialState: {
selectedSection: this.sectionId
}
};
this.bsModalRef = this.modalService.show(AddTopicModalComponent, config);
}
} | HokaHelal/Madrasa | angular/src/app/forum/section-page/section-page.component.ts | TypeScript |
MethodDeclaration |
ngOnInit() {
this.route.data.subscribe(data => {
let section = data.section as Section;
this.sectionName = section.name;
this.sectionId = section.id;
this.pinnedThreads = section.topics.filter(x => x.isPinned);
this.unpinnedThreads = section.topics.filter(x => !x.isPinned);
if(section.topics?.length == 0) this.isEmpty = true;
});
} | HokaHelal/Madrasa | angular/src/app/forum/section-page/section-page.component.ts | TypeScript |
MethodDeclaration |
openNewThreadModal() {
const config = {
class: 'modal-dialog-centered modal-lg',
initialState: {
selectedSection: this.sectionId
}
};
this.bsModalRef = this.modalService.show(AddTopicModalComponent, config);
} | HokaHelal/Madrasa | angular/src/app/forum/section-page/section-page.component.ts | TypeScript |
ArrowFunction |
type => UserStrength | soumyanildas/cv-base | src/user/entities/strength.entity.ts | TypeScript |
ArrowFunction |
userStrength => userStrength.strength | soumyanildas/cv-base | src/user/entities/strength.entity.ts | TypeScript |
ClassDeclaration |
@Entity('strengths')
export class Strength {
@PrimaryGeneratedColumn('uuid')
id: string;
@Column({
type: 'text',
nullable: true
})
strengthName: string;
@OneToMany(type => UserStrength, userStrength => userStrength.strength)
strengths: UserStrength[];
} | soumyanildas/cv-base | src/user/entities/strength.entity.ts | TypeScript |
FunctionDeclaration |
function handleSort(id: string) {
if (id === sortColumn) {
setSortAsc(asc => !asc);
} else {
setSortColumn(id);
setSortAsc(true);
}
} | yashatgit/baseweb | documentation-site/examples/table-semantic/sortable.tsx | TypeScript |
ArrowFunction |
() => {
const [sortColumn, setSortColumn] = useState('bar');
const [sortAsc, setSortAsc] = useState(true);
const [data] = useState([
{
foo: 10,
bar: 'banana',
url: 'https://example.com/b',
},
{
foo: 1,
bar: 'carrot',
url: 'https://example.com/c',
},
{
foo: 2,
bar: 'apple',
url: 'https://example.com/a',
},
]);
const sortedData = useMemo(() => {
return data.slice().sort((a: any, b: any) => {
const left = sortAsc ? a : b;
const right = sortAsc ? b : a;
const leftValue = String(left[sortColumn]);
const rightValue = String(right[sortColumn]);
return leftValue.localeCompare(rightValue, 'en', {
numeric: true,
sensitivity: 'base',
});
});
}, [sortColumn, sortAsc, data]);
function handleSort(id: string) {
if (id === sortColumn) {
setSortAsc(asc => !asc);
} else {
setSortColumn(id);
setSortAsc(true);
}
}
return (
<TableBuilder
data={sortedData}
sortColumn={sortColumn}
sortOrder={sortAsc ? 'ASC' : 'DESC'}
onSort={handleSort}
>
<TableBuilderColumn id="bar" header="Produce" sortable>
{row => <Link href={row.url}>{row.bar}</Link>}
</TableBuilderColumn>
<TableBuilderColumn
id="foo"
header="Quantity"
numeric
sortable
>
{row => row.foo}
</TableBuilderColumn>
</TableBuilder>
);
} | yashatgit/baseweb | documentation-site/examples/table-semantic/sortable.tsx | TypeScript |
ArrowFunction |
() => {
return data.slice().sort((a: any, b: any) => {
const left = sortAsc ? a : b;
const right = sortAsc ? b : a;
const leftValue = String(left[sortColumn]);
const rightValue = String(right[sortColumn]);
return leftValue.localeCompare(rightValue, 'en', {
numeric: true,
sensitivity: 'base',
});
});
} | yashatgit/baseweb | documentation-site/examples/table-semantic/sortable.tsx | TypeScript |
ArrowFunction |
(a: any, b: any) => {
const left = sortAsc ? a : b;
const right = sortAsc ? b : a;
const leftValue = String(left[sortColumn]);
const rightValue = String(right[sortColumn]);
return leftValue.localeCompare(rightValue, 'en', {
numeric: true,
sensitivity: 'base',
});
} | yashatgit/baseweb | documentation-site/examples/table-semantic/sortable.tsx | TypeScript |
ArrowFunction |
asc => !asc | yashatgit/baseweb | documentation-site/examples/table-semantic/sortable.tsx | TypeScript |
ClassDeclaration |
export class DatabaseConfigInfo
{
/*Bindable*/ public connection:string = "";
/*Bindable*/ public schema:string = "weave";
/*Bindable*/ public idFields:string[] = null;
} | WeaveTeam/WeaveJS | WeaveTSJS/src/weavejs/net/beans/DatabaseConfigInfo.ts | TypeScript |
ClassDeclaration |
export class ImportApiCommand extends $Command<
ImportApiCommandInput,
ImportApiCommandOutput,
ApiGatewayV2ClientResolvedConfig
> {
// Start section: command_properties
// End section: command_properties
constructor(readonly input: ImportApiCommandInput) {
// Start section: command_constructor
super();
// End section: command_constructor
}
resolveMiddleware(
clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
configuration: ApiGatewayV2ClientResolvedConfig,
options?: __HttpHandlerOptions
): Handler<ImportApiCommandInput, ImportApiCommandOutput> {
this.middlewareStack.use(
getSerdePlugin(configuration, this.serialize, this.deserialize)
);
const stack = clientStack.concat(this.middlewareStack);
const handlerExecutionContext: HandlerExecutionContext = {
logger: {} as any
};
const { requestHandler } = configuration;
return stack.resolve(
(request: FinalizeHandlerArguments<any>) =>
requestHandler.handle(request.request as __HttpRequest, options || {}),
handlerExecutionContext
);
}
private serialize(
input: ImportApiCommandInput,
context: __SerdeContext
): Promise<__HttpRequest> {
return serializeAws_restJson1_1ImportApiCommand(input, context);
}
private deserialize(
output: __HttpResponse,
context: __SerdeContext
): Promise<ImportApiCommandOutput> {
return deserializeAws_restJson1_1ImportApiCommand(output, context);
}
// Start section: command_body_extra
// End section: command_body_extra
} | garrettheel/aws-sdk-js-v3 | clients/client-apigatewayv2/commands/ImportApiCommand.ts | TypeScript |
TypeAliasDeclaration |
export type ImportApiCommandInput = ImportApiRequest; | garrettheel/aws-sdk-js-v3 | clients/client-apigatewayv2/commands/ImportApiCommand.ts | TypeScript |
TypeAliasDeclaration |
export type ImportApiCommandOutput = ImportApiResponse & __MetadataBearer; | garrettheel/aws-sdk-js-v3 | clients/client-apigatewayv2/commands/ImportApiCommand.ts | TypeScript |
MethodDeclaration |
resolveMiddleware(
clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
configuration: ApiGatewayV2ClientResolvedConfig,
options?: __HttpHandlerOptions
): Handler<ImportApiCommandInput, ImportApiCommandOutput> {
this.middlewareStack.use(
getSerdePlugin(configuration, this.serialize, this.deserialize)
);
const stack = clientStack.concat(this.middlewareStack);
const handlerExecutionContext: HandlerExecutionContext = {
logger: {} as any
};
const { requestHandler } = configuration;
return stack.resolve(
(request: FinalizeHandlerArguments<any>) =>
requestHandler.handle(request.request as __HttpRequest, options || {}),
handlerExecutionContext
);
} | garrettheel/aws-sdk-js-v3 | clients/client-apigatewayv2/commands/ImportApiCommand.ts | TypeScript |
MethodDeclaration |
private serialize(
input: ImportApiCommandInput,
context: __SerdeContext
): Promise<__HttpRequest> {
return serializeAws_restJson1_1ImportApiCommand(input, context);
} | garrettheel/aws-sdk-js-v3 | clients/client-apigatewayv2/commands/ImportApiCommand.ts | TypeScript |
MethodDeclaration |
private deserialize(
output: __HttpResponse,
context: __SerdeContext
): Promise<ImportApiCommandOutput> {
return deserializeAws_restJson1_1ImportApiCommand(output, context);
} | garrettheel/aws-sdk-js-v3 | clients/client-apigatewayv2/commands/ImportApiCommand.ts | TypeScript |
ClassDeclaration |
export class Operacion implements Expresion {
linea: number;
columna: number;
op_izquierda: Expresion;
op_derecha: Expresion;
operador: Operador;
constructor(op_izquierda:Expresion, op_derecha:Expresion, operacion:Operador, linea:number, columna:number){
this.linea = linea;
this.columna = columna;
this.op_izquierda = op_izquierda;
this.op_derecha = op_derecha;
this.operador = operacion;
}
getTipo(ent: Ambito, arbol: AST): Tipo {
const valor = this.getValorImplicito(ent, arbol);
if (typeof(valor) === 'string'){
return Tipo.STRING;
}
else if (typeof(valor) === 'number'){
if(this.isInt(Number(valor))){
return Tipo.INT;
}
return Tipo.DOUBLE;
}
else if(valor === null){
return Tipo.NULL;
}
return Tipo.NULL;
}
getValorImplicito(ent: Ambito, arbol: AST) {
if (this.operador !== Operador.MENOS_UNARIO && this.operador !== Operador.NOT && this.operador !== Operador.NODO){
let op1 = this.op_izquierda.getValorImplicito(ent, arbol);
let op2 = this.op_derecha.getValorImplicito(ent, arbol);
//suma
if (this.operador == Operador.SUMA)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
return op1 + op2;
}
else if (op1==="string" || op2 ==="string")
{
if (op1 == null) op1 = "null";
if (op2 == null) op2 = "null";
return op1.ToString() + op2.ToString();
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//resta
else if (this.operador == Operador.RESTA)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
return op1 - op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//multiplicación
else if (this.operador == Operador.MULTIPLICACION)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
return op1 * op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//division
else if (this.operador == Operador.DIVISION)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
if(op2===0){
console.log("Resultado indefinido, no puede ejecutarse operación sobre cero.");
return null;
}
return op1 / op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//modulo
else if (this.operador == Operador.MODULO)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
if(op2===0){
console.log("Resultado indefinido, no puede ejecutarse operación sobre cero.");
return null;
}
return op1 % op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
}else{
let op1 = this.op_izquierda.getValorImplicito(ent, arbol);
if (this.operador == Operador.NODO)
{
return op1;
}
else if (this.operador == Operador.MENOS_UNARIO)
{
if (typeof(op1==="number"))
{
return -1* op1;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una operación unaria");
return null;
}
}
}
return null;
}
isInt(n:number){
return Number(n) === n && n % 1 === 0;
}
} | 18SebastianVC/tytusx | 20211SVAC/G37/Codigo Fuente/CLASES/Operacion.ts | TypeScript |
EnumDeclaration |
export enum Operador {
ENTERO,
DECIMAL,
CADENA,
SUMA,
RESTA,
MULTIPLICACION,
DIVISION,
MODULO,
MENOS_UNARIO,
MAYOR_QUE,
MENOR_QUE,
IGUAL_IGUAL,
DIFERENTE_QUE,
OR,
AND,
NOT,
MAYOR_IGUA_QUE,
MENOR_IGUA_QUE,
DESCONOCIDO,
NODO,
AXE,
POR_WILDCARD,
POR,
DOT,
DOUBLE_DOT
} | 18SebastianVC/tytusx | 20211SVAC/G37/Codigo Fuente/CLASES/Operacion.ts | TypeScript |
MethodDeclaration |
getTipo(ent: Ambito, arbol: AST): Tipo {
const valor = this.getValorImplicito(ent, arbol);
if (typeof(valor) === 'string'){
return Tipo.STRING;
}
else if (typeof(valor) === 'number'){
if(this.isInt(Number(valor))){
return Tipo.INT;
}
return Tipo.DOUBLE;
}
else if(valor === null){
return Tipo.NULL;
}
return Tipo.NULL;
} | 18SebastianVC/tytusx | 20211SVAC/G37/Codigo Fuente/CLASES/Operacion.ts | TypeScript |
MethodDeclaration |
getValorImplicito(ent: Ambito, arbol: AST) {
if (this.operador !== Operador.MENOS_UNARIO && this.operador !== Operador.NOT && this.operador !== Operador.NODO){
let op1 = this.op_izquierda.getValorImplicito(ent, arbol);
let op2 = this.op_derecha.getValorImplicito(ent, arbol);
//suma
if (this.operador == Operador.SUMA)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
return op1 + op2;
}
else if (op1==="string" || op2 ==="string")
{
if (op1 == null) op1 = "null";
if (op2 == null) op2 = "null";
return op1.ToString() + op2.ToString();
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//resta
else if (this.operador == Operador.RESTA)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
return op1 - op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//multiplicación
else if (this.operador == Operador.MULTIPLICACION)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
return op1 * op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//division
else if (this.operador == Operador.DIVISION)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
if(op2===0){
console.log("Resultado indefinido, no puede ejecutarse operación sobre cero.");
return null;
}
return op1 / op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
//modulo
else if (this.operador == Operador.MODULO)
{
if (typeof(op1==="number") && typeof(op2==="number"))
{
if(op2===0){
console.log("Resultado indefinido, no puede ejecutarse operación sobre cero.");
return null;
}
return op1 % op2;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una suma");
return null;
}
}
}else{
let op1 = this.op_izquierda.getValorImplicito(ent, arbol);
if (this.operador == Operador.NODO)
{
return op1;
}
else if (this.operador == Operador.MENOS_UNARIO)
{
if (typeof(op1==="number"))
{
return -1* op1;
}
else
{
console.log("Error de tipos de datos no permitidos realizando una operación unaria");
return null;
}
}
}
return null;
} | 18SebastianVC/tytusx | 20211SVAC/G37/Codigo Fuente/CLASES/Operacion.ts | TypeScript |
MethodDeclaration |
isInt(n:number){
return Number(n) === n && n % 1 === 0;
} | 18SebastianVC/tytusx | 20211SVAC/G37/Codigo Fuente/CLASES/Operacion.ts | TypeScript |
ArrowFunction |
() => {
this.setState({ itemCount: this.todoListService.getItemCount() });
} | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
ArrowFunction |
() => {
this.setState({ listItems: this.todoListService.getListItems() });
} | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
ArrowFunction |
($event) => this.addAndClearItem($event) | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
ArrowFunction |
(item) => {
return <div>{item}</div>
} | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
ClassDeclaration |
export default class App extends Component<any, AppState> {
@lazyInject('TODOListService') todoListService: TODOListService;
// Creates a reference to our html input element so that we can get its value
inputElement = createRef<HTMLInputElement>();
constructor() {
super();
this.state = {
itemCount: this.todoListService.getItemCount(),
listItems: this.todoListService.getListItems() || [],
}
// When event an item is added to the todoList, this will be notified of it.
window.addEventListener(LIST_CHANGED_EVENT_TYPE_ID, () => {
this.setState({ itemCount: this.todoListService.getItemCount() });
});
window.addEventListener(LIST_CHANGED_EVENT_TYPE_ID, () => {
this.setState({ listItems: this.todoListService.getListItems() });
});
}
addAndClearItem($event) {
const item = this.inputElement.current.value;
if (item && item.length > 0) {
this.todoListService.addListItem(item);
}
this.inputElement.current.value = "";
}
render() {
return (
<div id="app">
<div class="list-item-count">
You have {this.state.itemCount} items todo.
</div>
<div >
<div class="control-container">
<input ref={this.inputElement} type="text" />
<button onClick={($event) => this.addAndClearItem($event)}>Add</button>
</div>
</div>
<div class="todo-list">
{
// Render current list
this.state.listItems.map((item) => {
return <div>{item}</div>
})
}
</div>
</div>
);
}
} | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
InterfaceDeclaration |
interface AppState {
itemCount: number;
listItems: string[];
} | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
MethodDeclaration |
addAndClearItem($event) {
const item = this.inputElement.current.value;
if (item && item.length > 0) {
this.todoListService.addListItem(item);
}
this.inputElement.current.value = "";
} | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
MethodDeclaration |
render() {
return (
<div id="app">
<div class="list-item-count">
You have {this.state.itemCount} items todo.
</div>
<div >
<div class="control-container">
<input ref={this.inputElement} type="text" />
<button onClick={($event) => this.addAndClearItem($event)}>Add</button>
</div>
</div>
<div class="todo-list">
{
// Render current list
this.state.listItems.map((item) => {
return <div>{item}</div>
})
}
</div>
</div>
);
} | harithay/preact-with-inversifyjs-as-di | webapp/src/components/app.tsx | TypeScript |
FunctionDeclaration |
function createProtocolError(error: ProtocolError, method: string, protocolError: { message: string; data: any; }): ProtocolError {
let message = `Protocol error (${method}): ${protocolError.message}`;
if ('data' in protocolError)
message += ` ${protocolError.data}`;
return rewriteErrorMessage(error, message);
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
ArrowFunction |
() => this.emit(ConnectionEvents.Disconnected) | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
ArrowFunction |
(resolve, reject) => {
this._callbacks.set(id, { resolve, reject, error: new ProtocolError(false), method });
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
ArrowFunction |
(error: ProtocolError) => debugLogger.log('error', error) | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
ArrowFunction |
() => {
if (this._eventListener)
this._eventListener(object.method!, object.params);
this.emit(object.method!, object.params);
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
ArrowFunction |
() => this.emit(CRSessionEvents.Disconnected) | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
ClassDeclaration |
export class CRConnection extends EventEmitter {
private _lastId = 0;
private readonly _transport: ConnectionTransport;
private readonly _sessions = new Map<string, CRSession>();
private readonly _protocolLogger: ProtocolLogger;
private readonly _browserLogsCollector: RecentLogsCollector;
readonly rootSession: CRSession;
_closed = false;
constructor(transport: ConnectionTransport, protocolLogger: ProtocolLogger, browserLogsCollector: RecentLogsCollector) {
super();
this.setMaxListeners(0);
this._transport = transport;
this._protocolLogger = protocolLogger;
this._browserLogsCollector = browserLogsCollector;
this._transport.onmessage = this._onMessage.bind(this);
this._transport.onclose = this._onClose.bind(this);
this.rootSession = new CRSession(this, '', 'browser', '');
this._sessions.set('', this.rootSession);
}
static fromSession(session: CRSession): CRConnection {
return session._connection!;
}
session(sessionId: string): CRSession | null {
return this._sessions.get(sessionId) || null;
}
_rawSend(sessionId: string, method: string, params: any): number {
const id = ++this._lastId;
const message: ProtocolRequest = { id, method, params };
if (sessionId)
message.sessionId = sessionId;
this._protocolLogger('send', message);
this._transport.send(message);
return id;
}
async _onMessage(message: ProtocolResponse) {
this._protocolLogger('receive', message);
if (message.id === kBrowserCloseMessageId)
return;
if (message.method === 'Target.attachedToTarget') {
const sessionId = message.params.sessionId;
const rootSessionId = message.sessionId || '';
const session = new CRSession(this, rootSessionId, message.params.targetInfo.type, sessionId);
this._sessions.set(sessionId, session);
} else if (message.method === 'Target.detachedFromTarget') {
const session = this._sessions.get(message.params.sessionId);
if (session) {
session._onClosed(undefined);
this._sessions.delete(message.params.sessionId);
}
}
const session = this._sessions.get(message.sessionId || '');
if (session)
session._onMessage(message);
}
_onClose() {
this._closed = true;
this._transport.onmessage = undefined;
this._transport.onclose = undefined;
const browserDisconnectedLogs = helper.formatBrowserLogs(this._browserLogsCollector.recentLogs());
for (const session of this._sessions.values())
session._onClosed(browserDisconnectedLogs);
this._sessions.clear();
Promise.resolve().then(() => this.emit(ConnectionEvents.Disconnected));
}
close() {
if (!this._closed)
this._transport.close();
}
async createSession(targetInfo: Protocol.Target.TargetInfo): Promise<CRSession> {
const { sessionId } = await this.rootSession.send('Target.attachToTarget', { targetId: targetInfo.targetId, flatten: true });
return this._sessions.get(sessionId)!;
}
async createBrowserSession(): Promise<CRSession> {
const { sessionId } = await this.rootSession.send('Target.attachToBrowserTarget');
return this._sessions.get(sessionId)!;
}
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
ClassDeclaration |
export class CRSession extends EventEmitter {
_connection: CRConnection | null;
_eventListener?: (method: string, params?: Object) => void;
private readonly _callbacks = new Map<number, {resolve: (o: any) => void, reject: (e: ProtocolError) => void, error: ProtocolError, method: string}>();
private readonly _targetType: string;
private readonly _sessionId: string;
private readonly _rootSessionId: string;
private _crashed: boolean = false;
private _browserDisconnectedLogs: string | undefined;
override on: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;
override addListener: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;
override off: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;
override removeListener: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;
override once: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;
readonly guid: string;
constructor(connection: CRConnection, rootSessionId: string, targetType: string, sessionId: string) {
super();
this.guid = `cdp-session@${sessionId}`;
this.setMaxListeners(0);
this._connection = connection;
this._rootSessionId = rootSessionId;
this._targetType = targetType;
this._sessionId = sessionId;
this.on = super.on;
this.addListener = super.addListener;
this.off = super.removeListener;
this.removeListener = super.removeListener;
this.once = super.once;
}
_markAsCrashed() {
this._crashed = true;
}
async send<T extends keyof Protocol.CommandParameters>(
method: T,
params?: Protocol.CommandParameters[T]
): Promise<Protocol.CommandReturnValues[T]> {
if (this._crashed)
throw new ProtocolError(true, 'Target crashed');
if (this._browserDisconnectedLogs !== undefined)
throw new ProtocolError(true, `Browser closed.` + this._browserDisconnectedLogs);
if (!this._connection)
throw new ProtocolError(true, `Target closed`);
const id = this._connection._rawSend(this._sessionId, method, params);
return new Promise((resolve, reject) => {
this._callbacks.set(id, { resolve, reject, error: new ProtocolError(false), method });
});
}
_sendMayFail<T extends keyof Protocol.CommandParameters>(method: T, params?: Protocol.CommandParameters[T]): Promise<Protocol.CommandReturnValues[T] | void> {
return this.send(method, params).catch((error: ProtocolError) => debugLogger.log('error', error));
}
_onMessage(object: ProtocolResponse) {
if (object.id && this._callbacks.has(object.id)) {
const callback = this._callbacks.get(object.id)!;
this._callbacks.delete(object.id);
if (object.error)
callback.reject(createProtocolError(callback.error, callback.method, object.error));
else
callback.resolve(object.result);
} else if (object.id && object.error?.code === -32001) {
// Message to a closed session, just ignore it.
} else {
assert(!object.id);
Promise.resolve().then(() => {
if (this._eventListener)
this._eventListener(object.method!, object.params);
this.emit(object.method!, object.params);
});
}
}
async detach() {
if (!this._connection)
throw new Error(`Session already detached. Most likely the ${this._targetType} has been closed.`);
const rootSession = this._connection.session(this._rootSessionId);
if (!rootSession)
throw new Error('Root session has been closed');
await rootSession.send('Target.detachFromTarget', { sessionId: this._sessionId });
}
_onClosed(browserDisconnectedLogs: string | undefined) {
this._browserDisconnectedLogs = browserDisconnectedLogs;
const errorMessage = browserDisconnectedLogs !== undefined ? 'Browser closed.' + browserDisconnectedLogs : 'Target closed';
for (const callback of this._callbacks.values()) {
callback.error.sessionClosed = true;
callback.reject(rewriteErrorMessage(callback.error, errorMessage));
}
this._callbacks.clear();
this._connection = null;
Promise.resolve().then(() => this.emit(CRSessionEvents.Disconnected));
}
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
static fromSession(session: CRSession): CRConnection {
return session._connection!;
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
session(sessionId: string): CRSession | null {
return this._sessions.get(sessionId) || null;
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
_rawSend(sessionId: string, method: string, params: any): number {
const id = ++this._lastId;
const message: ProtocolRequest = { id, method, params };
if (sessionId)
message.sessionId = sessionId;
this._protocolLogger('send', message);
this._transport.send(message);
return id;
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
async _onMessage(message: ProtocolResponse) {
this._protocolLogger('receive', message);
if (message.id === kBrowserCloseMessageId)
return;
if (message.method === 'Target.attachedToTarget') {
const sessionId = message.params.sessionId;
const rootSessionId = message.sessionId || '';
const session = new CRSession(this, rootSessionId, message.params.targetInfo.type, sessionId);
this._sessions.set(sessionId, session);
} else if (message.method === 'Target.detachedFromTarget') {
const session = this._sessions.get(message.params.sessionId);
if (session) {
session._onClosed(undefined);
this._sessions.delete(message.params.sessionId);
}
}
const session = this._sessions.get(message.sessionId || '');
if (session)
session._onMessage(message);
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
_onClose() {
this._closed = true;
this._transport.onmessage = undefined;
this._transport.onclose = undefined;
const browserDisconnectedLogs = helper.formatBrowserLogs(this._browserLogsCollector.recentLogs());
for (const session of this._sessions.values())
session._onClosed(browserDisconnectedLogs);
this._sessions.clear();
Promise.resolve().then(() => this.emit(ConnectionEvents.Disconnected));
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
close() {
if (!this._closed)
this._transport.close();
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
async createSession(targetInfo: Protocol.Target.TargetInfo): Promise<CRSession> {
const { sessionId } = await this.rootSession.send('Target.attachToTarget', { targetId: targetInfo.targetId, flatten: true });
return this._sessions.get(sessionId)!;
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
async createBrowserSession(): Promise<CRSession> {
const { sessionId } = await this.rootSession.send('Target.attachToBrowserTarget');
return this._sessions.get(sessionId)!;
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
_markAsCrashed() {
this._crashed = true;
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
async send<T extends keyof Protocol.CommandParameters>(
method: T,
params?: Protocol.CommandParameters[T]
): Promise<Protocol.CommandReturnValues[T]> {
if (this._crashed)
throw new ProtocolError(true, 'Target crashed');
if (this._browserDisconnectedLogs !== undefined)
throw new ProtocolError(true, `Browser closed.` + this._browserDisconnectedLogs);
if (!this._connection)
throw new ProtocolError(true, `Target closed`);
const id = this._connection._rawSend(this._sessionId, method, params);
return new Promise((resolve, reject) => {
this._callbacks.set(id, { resolve, reject, error: new ProtocolError(false), method });
});
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
_sendMayFail<T extends keyof Protocol.CommandParameters>(method: T, params?: Protocol.CommandParameters[T]): Promise<Protocol.CommandReturnValues[T] | void> {
return this.send(method, params).catch((error: ProtocolError) => debugLogger.log('error', error));
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
_onMessage(object: ProtocolResponse) {
if (object.id && this._callbacks.has(object.id)) {
const callback = this._callbacks.get(object.id)!;
this._callbacks.delete(object.id);
if (object.error)
callback.reject(createProtocolError(callback.error, callback.method, object.error));
else
callback.resolve(object.result);
} else if (object.id && object.error?.code === -32001) {
// Message to a closed session, just ignore it.
} else {
assert(!object.id);
Promise.resolve().then(() => {
if (this._eventListener)
this._eventListener(object.method!, object.params);
this.emit(object.method!, object.params);
});
}
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
async detach() {
if (!this._connection)
throw new Error(`Session already detached. Most likely the ${this._targetType} has been closed.`);
const rootSession = this._connection.session(this._rootSessionId);
if (!rootSession)
throw new Error('Root session has been closed');
await rootSession.send('Target.detachFromTarget', { sessionId: this._sessionId });
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
MethodDeclaration |
_onClosed(browserDisconnectedLogs: string | undefined) {
this._browserDisconnectedLogs = browserDisconnectedLogs;
const errorMessage = browserDisconnectedLogs !== undefined ? 'Browser closed.' + browserDisconnectedLogs : 'Target closed';
for (const callback of this._callbacks.values()) {
callback.error.sessionClosed = true;
callback.reject(rewriteErrorMessage(callback.error, errorMessage));
}
this._callbacks.clear();
this._connection = null;
Promise.resolve().then(() => this.emit(CRSessionEvents.Disconnected));
} | Meir017/playwright | packages/playwright-core/src/server/chromium/crConnection.ts | TypeScript |
FunctionDeclaration |
export function format(content: string): string {
try {
const tokens = tokenize(content, { range: true });
let result = content;
// 在原来的基础上偏移量
let offset = 0;
tokens.forEach(item => {
if (item.type === 'String' || item.type === 'Identifier') {
let [start, end] = item.range;
start += offset;
end += offset;
const value = item.value;
const singleQReg = /^'(.+)'$/;
const doubleQReg = /^"(.+)"$/;
if (singleQReg.test(value)) {
result = `${result.slice(0, start)}"${value.slice(
1,
-1,
)}"${result.slice(end)}`;
} else if (!singleQReg.test(value) && !doubleQReg.test(value)) {
result = `${result.slice(0, start)}"${value}"${result.slice(
end,
)}`;
offset += 2;
}
}
});
return result;
} catch (error) {
return content;
}
} | wulunyi/typeof-jsonc | src/utils/format.ts | TypeScript |
ArrowFunction |
item => {
if (item.type === 'String' || item.type === 'Identifier') {
let [start, end] = item.range;
start += offset;
end += offset;
const value = item.value;
const singleQReg = /^'(.+)'$/;
const doubleQReg = /^"(.+)"$/;
if (singleQReg.test(value)) {
result = `${result.slice(0, start)}"${value.slice(
1,
-1,
)}"${result.slice(end)}`;
} else if (!singleQReg.test(value) && !doubleQReg.test(value)) {
result = `${result.slice(0, start)}"${value}"${result.slice(
end,
)}`;
offset += 2;
}
}
} | wulunyi/typeof-jsonc | src/utils/format.ts | TypeScript |
FunctionDeclaration |
function MarketRowItem({
style,
currency,
counterCurrency,
locale,
loading,
isStarred,
toggleStar,
selectCurrency,
availableOnBuy,
availableOnSwap,
}: Props) {
const { t } = useTranslation();
const dispatch = useDispatch();
const openAddAccounts = useCallback(() => {
if (currency)
dispatch(
openModal("MODAL_ADD_ACCOUNTS", {
currency: currency.internalCurrency,
preventSkippingCurrencySelection: true,
}),
);
}, [dispatch, currency]);
const history = useHistory();
const { colors } = useTheme();
const graphColor = colors.neutral.c80;
const allAccounts = useSelector(accountsSelector);
const flattenedAccounts = flattenAccounts(allAccounts);
const onCurrencyClick = useCallback(() => {
selectCurrency(currency.id);
setTrackingSource("Page Market");
history.push({
pathname: `/market/${currency.id}`,
state: currency,
});
}, [currency, history, selectCurrency]);
const onBuy = useCallback(
e => {
e.preventDefault();
e.stopPropagation();
setTrackingSource("Page Market");
history.push({
pathname: "/exchange",
state: {
mode: "onRamp",
defaultTicker: currency.ticker.toUpperCase(),
},
});
},
[currency, history],
);
const onSwap = useCallback(
e => {
if (currency?.internalCurrency?.id) {
e.preventDefault();
e.stopPropagation();
setTrackingSource("Page Market");
const currencyId = currency?.internalCurrency?.id;
const defaultAccount = getAvailableAccountsById(currencyId, flattenedAccounts).find(
Boolean,
);
if (!defaultAccount) return openAddAccounts();
history.push({
pathname: "/swap",
state: {
defaultCurrency: currency.internalCurrency,
defaultAccount,
defaultParentAccount: defaultAccount?.parentId
? flattenedAccounts.find(a => a.id === defaultAccount.parentId)
: null,
},
});
}
},
[currency?.internalCurrency, flattenedAccounts, openAddAccounts, history],
);
const onStarClick = useCallback(
e => {
e.preventDefault();
e.stopPropagation();
toggleStar();
},
[toggleStar],
);
const hasActions = currency?.internalCurrency && (availableOnBuy || availableOnSwap);
return (
<div style={{ ...style }} | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
ArrowFunction |
() => {
if (currency)
dispatch(
openModal("MODAL_ADD_ACCOUNTS", {
currency: currency.internalCurrency,
preventSkippingCurrencySelection: true,
}),
);
} | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
ArrowFunction |
() => {
selectCurrency(currency.id);
setTrackingSource("Page Market");
history.push({
pathname: `/market/${currency.id}`,
state: currency,
});
} | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
ArrowFunction |
e => {
e.preventDefault();
e.stopPropagation();
setTrackingSource("Page Market");
history.push({
pathname: "/exchange",
state: {
mode: "onRamp",
defaultTicker: currency.ticker.toUpperCase(),
},
});
} | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
ArrowFunction |
e => {
if (currency?.internalCurrency?.id) {
e.preventDefault();
e.stopPropagation();
setTrackingSource("Page Market");
const currencyId = currency?.internalCurrency?.id;
const defaultAccount = getAvailableAccountsById(currencyId, flattenedAccounts).find(
Boolean,
);
if (!defaultAccount) return openAddAccounts();
history.push({
pathname: "/swap",
state: {
defaultCurrency: currency.internalCurrency,
defaultAccount,
defaultParentAccount: defaultAccount?.parentId
? flattenedAccounts.find(a => a.id === defaultAccount.parentId)
: null,
},
});
}
} | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
ArrowFunction |
a => a.id === defaultAccount.parentId | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
ArrowFunction |
e => {
e.preventDefault();
e.stopPropagation();
toggleStar();
} | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
TypeAliasDeclaration |
type Props = {
currency: CurrencyData;
counterCurrency: string;
style: any;
loading: boolean;
locale: string;
isStarred: boolean;
toggleStar: () => void;
selectCurrency: (currencyId: string) => void;
availableOnBuy: boolean;
availableOnSwap: boolean;
}; | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
MethodDeclaration |
t("accounts.contextMenu.buy") | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
MethodDeclaration |
t("accounts.contextMenu.swap") | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
MethodDeclaration |
counterValueFormatter({ value: currency | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
MethodDeclaration |
parseFloat(currency | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
MethodDeclaration |
counterValueFormatter({
shorten: true,
currency: counterCurrency,
value: currency | pawelnguyen/ledger-live-desktop | src/renderer/screens/market/MarketRowItem.tsx | TypeScript |
FunctionDeclaration |
function getKeytip(keytips: IKeytipProps[], content: string): IKeytipProps | undefined {
return find(keytips, (keytip: IKeytipProps) => {
return keytip.content === content;
});
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
(keytip: IKeytipProps) => {
return keytip.content === content;
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
if (ktpLayer) {
ktpLayer.unmount();
}
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
// Add some keytips to the Manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG },
};
// Create layer
ktpLayer = mount(<KeytipLayerBase content="Alt Windows" />);
const layerKeytips = ktpLayer.state('keytips');
expect(layerKeytips).toHaveLength(2);
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
const onEnter = jest.fn();
const onExit = jest.fn();
beforeEach(() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
});
it('correctly sets variables when entering and exiting', () => {
// Call enterKeytipMode
ktpMgr.enterKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(true);
expect(onEnter).toBeCalled();
ktpTree = layerRef.current!.getKeytipTree();
// 4 nodes + the root
expect(Object.keys(ktpTree.nodeMap)).toHaveLength(5);
expect(ktpTree.getNode(keytipIdB)).toBeDefined();
expect(ktpTree.getNode(keytipIdC)).toBeDefined();
expect(ktpTree.getNode(keytipIdD)).toBeDefined();
expect(ktpTree.getNode(keytipIdG)).toBeDefined();
// Should show B and C
let visibleKeytips: IKeytipProps[] = ktpLayer.state('visibleKeytips');
expect(visibleKeytips).toHaveLength(2);
expect(getKeytip(visibleKeytips, 'B')).toBeDefined();
expect(getKeytip(visibleKeytips, 'C')).toBeDefined();
expect(ktpTree.currentKeytip).toEqual(ktpTree.root);
// Call enterKeytipMode
ktpMgr.exitKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(false);
expect(onExit).toBeCalled();
ktpTree = layerRef.current!.getKeytipTree();
visibleKeytips = ktpLayer.state('visibleKeytips');
expect(visibleKeytips).toHaveLength(0);
expect(layerRef.current!.getCurrentSequence()).toEqual('');
expect(ktpTree.currentKeytip).toBeUndefined();
});
it('respects shouldEnterKeytipMode', () => {
ktpMgr.shouldEnterKeytipMode = false;
ktpMgr.enterKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(false);
ktpMgr.shouldEnterKeytipMode = true;
ktpMgr.enterKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(true);
expect(onEnter).toBeCalled();
});
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
// Call enterKeytipMode
ktpMgr.enterKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(true);
expect(onEnter).toBeCalled();
ktpTree = layerRef.current!.getKeytipTree();
// 4 nodes + the root
expect(Object.keys(ktpTree.nodeMap)).toHaveLength(5);
expect(ktpTree.getNode(keytipIdB)).toBeDefined();
expect(ktpTree.getNode(keytipIdC)).toBeDefined();
expect(ktpTree.getNode(keytipIdD)).toBeDefined();
expect(ktpTree.getNode(keytipIdG)).toBeDefined();
// Should show B and C
let visibleKeytips: IKeytipProps[] = ktpLayer.state('visibleKeytips');
expect(visibleKeytips).toHaveLength(2);
expect(getKeytip(visibleKeytips, 'B')).toBeDefined();
expect(getKeytip(visibleKeytips, 'C')).toBeDefined();
expect(ktpTree.currentKeytip).toEqual(ktpTree.root);
// Call enterKeytipMode
ktpMgr.exitKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(false);
expect(onExit).toBeCalled();
ktpTree = layerRef.current!.getKeytipTree();
visibleKeytips = ktpLayer.state('visibleKeytips');
expect(visibleKeytips).toHaveLength(0);
expect(layerRef.current!.getCurrentSequence()).toEqual('');
expect(ktpTree.currentKeytip).toBeUndefined();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
ktpMgr.shouldEnterKeytipMode = false;
ktpMgr.enterKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(false);
ktpMgr.shouldEnterKeytipMode = true;
ktpMgr.enterKeytipMode();
expect(ktpLayer.state('inKeytipMode')).toEqual(true);
expect(onEnter).toBeCalled();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
let layerValue: KeytipLayerBase;
const onEnter = jest.fn();
const onExit = jest.fn();
describe('processTransitionInput', () => {
describe('with a default layer', () => {
beforeEach(() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
layerValue = layerRef.current!;
ktpTree = layerValue.getKeytipTree();
});
it('calls on enter keytip mode when we process alt + left win', () => {
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onEnter).toBeCalledWith({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
});
it('calls on exit keytip mode when we process alt + left win', () => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onExit).toBeCalled();
});
it('calls on exit keytip mode because we are going back when on the root', () => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Escape' });
expect(onExit).toBeCalled();
});
it('hitting Esc when on a root child node will go up to the root', () => {
const onReturn: jest.Mock = jest.fn();
const nodeC = ktpTree.getNode(keytipIdC)!;
nodeC.onReturn = onReturn;
ktpTree.currentKeytip = nodeC;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.root);
expect(onReturn).toBeCalled();
});
it('hitting Esc when on a child node will go up one level', () => {
const onReturn: jest.Mock = jest.fn();
const nodeD = ktpTree.getNode(keytipIdD)!;
nodeD.onReturn = onReturn;
ktpTree.currentKeytip = nodeD;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.getNode(keytipIdC));
});
});
it('can handle using a single key that is also a modifier for transitions', () => {
// Create layer
ktpLayer = mount(
<KeytipLayerBase
content="Alt Windows"
componentRef={layerRef}
keytipStartSequences={[{ key: 'Meta' }]}
onEnterKeytipMode={onEnter}
/>,
);
layerValue = layerRef.current!;
layerValue.processTransitionInput({ key: 'Meta' });
expect(onEnter).toBeCalledWith({ key: 'Meta' });
});
});
describe('processInput', () => {
beforeEach(() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
[uniqueIdE1]: { keytip: keytipE1, uniqueID: uniqueIdE1 },
[uniqueIdE2]: { keytip: keytipE2, uniqueID: uniqueIdE2 },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
layerValue = layerRef.current!;
ktpTree = layerValue.getKeytipTree();
});
// Processing keys tests
it('Processing a leaf node should execute it`s onExecute func and trigger onExitKeytipMode', () => {
const onExecute: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipB, onExecute }, uniqueIdB);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('b');
expect(onExecute).toBeCalled();
expect(onExit).toBeCalled();
expect(layerValue.getCurrentSequence().length).toEqual(0);
});
it('Processing a node with two keys should save sequence and wait for second key', () => {
const onExecuteE2: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipE2, onExecute: onExecuteE2 }, uniqueIdE2);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('e');
// We are still waiting for second key
expect(layerValue.getCurrentSequence().length).toEqual(1);
layerValue.processInput('2');
expect(onExecuteE2).toBeCalled();
expect(layerValue.getCurrentSequence().length).toEqual(0);
expect(onExit).toBeCalled();
});
it('Processing a node which is not leaf but its children are not in the DOM', () => {
const onExecute: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipB, onExecute, hasDynamicChildren: true }, uniqueIdB);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('b');
// Node B's onExecute should be called
expect(onExecute).toBeCalled();
// There is no more buffer in the sequence
expect(layerValue.getCurrentSequence().length).toEqual(0);
// We haven't exited keytip mode (current keytip is set to the matched keytip)
expect(ktpTree.currentKeytip.id).toEqual(keytipIdB);
});
it('with a persisted node will partially match the keytip but won`t show it', () => {
// Make E2 a persisted node
const nodeE2 = ktpTree.getNode(keytipIdE2)!;
nodeE2.persisted = true;
nodeE2.onExecute = jest.fn();
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('e');
// Only E1 should be visible
const visibleLayerKtps: IKeytipProps[] = ktpLayer.state('visibleKeytips');
expect(visibleLayerKtps).toHaveLength(1);
expect(visibleLayerKtps[0].content).toEqual('E1');
layerValue.processInput('2');
// E2 should be triggered
expect(nodeE2.onExecute).toBeCalled();
});
});
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
describe('with a default layer', () => {
beforeEach(() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
layerValue = layerRef.current!;
ktpTree = layerValue.getKeytipTree();
});
it('calls on enter keytip mode when we process alt + left win', () => {
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onEnter).toBeCalledWith({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
});
it('calls on exit keytip mode when we process alt + left win', () => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onExit).toBeCalled();
});
it('calls on exit keytip mode because we are going back when on the root', () => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Escape' });
expect(onExit).toBeCalled();
});
it('hitting Esc when on a root child node will go up to the root', () => {
const onReturn: jest.Mock = jest.fn();
const nodeC = ktpTree.getNode(keytipIdC)!;
nodeC.onReturn = onReturn;
ktpTree.currentKeytip = nodeC;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.root);
expect(onReturn).toBeCalled();
});
it('hitting Esc when on a child node will go up one level', () => {
const onReturn: jest.Mock = jest.fn();
const nodeD = ktpTree.getNode(keytipIdD)!;
nodeD.onReturn = onReturn;
ktpTree.currentKeytip = nodeD;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.getNode(keytipIdC));
});
});
it('can handle using a single key that is also a modifier for transitions', () => {
// Create layer
ktpLayer = mount(
<KeytipLayerBase
content="Alt Windows"
componentRef={layerRef}
keytipStartSequences={[{ key: 'Meta' }]}
onEnterKeytipMode={onEnter}
/>,
);
layerValue = layerRef.current!;
layerValue.processTransitionInput({ key: 'Meta' });
expect(onEnter).toBeCalledWith({ key: 'Meta' });
});
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
beforeEach(() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
layerValue = layerRef.current!;
ktpTree = layerValue.getKeytipTree();
});
it('calls on enter keytip mode when we process alt + left win', () => {
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onEnter).toBeCalledWith({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
});
it('calls on exit keytip mode when we process alt + left win', () => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onExit).toBeCalled();
});
it('calls on exit keytip mode because we are going back when on the root', () => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Escape' });
expect(onExit).toBeCalled();
});
it('hitting Esc when on a root child node will go up to the root', () => {
const onReturn: jest.Mock = jest.fn();
const nodeC = ktpTree.getNode(keytipIdC)!;
nodeC.onReturn = onReturn;
ktpTree.currentKeytip = nodeC;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.root);
expect(onReturn).toBeCalled();
});
it('hitting Esc when on a child node will go up one level', () => {
const onReturn: jest.Mock = jest.fn();
const nodeD = ktpTree.getNode(keytipIdD)!;
nodeD.onReturn = onReturn;
ktpTree.currentKeytip = nodeD;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.getNode(keytipIdC));
});
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
layerValue = layerRef.current!;
ktpTree = layerValue.getKeytipTree();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onEnter).toBeCalledWith({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Meta', modifierKeys: [KeyCodes.alt] });
expect(onExit).toBeCalled();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
ktpTree.currentKeytip = ktpTree.root;
layerValue.processTransitionInput({ key: 'Escape' });
expect(onExit).toBeCalled();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
const onReturn: jest.Mock = jest.fn();
const nodeC = ktpTree.getNode(keytipIdC)!;
nodeC.onReturn = onReturn;
ktpTree.currentKeytip = nodeC;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.root);
expect(onReturn).toBeCalled();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
const onReturn: jest.Mock = jest.fn();
const nodeD = ktpTree.getNode(keytipIdD)!;
nodeD.onReturn = onReturn;
ktpTree.currentKeytip = nodeD;
layerValue.processTransitionInput({ key: 'Escape' });
expect(ktpTree.currentKeytip).toEqual(ktpTree.getNode(keytipIdC));
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
// Create layer
ktpLayer = mount(
<KeytipLayerBase
content="Alt Windows"
componentRef={layerRef}
keytipStartSequences={[{ key: 'Meta' }]}
onEnterKeytipMode={onEnter}
/>,
);
layerValue = layerRef.current!;
layerValue.processTransitionInput({ key: 'Meta' });
expect(onEnter).toBeCalledWith({ key: 'Meta' });
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
beforeEach(() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
[uniqueIdE1]: { keytip: keytipE1, uniqueID: uniqueIdE1 },
[uniqueIdE2]: { keytip: keytipE2, uniqueID: uniqueIdE2 },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
layerValue = layerRef.current!;
ktpTree = layerValue.getKeytipTree();
});
// Processing keys tests
it('Processing a leaf node should execute it`s onExecute func and trigger onExitKeytipMode', () => {
const onExecute: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipB, onExecute }, uniqueIdB);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('b');
expect(onExecute).toBeCalled();
expect(onExit).toBeCalled();
expect(layerValue.getCurrentSequence().length).toEqual(0);
});
it('Processing a node with two keys should save sequence and wait for second key', () => {
const onExecuteE2: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipE2, onExecute: onExecuteE2 }, uniqueIdE2);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('e');
// We are still waiting for second key
expect(layerValue.getCurrentSequence().length).toEqual(1);
layerValue.processInput('2');
expect(onExecuteE2).toBeCalled();
expect(layerValue.getCurrentSequence().length).toEqual(0);
expect(onExit).toBeCalled();
});
it('Processing a node which is not leaf but its children are not in the DOM', () => {
const onExecute: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipB, onExecute, hasDynamicChildren: true }, uniqueIdB);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('b');
// Node B's onExecute should be called
expect(onExecute).toBeCalled();
// There is no more buffer in the sequence
expect(layerValue.getCurrentSequence().length).toEqual(0);
// We haven't exited keytip mode (current keytip is set to the matched keytip)
expect(ktpTree.currentKeytip.id).toEqual(keytipIdB);
});
it('with a persisted node will partially match the keytip but won`t show it', () => {
// Make E2 a persisted node
const nodeE2 = ktpTree.getNode(keytipIdE2)!;
nodeE2.persisted = true;
nodeE2.onExecute = jest.fn();
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('e');
// Only E1 should be visible
const visibleLayerKtps: IKeytipProps[] = ktpLayer.state('visibleKeytips');
expect(visibleLayerKtps).toHaveLength(1);
expect(visibleLayerKtps[0].content).toEqual('E1');
layerValue.processInput('2');
// E2 should be triggered
expect(nodeE2.onExecute).toBeCalled();
});
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
// Add keytips to the manager
ktpMgr.keytips = {
[uniqueIdB]: { keytip: keytipB, uniqueID: uniqueIdB },
[uniqueIdC]: { keytip: keytipC, uniqueID: uniqueIdC },
[uniqueIdD]: { keytip: keytipD, uniqueID: uniqueIdD },
[uniqueIdE1]: { keytip: keytipE1, uniqueID: uniqueIdE1 },
[uniqueIdE2]: { keytip: keytipE2, uniqueID: uniqueIdE2 },
};
ktpMgr.persistedKeytips = { [uniqueIdG]: { keytip: keytipG, uniqueID: uniqueIdG } };
// Create layer
ktpLayer = mount(
<KeytipLayerBase
componentRef={layerRef}
content="Alt Windows"
onEnterKeytipMode={onEnter}
onExitKeytipMode={onExit}
/>,
);
layerValue = layerRef.current!;
ktpTree = layerValue.getKeytipTree();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
const onExecute: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipB, onExecute }, uniqueIdB);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('b');
expect(onExecute).toBeCalled();
expect(onExit).toBeCalled();
expect(layerValue.getCurrentSequence().length).toEqual(0);
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
ArrowFunction |
() => {
const onExecuteE2: jest.Mock = jest.fn();
ktpTree.addNode({ ...keytipE2, onExecute: onExecuteE2 }, uniqueIdE2);
ktpTree.currentKeytip = ktpTree.root;
layerValue.processInput('e');
// We are still waiting for second key
expect(layerValue.getCurrentSequence().length).toEqual(1);
layerValue.processInput('2');
expect(onExecuteE2).toBeCalled();
expect(layerValue.getCurrentSequence().length).toEqual(0);
expect(onExit).toBeCalled();
} | Augani/fluentui | packages/react/src/components/KeytipLayer/KeytipLayer.test.tsx | TypeScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.