lang
stringclasses 10
values | seed
stringlengths 5
2.12k
|
|---|---|
typescript | <path d="M5 12a1 1 0 102 0V6.414l1.293 1.293a1 1 0 001.414-1.414l-3-3a1 1 0 00-1.414 0l-3 3a1 1 0 001.414 1.414L5 6.414V12zm10-4a1 1 0 10-2 0v5.586l-1.293-1.293a1 1 0 00-1.414 1.414l3 3a1 1 0 001.414 0l3-3a1 1 0 00-1.414-1.414L15 13.586V8z" />
</svg>
);
};
export default SwitchVertical;
|
typescript | <Box marginX={4}>
<Text
as="div"
fontSize="lg"
fontFamily={`"Noto Sans JP", sans-serif`} |
typescript | while (queue.length > 0) { // go through that queue
const edge = queue.pop(); // extract the needed geometric entities
const a = edge.a;
const c = edge.b;
let abc = null, cda = null;
try { // be careful when getting the hypothetical cross edge
abc = triangleOf(c, a) |
typescript | ticker.tick()
yield d.getValue()
}
} finally {
untap()
}
}
|
typescript | const cells: Cell<CellValueType>[][] = [];
this.cellValues
.forEach((row, rowIndex) => {
const cellRow: Cell<CellValueType>[] = [];
row.forEach((cellValue, collIndex) => {
cellRow.push({
index: {row: rowIndex, col: collIndex},
value: cellValue,
position: {top: this.rowPosition(rowIndex), left: this.colPosition(collIndex)},
size: {height: this.rowHeight(rowIndex), width: this.colWidth(collIndex)},
hover: false,
}); |
typescript | import { User } from './../auth/user.entity';
import {
Body,
Controller,
Delete,
Get,
Param,
ParseIntPipe,
Patch,
Post,
Query,
UsePipes, |
typescript | providers: [WallService]
});
});
it('should be created', inject([WallService], (service: WallService) => {
expect(service).toBeTruthy();
})); |
typescript | nctId: string;
wikiPage: SuggestedLabelsQuery_study_wikiPage | null;
}
export interface SuggestedLabelsQuery {
/**
* Searches params by searchHash on server and `params` argument into it
*/
search: SuggestedLabelsQuery_search | null;
study: SuggestedLabelsQuery_study | null;
}
export interface SuggestedLabelsQueryVariables {
searchHash: string;
nctId: string; |
typescript | posts and much more
</p>
<button className="btn btn--blue" onClick={handleLogin}>
Login now
</button>
</div>
</div>
</>
);
};
export const getServerSideProps = wrapper.getServerSideProps(async ctx => { |
typescript | /// <reference types="node" />
export declare const MAX_FILE_SIZE: number;
export declare const isText: (filename: string, buffer: Buffer) => true | Promise<unknown>;
export declare const isTooBig: (buffer: Buffer) => boolean;
//# sourceMappingURL=is-text.d.ts.map |
typescript | .compileComponents();
}));
beforeEach(() => {
fixture = TestBed.createComponent(EvaluacionEstudianteComponent);
component = fixture.componentInstance;
fixture.detectChanges();
});
it('should create', () => {
expect(component).toBeTruthy();
}); |
typescript |
export class InternalServerErrorException extends HttpException {
constructor(public readonly message: string) {
super(message, HttpStatus.INTERNAL_SERVER_ERROR)
}
} |
typescript | (grow ? 1 : -1) *
((fifthGuy.originalRadius - finalRadius) / 5) *
timeIncrement;
baton.position.zRotation += fifthGuy.angularVelocity * timeIncrement;
fifthGuy.angularVelocity += ((grow ? 1 : -1) * timeIncrement) / 5;
} else {
baton.position.zRotation += finalVelocity * timeIncrement;
}
baton.position.x =
fifthGuy.batonRadius * -Math.cos(baton.position.zRotation) + 32; |
typescript | res.json({
authentication: jwtToken,
});
},
);
route.post(
'/api/register-local',
checkSchema(UserLoginValidationSchema),
async (req: Request, res: Response) => {
const result = validationResult(req);
if (!result.isEmpty()) { |
typescript | width: 16,
height: 16,
viewBox: '0 0 16 16',
children: (
<> |
typescript | },
artist: {
fontSize: 24,
fontWeight: '600',
color: '#AEAEB2',
textTransform: 'uppercase',
marginBottom: 16,
paddingLeft: sidePadding,
paddingRight: sidePadding,
},
description: {
marginTop: 0,
fontSize: 18, |
typescript | }
}
function toApiLocation(source: types.SourceLocation, lineOffset: number): Location {
return {
start: toPosition(source.start, lineOffset),
end: toPosition(source.end, lineOffset),
};
}
function toPosition(source: Position, lineOffset: number): Position {
return {
column: source.column, |
typescript | },
[CloudInitField.AUTH_KEYS]: {
value: [],
},
},
error: null,
isValid: true,
hasAllRequiredFilled: true,
isLocked: false,
isHidden: data.data.isProviderImport && data.data.isSimpleView,
isCreateDisabled: false,
isUpdateDisabled: false,
isDeleteDisabled: false, |
typescript | import { Attr } from '../attr';
import { Highlighter } from './index';
export interface StrokeHighlighterOptions {
padding?: number;
rx?: number;
ry?: number;
attrs?: Attr.SimpleAttrs;
}
export declare const stroke: Highlighter.Definition<StrokeHighlighterOptions>;
|
typescript | styleUrls: ['./upload-csv.component.scss']
})
export class UploadCsvComponent implements OnInit {
@Output()
public changeFileEmitter = new EventEmitter();
@Input()
public loading: boolean;
@Input() |
typescript | };
let method = 'patch';
let endpoint = 'products/' + params.id + '/attributes/' + params.attribute_id;
let dataQuery = data1;
let paramQuery = {};
runServiceQuery([method, endpoint, dataQuery, paramQuery, res]);
|
typescript | const builder = new FilterBuilder(new FilterValidator(subCommand))
let resource: string
switch (subCommand.getValue()) {
case AwsSubCommands.EBS:
resource = 'volume-id'
break
case AwsSubCommands.EC2:
resource = 'instance-id'
break
case AwsSubCommands.RDS: |
typescript | </FormGroup>
</Callout>
<br />
<Callout>
<FormGroup label={electronLoggingLabel}>
<Checkbox
checked={isEnablingElectronLogging}
label="Enable advanced Electron logging." |
typescript |
fetchWorkflowInitData = async () => {
const result = await getWorkflowInitState({workflowId: this.props.workflowId})
if (result.code === 0) {
this.setState({workflowResult: result.data.value});
} else {
message.error(result.msg);
}
}
|
typescript | const getListUseCase = new GetListFillingsCase(
postgresFillingRepository
)
const getListFillingsController = new GetListFillingsController(
getListUseCase
)
export { getListUseCase, getListFillingsController } |
typescript | import { StringToDatePipe } from './string-to-date.pipe';
describe('StringToDatePipe', () => {
it('create an instance', () => {
const pipe = new StringToDatePipe();
expect(pipe).toBeTruthy();
});
});
|
typescript | export { AppStore } from './app-store'
export * from './dark-sky-store'
export * from './upcoming-store'
export * from './board-game-geek-store'
export * from './rss-store'
export * from './pingdom-store' |
typescript | import { TestBed, inject } from '@angular/core/testing';
import { SwathResultService } from './swath-result.service';
describe('SwathResultService', () => {
beforeEach(() => {
TestBed.configureTestingModule({
providers: [SwathResultService]
});
});
it('should be created', inject([SwathResultService], (service: SwathResultService) => {
expect(service).toBeTruthy();
})); |
typescript |
id : number,
parent_id : number,
company_id : number,branch_id:number,
author_id : number,
name : string,
code : string,
type : string,
is_percentage : boolean,
amount : number,
limit : number, |
typescript | variant={isSizeXS ? "body2" : "body1"}
/>
<ButtonLinks
link={props.link}
github={props.github}
buttons={
props.certificate && [ |
typescript | export * from "./applyPhpConstants";
export * from "./applyPhpFunctions";
export * from "./applyPromptsToTemplates";
export * from "./applySlug";
export * from "./copyTemplates";
export * from "./installPlugin";
export * from "./execute";
export * from "./program";
export * from "./prompt";
|
typescript | name: 'Foo',
ref: myObj,
inject: [inject],
// action: DI.ACTIONS.NONE
}).set({ |
typescript | export declare const cibCreativeCommonsNcJp: string[]; |
typescript | export { default as Secondary } from './Secondary';
export { default as Error } from './Error';
export { default as Success } from './Success';
export { default as Primary } from './Primary';
export { default as Warning } from './Warning';
export { default as Gray } from './Gray';
|
typescript | 6,
16,
20,
11,
16,
10,
19,
5,
18]);
width = 128;
|
typescript | }
});
return item;
},
find(query: object) { |
typescript |
let cbounds: { start: number, end: number } = { start: Math.floor(x(domain.start)), end: Math.floor(x(domain.end)) };
let retval = initialPreRenderedValues(cbounds);
data.forEach((point: BigWigData): void => {
let cxs: number = Math.floor(x(point.start < domain.start ? domain.start : point.start));
let cxe: number = Math.floor(x(point.end > domain.end ? domain.end : point.end));
if (point.value < retval[cxs].min) {
retval[cxs].min = point.value;
}
if (point.value > retval[cxs].max) {
retval[cxs].max = point.value;
}
for (let i: number = cxs + 1; i <= cxe; ++i) {
retval[i].min = point.value; |
typescript | import type { Meta } from "@storybook/react";
export default {
title: "Pages/Dashboard Shell",
component: DashboardShellComponent,
decorators: [],
} as Meta; |
typescript | EXAMPLE_APP_WITH_ENTITY,
history,
true
),
],
EXAMPLE_APP.id,
],
[ |
typescript | export interface IWeatherParam {
key: string,
city: number,
extensions: "base" | "all",
output: "JSON" | "XML"
}
export interface IWeatherRequest {
status: "0" | "1" // 值为0或1 1：成功；0：失败
count: number // 返回结果总数目
info: string // 返回的状态信息
infocode: string // 返回状态说明,10000代表正确
lives?: { // 实况天气数据信息
province: string // 省份名 |
typescript | dtTrigger: Subject<any> = new Subject();
constructor(
private service: CommonService,
public router: Router,
public toastr : ToastrService
){
}
ngOnInit(): void {
this.dtOptions = {
pagingType: 'full_numbers'
}; |
typescript | import rootReducer from './rootReducer';
export type TAppState = ReturnType<typeof rootReducer>;
declare module '@ag/core' {
export interface IGERules {
straightup: IGERulesDetails;
straightupx1: IGERulesDetails;
straightupx2: IGERulesDetails;
straightupx3: IGERulesDetails;
col_doz: IGERulesDetails;
gamelimit: IGERulesDetails;
evenchances: IGERulesDetails;
col: IGERulesDetails; |
typescript |
export const loader: LoaderFunction = async () => {
return redirect("https://api.nitropay.com/v1/ads-1043.txt", 301);
};
export const headers: HeadersFunction = () => {
return {
"cache-control": "s-maxage=360, stale-while-revalidate", |
typescript | */
$maxRetries?: number;
/**
* An object that may be queried to determine if the underlying operation has been aborted.
*
* @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
*/ |
typescript | * via the `patternProperty` "^[a-z]{2}$".
*
* This interface was referenced by `undefined`'s JSON-Schema definition
* via the `patternProperty` "^[a-z]{2}$".
*
* This interface was referenced by `undefined`'s JSON-Schema definition
* via the `patternProperty` "^[a-z]{2}$".
*/
[k: string]: string;
}; |
typescript | country: string;
houseNumber: string;
street: string;
postCode: string;
} |
typescript | _templet.offAll();
complete && complete(_templet);
});
_templet.on(Laya.Event.ERROR, this, () => {
this.templetLoad[_key] = false;
error && error(skFile);
});
_templet.loadAni(skFile);
}
|
typescript |
export default (request: Request, response: Response, next: any) => {
const authHeader = request.headers.authorization;
if(!authHeader)
return response.status(401).send({ error: "No token provided!" });
const parts = authHeader.split(' ');
if(parts.length !== 2)
return response.status(401).send({ error: "Token error!" });
const [ scheme, token ] = parts; |
typescript | filenames: files.FullFilePath[],
sourceDir: files.SourceDir,
tagMapper: TagMapper
): Promise<ast.NodeList[]> {
const result = []
const parser = new Parser(tagMapper)
for (const filename of filenames) {
const content = await fs.readFile(sourceDir.joinFullFile(filename).platformified(), {
encoding: "utf8",
})
result.push(parser.parse(content, new files.Location(sourceDir, filename, 1))) |
typescript | },
{
item_name: 'Kit',
defindex: 6523,
proper_name: false
},
],
particles: [
{
name: 'Circling TF Logo', |
typescript | return JSON.parse(decompressFromUTF16(serializedState)) as ISavedState;
} catch (err) {
console.log("error");
return undefined;
}
};
export const saveState = (state: IGlobalState) => {
try {
const stateToBeSaved: ISavedState = {
playgroundEditorValue: state.playgroundEditorValue,
};
const serialized = compressToUTF16(JSON.stringify(stateToBeSaved));
localStorage.setItem("storedState", serialized);
} catch (err) { |
typescript |
const NotFoundPage = () => (
<Layout>
<Heading level="h1">NOT FOUND</Heading>
<p>You just hit a route that doesn’t exist…the sadness.</p>
</Layout>
)
export default NotFoundPage |
typescript | import {changelog} from "./config-change-log";
import {components} from "./config-compoennts";
import {api} from "./config-api";
export default FopsConfig.create({
pages,
components, |
typescript | *
*/
export class LoggedError extends Error {
/**
* @property logged
*/
logged = false;
constructor(error: LoggerMessage, level: number = LOGGER_LEVELS.ERROR) {
super(error instanceof Error ? error.message : error);
this.logged = error instanceof LoggedError && error.logged;
if (!this.logged)
getLogger().report(error, level);
}
} |
typescript | import React, { useMemo, useState } from 'react'
import clsx from 'clsx'
import { createStyles, Drawer, isWidthDown, Theme, withWidth } from '@material-ui/core'
import { makeStyles } from '@material-ui/core/styles'
import { breakpoints } from '../../theme/theme' |
typescript | //let ctx = model.SelectCommand(method);
//if (ctx == null)
// continue;
let output_args: string [] = [];
output_args.push("");
if(needUpdate) {
output_args.push(" with self.argument_context('" + model.Command_Name.replace(/ create/g, " update") + "') as c:");
} else {
output_args.push(" with self.argument_context('" + model.Command_Name + "') as c:");
}
let hasParam = false; |
typescript | }
const SearchSessionContext = React.createContext<State>({
searchSessionId: undefined,
});
export interface SearchSessionProps {
searchSessionId: string; |
typescript | type ButtonLinkProps = Omit<ComponentProps<typeof Link>, "to" | "className"> &
({ to?: never; href: string } | { to: string; href?: never });
export default function ButtonLink({
to,
href,
children,
...rest
}: ButtonLinkProps) {
if (href)
return (
<a href={href} className={styles.buttonLink} {...rest}> |
typescript | export { useCountUp } from './hooks'
export { CountUp } from './components'
|
typescript | import { ExpoConfig } from '@expo/config-types';
import { AndroidManifest } from './Manifest';
export declare const withAdMob: import("..").ConfigPlugin<void>;
export declare function getGoogleMobileAdsAppId(config: Pick<ExpoConfig, 'android'>): string | null;
export declare function getGoogleMobileAdsAutoInit(config: Pick<ExpoConfig, 'android'>): boolean;
export declare function setAdMobConfig(config: Pick<ExpoConfig, 'android'>, androidManifest: AndroidManifest): AndroidManifest;
|
typescript |
layerRef.current = leafletRef.current
.layerGroup()
.addTo(mapRef.current);
customers.forEach((customer) => {
if (!customer.longitude || !customer.latitude) {
return;
}
leafletRef.current
.marker([customer.latitude, customer.longitude], {
icon:
customer.score < 25
? redIcon
: customer.score < 75
? yellowIcon |
typescript | import { TodoListESelect, TodoListECreateProperties, TodoListEUpdateColumns, TodoListEUpdateProperties, TodoListEId, TodoListGraph, QTodoList } from './qtodolist';
import { IDuo, IEntityCascadeGraph, IEntityCreateProperties, IEntityIdProperties, IEntitySelectProperties, IEntityUpdateColumns, IEntityUpdateProperties, IQEntity } from '@airport/air-control';
import { Duo } from '@airport/check-in';
import { EntityId as DbEntityId } from '@airport/ground-control';
export declare class SQDIDuo<Entity, EntitySelect extends IEntitySelectProperties, EntityCreate extends IEntityCreateProperties, EntityUpdateColumns extends IEntityUpdateColumns, EntityUpdateProperties extends IEntityUpdateProperties, EntityId extends IEntityIdProperties, EntityCascadeGraph extends IEntityCascadeGraph, IQE extends IQEntity<Entity>> extends Duo<Entity, EntitySelect, EntityCreate, EntityUpdateColumns, EntityUpdateProperties, EntityId, EntityCascadeGraph, IQE> {
constructor(dbEntityId: DbEntityId);
}
export interface IBaseTodoItemDuo extends IDuo<ITodoItem, TodoItemESelect, TodoItemECreateProperties, TodoItemEUpdateColumns, TodoItemEUpdateProperties, TodoItemEId, TodoItemGraph, QTodoItem> {
}
export declare class BaseTodoItemDuo extends SQDIDuo<ITodoItem, TodoItemESelect, TodoItemECreateProperties, TodoItemEUpdateColumns, TodoItemEUpdateProperties, TodoItemEId, TodoItemGraph, QTodoItem> implements IBaseTodoItemDuo {
static diSet(): boolean;
constructor();
}
export interface IBaseTodoListDuo extends IDuo<ITodoList, TodoListESelect, TodoListECreateProperties, TodoListEUpdateColumns, TodoListEUpdateProperties, TodoListEId, TodoListGraph, QTodoList> {
} |
typescript | export const fileWord16F: string;
|
typescript | exportCsvData.headings['TotalDur'] = { title: 'TotalDur', placeholder: this.common.formatTitle(key) };
} else {
exportCsvData.headings[key.replace(/[.\s]/g, '')] = { title: key.replace(/[.\s]/g, ''), placeholder: this.common.formatTitle(key) };
}
}
}
exportCsvData.Columns = this.callKpiList.map(ele => { |
typescript | import { MdeModule } from '../../visuals/mde/mde.module';
import { MdViewComponent } from './md-view.component';
@NgModule({
declarations: [
CardViewPage, MdViewComponent
],
imports: [
IonicPageModule.forChild(CardViewPage), MdeModule
],
exports: [
CardViewPage
]
}) |
typescript | <gh_stars>0
import { installable } from '../utils';
import _Uploader from './Uploader';
const Uploader = installable(_Uploader);
export default Uploader;
export { Uploader };
|
typescript | @Component({
selector: 'blog-component',
directives: [ROUTER_DIRECTIVES, NavigationComponent],
pipes: [TranslatePipe],
template: require('./blog.component.html')
})
export class BlogComponent {
constructor() {}
}
|
typescript | <gh_stars>0
import {
BaseEntity,
PrimaryGeneratedColumn,
Column,
Entity,
Unique, |
typescript | *
* @preferred
* @module fly/fetch
*/
/**
* Fly augmented Request, adds extra relevant fields for proxy level
* Requests. |
typescript | import { IBaseEventHandling } from "@tobydux/ste-core";
import { IEventHandler } from "./IEventHandler";
/**
* Indicates the object is capable of handling named events.
*/
export interface IEventHandling<TSender, TArgs>
extends IBaseEventHandling<IEventHandler<TSender, TArgs>> {}
|
typescript | cmd.config.fs.inject = akala.introspect.getParamNames(func).map(v =>
{
if (v == '$container')
return v;
return 'param.' + (n++)
}
); |
typescript |
@Component({
selector: 'rente-can-not-bargain-dialog',
templateUrl: './can-not-bargain-dialog.component.html',
styleUrls: ['./can-not-bargain-dialog.component.scss']
})
export class CanNotBargainDialogComponent implements OnInit {
public closeState: string;
constructor(
public dialog: MatDialog,
public dialogRef: MatDialogRef<CanNotBargainDialogComponent> |
typescript | discord_id
username
discriminator
twitter_name
avatar
}
suggester_discord_user {
discord_id |
typescript | return {
InstanceOfRequests: this.numberOfRequests,
AverageTime: `${(this.averageTime/this.numberOfRequests).toFixed(2)}ms`,
TimeSpent: `${(Math.abs(this.endTime - this.startTime)).toFixed(2)}ms`,
}
}
route(router: Router) {
router.get('/api/health', (context) => { |
typescript | /**
* @Attribute DBEndpointId: DB cluster endpoint ID. E.g. pe-xxxxxxxx.
*/
public readonly attrDbEndpointId: any;
/**
* Create a new `ALIYUN::POLARDB::DBClusterEndpoint`.
*
* @param scope - scope in which this resource is defined
* @param id - scoped id of the resource
* @param props - resource properties
*/
constructor(scope: ros.Construct, id: string, props: DBClusterEndpointProps, enableResourcePropertyConstraint:boolean = true) {
super(scope, id);
|
typescript | <Image
src={user.avatar_url}
layout="fill"
alt={user.name}
className="rounded-xl"
/>
</div>
<div className="flex flex-col flex-1 gap-4 mt-5 sm:mt-0">
<div className="flex flex-col gap-4 md:flex-row md:justify-between">
<div className="flex flex-col">
<h1 className="text-2xl text-gray-800">{user.name}</h1>
<span className="text-lg text-gray-700">{user.title}</span> |
typescript | // eslint-disable-next-line quotes
this.gameInfo.innerHTML = "Waiting for your opponent's move ...";
}
}
|
typescript | enterFrom="transform opacity-0 scale-95"
enterTo="transform opacity-100 scale-100"
leave="transition ease-in duration-75"
leaveFrom="transform opacity-100 scale-100"
leaveTo="transform opacity-0 scale-95"
>
<Menu.Items
static
className="origin-top-right absolute right-0 mt-2 w-48 rounded-md shadow-lg py-1 bg-white ring-1 ring-black ring-opacity-5 focus:outline-none" |
typescript | ) => {
const { hall, session, fields } = getState();
await flush(dispatch, getState);
const params = { runno, fileno, hall, session, fields };
fetchWithNewLocation(params, dispatch);
// const { newRun, newFile } = await fetchWithNewLocation(params);
// dispatch(setLocation(newRun, newFile, hall));
}; |
typescript | /**
* Clamps a number between min and max
* @param value The value to clamp
* @param min The minimum value to clamp to
* @param max The maximum value to clamp to
*/
public static clamp(value: number, min: number, max: number): number {
if (value < min) {
return min;
}
if (value > max) {
return max;
} |
typescript |
import { XlsxDirective } from './xlsx.directive';
const COMPONENTS = [XlsxDirective];
@NgModule({
imports: [CommonModule], |
typescript | import YjTable from './src/table.vue'
export default YjTable
|
typescript | import {IndexRoutingModule} from './index-routing.module';
import {IndexComponent} from './index.component';
import {ShareModule} from '../../share/share.module';
@NgModule({
imports: [
ShareModule,
IndexRoutingModule,
],
declarations: [
IndexComponent, |
typescript | export * from './base-edge-construct';
export * from './http-headers';
export * from './edge-function';
export * from './lambda-function-association';
export * from './edge-lambda';
export * from './edge-role';
export * from './with-configuration';
|
typescript | import { bnsCodec } from "./bnscodec";
import { BnsConnection } from "./bnsconnection";
/**
* A helper to connect to a bns-based chain at a given url
*/
export function createBnsConnector(url: string, expectedChainId?: ChainId): ChainConnector<BnsConnection> {
return {
establishConnection: async () => BnsConnection.establish(url),
codec: bnsCodec,
expectedChainId: expectedChainId,
};
}
|
typescript | import { merge } from '../helper';
merge(
/^\/hentaiathome\.php/,
undefined,
{
'Hentai@Home Clients': 'Hentai@Home 客户端',
},
[
[
/All schedule times are in UTC\. As a reference, the current UTC time is (.*?)\./,
(s, t) => `所有计划时间均为 UTC。作为参考，现在的 UTC 时间是 ${t.replace(/\s/g, '\xA0')}。`,
], |
typescript | @Directive({
selector: '[myHighlight]'
})
export class HighlightDirective {
elem:any;
constructor(el: ElementRef) {
this.elem = el;
el.nativeElement.style.backgroundColor = 'red';
console.log('Directive > ++'); |
typescript | export * from './login-path'
export * from './signup-path'
export * from './survey-path'
export * from './survey-result-path'
|
typescript | type ExampleTypeDefinition = 'Hello' |
typescript | this.data = data
this.changes = new Map<MemberName, Observer>()
this.conflicts = new Map<MemberName, ObjectRevision>()
if (Dbg.isOn)
Object.freeze(this)
}
}
// ObjectHolder |
typescript | version https://git-lfs.github.com/spec/v1
oid sha256:6d7e4e3e14975ee49c92f1e636b196396eedfd39647e56739c48a4aa72c47e86
size 520008
|
typescript | export default function NewWord({wordGroup}: Props): ReactElement {
const dispatch = useDispatch();
const [name, setName] = useState('');
const onCreate = useCallback(() => {
if(name.length > 0) {
dispatch(createWord(wordGroup, name));
setName('');
dispatch(loadWordGroups());
} |
typescript | hideProgressBar: false,
closeOnClick: true,
pauseOnHover: true,
draggable: true,
});
} catch (err) {
if (err instanceof Yup.ValidationError) {
const errors = getValidationErrors(err);
formRef.current?.setErrors(errors);
return;
}
|
typescript | await auth.configAuthentication('https://registry.npmjs.org', 'false');
expect(fs.statSync(rcFile)).toBeDefined();
let rc = readRcFile(rcFile);
expect(rc['@myscope:registry']).toBe('https://registry.npmjs.org/');
expect(rc['always-auth']).toBe('false');
});
it('Automatically configures GPR scope', async () => {
await auth.configAuthentication('npm.pkg.github.com', 'false');
expect(fs.statSync(rcFile)).toBeDefined();
let rc = readRcFile(rcFile);
expect(rc['@ownername:registry']).toBe('npm.pkg.github.com/');
expect(rc['always-auth']).toBe('false'); |
typescript | import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { UnauthenticatedComponent } from './unauthenticated.component';
import { RecognizedGuard } from '../../guards/recognized.guard';
const routes: Routes = [
{
path: '',
component: UnauthenticatedComponent, |
typescript | children?: React.ReactNode
/** Optional CSS class name */
className?: string
/** Disable rendering the header at all */
disableHeader?: boolean
/**
* Used to estimate the total height of a Table before all of its rows have actually been measured.
* The estimated total height is adjusted as rows are rendered.
*/
estimatedRowSize?: number
/** Optional custom CSS class name to attach to inner Grid element. */ |
typescript | }
}
export class PrinterProperty {
public static Barcode: string = "";
public static PrintableWidth: number = 0;
public static Cut: boolean = false;
public static CutSpacing: number = 0;
public static TearSpacing: number = 0;
public static ConnectType: number = 0; |
typescript | import { ReviewModel } from '../models/review.interface';
import { ReviewService } from '../services/review.service';
export declare class ReviewController {
private reviewService;
constructor(reviewService: ReviewService);
|
typescript | import React from "react";
import { Route, BrowserRouter } from 'react-router-dom';
import { Dashboard } from './pages';
const Routes = () => {
return (
<BrowserRouter>
<Route component={Dashboard} path="/" exact />
</BrowserRouter>
); |
typescript | }
up(): void {
console.log('we are opening the garage door');
}
down(): void {
throw new Error('Method not implemented.');
}
stop(): void {
throw new Error('Method not implemented.');
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.