lang
stringclasses 10
values | seed
stringlengths 5
2.12k
|
|---|---|
typescript | let text = yield page.headerText();
assert.equal(text, 'Title 2', 'header text is now "Title 2" ');
let queueSize = yield page.queueSize();
assert.equal(queueSize, 0);
});
test.it('should support adding items to a collection', function *() {
});
test.after(function*() {
yield driver.quit();
});
|
typescript |
const result = envVariable.parse("test{{FUNCTION_TEST}}function");
ava.true(result.includes(uuid));
});
test(`${namespace} - non-existent variable`, ava => {
const uuid = v4();
const envVariable = new EnvVariableParse({
STRING_TEST: uuid, |
typescript | }
function doDamage(circle: Phaser.Physics.Arcade.Sprite, enemy) {
let weapon = circle.getData("weapon");
let weaponOwner = weapon.owner;
// need to have an eye if this is a good tradeoff vs having more groups
if (weaponOwner.campID !== enemy.campID) {
let damage = weapon.amount;
let enemyStateHandler = enemy.stateHandler;
//Need this, otherwise all animation frames do damage
weapon.alreadyAttacked.push(enemy.id); |
typescript |
it('test sensibly bails if gets an old .snyk format', async () => {
const vulns2 = loadJson(
path.resolve(__dirname, '../../fixtures/test-jsbin-vulns-updated.json'),
);
try {
const config = await policy.load(
path.resolve(__dirname, '../../fixtures/old-snyk-config'),
);
const res = await config.filter(vulns2); |
typescript | const { fonts, addFont, removeFont } = useFontsState();
const handleFileUpload = (e: any) => {
[...e.target.files].forEach((file) => {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = (item) => {
if (item.target?.result) {
addFont({ |
typescript | const context = useContext(LocationContext)
const { location, getSnack } = context
const handleRandomize = () => {
const { pathname } = location as WindowLocation
if (pathname === "/random") {
getSnack()
} else {
navigate("/random")
}
}
return ( |
typescript | PostponedIndefinitely = "PostponedIndefinitely",
Active = "Active",
NoLongerOurProduct = "NoLongerOurProduct",
OutOfStockIndefinitely = "OutOfStockIndefinitely",
OutOfPrint = "OutOfPrint",
Inactive = "Inactive",
Unknown = "Unknown",
Remaindered = "Remaindered",
WithdrawnFromSale = "WithdrawnFromSale",
Recalled = "Recalled",
ActiveButNotSoldSeparately = "ActiveButNotSoldSeparately",
TemporarilyWithdrawnFromSale = "TemporarilyWithdrawnFromSale",
PermanentlyWithdrawnFromSale = "PermanentlyWithdrawnFromSale"
} |
typescript | name: 'emailConfirmed',
enumName: 'YesNo',
enum: accountApiEnums.YesNo,
dataType: 'string'
}),
new PageGridField({
name: 'status', |
typescript | export function findPrevious(terminal: any, term: string): boolean {
if (!terminal._searchHelper) {
terminal.searchHelper = new SearchHelper(terminal);
}
return (<SearchHelper>terminal.searchHelper).findPrevious(term);
};
export function apply(terminalConstructor) {
terminalConstructor.prototype.findNext = function(term) {
return findNext(this, term);
} |
typescript | err: SyntaxError | Error,
req: Request,
res: Response,
next: NextFunction
) => void
export type Wrapper = (
fn: Function
) => (req: Request, res: Response, next: NextFunction) => any
export type Logger = (r: Request, s: Response, n: NextFunction) => void
|
typescript | import { Moving } from "./moving";
const canvas = (<any>self).renderCanvas;
canvas.width = 800;
canvas.height = 800;
const bar = new Moving(canvas); |
typescript | import { NuxtAxiosInstance } from '@nuxtjs/axios';
let axios: NuxtAxiosInstance | null = null;
export function setAxios(nxtAxios: NuxtAxiosInstance): void {
axios = nxtAxios;
}
export { axios };
|
typescript | RealCoach3: number;
CreatedBy: number;
UpdatedBy: number;
constructor(Id: number, Area: number, Yard: number, YardArea: number, Class: number, ClassDay: string, ClassTime: string, Coach1: number, Coach2: number, Coach3: number, RealCoach1: number, RealCoach2: number, RealCoach3: number) { |
typescript | export type InstanceOf<A extends { new(...params: Array<any>): any }> =
A extends { new(...params: Array<any>): infer B }
? B
: never
|
typescript | $vendure: {
api: {
getFacet: jest.fn(() => ({
data: {
collections: [],
totalItems: 10,
items: [],
facetValues: []
}
}))
}
}
};
jest.mock('@vue-storefront/core', () => ({ |
typescript | <gh_stars>0
import React, { FC } from 'react';
import { ResponsiveContainerStyled } from './styles.ResponsiveContainer';
export interface PropsResponsiveContainer {
hideIn?: number;
showIn?: number;
} |
typescript |
function separator(): LogFragment {
const innerMarginStyle = getInnerMarginStyle();
return {
text: "\xa0| ", |
typescript |
return this;
}
lock(workerId: number): void {
this._locks[workerId] = true;
} |
typescript | import {Get} from "@tsed/schema";
import {Controller} from "@tsed/di";
import {MySocketService} from "../services/MySocketService";
@Controller("/")
export class MyCtrl {
constructor(private mySocketService: MySocketService) {
}
@Get("/allo")
allo() {
this.mySocketService.helloAll();
|
typescript |
it('can send a POST request', () => {
cy.origin('http://foobar.com:3500', () => {
cy.visit('http://www.foobar.com:3500/post-only', {
method: 'POST',
headers: {
'content-type': 'application/json', |
typescript | justify-content: center;
}
`)}
/* 480px - 639px */ |
typescript | }
set name(value: string) {
this._name = value;
}
set count(value: number) {
this._count = value; |
typescript | import { AcceptOnlyIntPositiveNumbersDirective } from './accept-only-int-positive-numbers.directive';
import { AcceptOnlyLettersAndIntNumbers } from './accept-only-letters-and-int-numbers.directive';
import { AcceptOnlyLetterDirective } from './accept-only-letters.directive';
import { AcceptOnlyPhoneNumbers } from './accept-only-phone-numbers.directive';
@NgModule({
imports: [],
declarations: [ |
typescript |
export class Nav extends React.Component<INavProps, {}> {
public render() {
return <nav className="pt-navbar pt-dark pt-fixed-top">
<div className="pt-navbar-group pt-align-left">
<div className="pt-navbar-heading">Blueprint Table preview</div>
</div>
<div className="pt-navbar-group pt-align-right"> |
typescript | import { PointContainer } from '../utils/pointContainer';
import { Palette } from '../utils/palette';
import { ImageQuantizerYieldValue } from './imageQuantizerYieldValue';
export declare abstract class AbstractImageQuantizer {
abstract quantize(pointContainer: PointContainer, palette: Palette): IterableIterator<ImageQuantizerYieldValue>; |
typescript |
@Component({
selector : 'app-concept-not-found',
template:
`
<p><b>Concepts Page Not Found</b></p>
`
})
|
typescript |
res.render("main", {
page: "my-account",
msgContent: "Contato excluído com sucesso!",
inputError: "",
msgType: "success",
contacts,
});
}
} |
typescript | import { transformCase } from '@priestine/case-transformer';
import { fromEnv } from '../utils/from-env.util';
import ProcessEnv = NodeJS.ProcessEnv;
export function updateConfigFromEnv(env: ProcessEnv) {
return ({ intermediate }: SemanticsCtx) => {
Object.keys(intermediate).forEach((key) => {
const envKey = transformCase(key)
.from.camel.to.snake.toString()
.toUpperCase();
const getFromEnv = fromEnv(env);
if (typeof intermediate[key] === 'number') {
intermediate[key] = Number.isInteger(intermediate[key]) |
typescript | wrapper.setProps({
in: false
})
await act(() => wait(50))
expect(call.mock.calls.length).toBe(3)
expect(call.mock.calls[0][0]).toBe('enterCancelled')
expect(call.mock.calls[1][0]).toBe('beforeLeave')
expect(call.mock.calls[2][0]).toBe('leave')
call.mockClear()
}) |
typescript | namespace Estella.Core {
export interface IEventEntityListService<T extends IEntity> {
getSource(): IEntityListService<T>;
getEntity(): T;
}
} |
typescript |
const itemNext = getByTestId('pagination-item-next')
const itemReturn = getByTestId('pagination-item-return')
const itemPage10 = getByTestId('pagination-item-10')
fireEvent.click(itemNext)
expect(handleOnChange).toHaveBeenLastCalledWith(2)
fireEvent.click(itemPage10)
expect(handleOnChange).toHaveBeenLastCalledWith(10)
fireEvent.click(itemReturn)
expect(handleOnChange).toHaveBeenLastCalledWith(9)
expect(handleOnChange).toHaveBeenCalledTimes(3)
})
|
typescript | import { BettererConstraintResult } from './constraint-result';
export function smaller(result: number, expected: number): BettererConstraintResult {
if (result === expected) {
return BettererConstraintResult.same;
}
if (result < expected) {
return BettererConstraintResult.better;
}
return BettererConstraintResult.worse;
}
|
typescript | export default ['video'];
|
typescript | export interface Contribution {
folderMap: FolderMap;
browserModules: Array<string>;
mainProcessModules: Array<string>;
}
export interface API {
contribute(sourceExtensionId :string, contribution: Contribution): void;
active() : boolean;
} |
typescript | // build query
let query =
'insert into alerts (service_id, summary, details, dedup_key) values '
const rows: Array<string> = []
for (let i = 0; i < count; i++) {
const summary = alertOptions.summary || c.word()
const details = alertOptions.details || c.sentence()
const dedupKey = 'manual:1:createManyAlerts_' + dedupIdx
rows.push(
`('${alertOptions?.serviceID}', '${summary}', '${details}', '${dedupKey}')`,
)
dedupIdx++
} |
typescript | it('should navigate to correct product when the id parameter changes', () => {
let expectedProduct: Product = MockProductService.testProducts[0];
// Setting this should cause anyone subscribing to the paramMap
// to update. Our `ProductProfileComponent` subscribes to that, so
// it should update right away.
activatedRoute.setParamMap({ id: expectedProduct._id }); |
typescript | import { IconDefinition } from '../types';
export declare const AmazonSquareFill: IconDefinition;
|
typescript | * @param {Number} x the cumulative distribution function argument
*
* @returns {Number} the cumulative distribution function evaluated at x
*/
cdf(x: number): number {
return (1.0 + this.erf(this.standardize(x) * Math.SQRT1_2)) / 2.0
}
/**
* Receives a floating-point number x and returns the value of the inverse of cumulative distribution function
* from a normal distribution with {@link mean} and {@link standardDeviation} evaluated at x. |
typescript | /* eslint-disable @typescript-eslint/no-unused-vars */
import { Injectable } from '@nestjs/common';
import { PrismaService } from 'src/prisma/prisma.service';
import { CreateFavoritosOnUsuarioDto } from './dto/create-favoritos-usuario.dto';
import { UpdateFavoritosOnUsuarioDto } from './dto/update-favoritos-usuario.dto';
import { FavoritosOnUsuario } from '@prisma/client';
@Injectable()
export class FavoritosUsuarioService {
constructor(private readonly prisma: PrismaService) {}
async create(createFavoritosOnUsuarioDto: CreateFavoritosOnUsuarioDto): Promise<FavoritosOnUsuario> { |
typescript | ChangeDetectionStrategy,
Component,
EventEmitter,
Input,
OnInit,
Output
} from '@angular/core';
|
typescript | scaleOutVerBottom,
scaleOutVerTop,
slideInBottom,
slideInTop,
slideOutBottom,
slideOutTop
} from '../../animations/main';
import { PlatformUtil } from '../../core/utils';
import { IgxOverlayOutletDirective } from '../../directives/toggle/toggle.directive'; |
typescript | setDifficulty(d as string)
}
const handleStartGame = () => {
dispatch(startGame(difficulty))
} |
typescript | import { injectable, inject } from 'tsyringe';
import ITasksRepository from '../repositories/ITasksRepository';
interface IRequest {
user_id: string;
task_id: string;
}
|
typescript | initialized = false;
contentLoaded = false;
collapsed: boolean = true;
@Output() loadContents = new EventEmitter();
toggle() {
this.collapsed = !this.collapsed;
if (!this.contentLoaded && !this.collapsed) {
this.loadContents.emit(); |
typescript | export * from './Tag';
export { default } from './Tag';
|
typescript | guild_id: string
prefix: string
}
export default async function getPrefixes (): Promise<Guild[]> {
const { data, error } = await supabase
.from<Guild>('guilds')
.select('guild_id, prefix')
if (error) {
throw error
}
|
typescript | export interface IUser {
type: string | 'User'
login: string
}
|
typescript | import { Pin20 } from "../../";
export = Pin20;
|
typescript | nonASCII++;
} else {
len++;
}
} |
typescript | const [user] = await connection("users")
.where("id", id)
.first()
.update({ name, email, username, password: password_hash })
.returning("*");
if (!user) {
return response.status(404).json({ message: "User not found!" });
}
return response.status(201).json(user);
} catch (err) {
console.log(err);
return response.status(400).send(); |
typescript | import Col from '@paljs/ui/Col';
import React from 'react';
import Box from './Box';
export default function Distribution() {
return (
<Container>
<h3>
<code>.around-</code>
</h3>
<Row>
<Col breakPoint={{ xs: 12 }}> |
typescript | export * from "./CompleteIcon";
export * from "./InfoIcon";
export * from "./NotAllowedIcon";
export * from "./NotAllowedInvertedIcon";
export * from "./WarningIcon";
export * from "./ArrowDropdownIcon";
export * from "./CheckboxIcon";
export * from "./CheckboxCheckedIcon"; |
typescript | import { PostsModule } from 'app/posts/posts.module';
import { CommonModule } from '@angular/common';
import { AlertService } from 'app/_services/alert.service';
import { AuthGuard } from './_guards/auth.guard';
import { AuthService } from './_services/auth.service';
import { UserService } from './_services/user.service';
import { ProfileComponent } from './profile/profile.component';
import { PostGuard } from './_guards/post.guard';
import { UploadComponent } from './upload/upload.component'; |
typescript | this.store.dispatch(updateApplicationIcon(applicationId, url));
}
getConfigData(manifestURL: string): Observable<config.ConfigData[]> {
const observableState = subscribeStore(this.store);
return observableState.pipe(
map(getApplications),
map(applications => applications.filter(
application => getApplicationManifestURL(application) === manifestURL) |
typescript |
export const ScrollWrapper: React.FC<React.HTMLAttributes<HTMLElement>> = ({
children,
}) => {
return <ScrollingProvider>{children}</ScrollingProvider>;
};
export default ScrollWrapper;
|
typescript | public readonly regexNonExact: RegExp | undefined;
public readonly timeOutLength: number | undefined;
// public readonly highlightActiveScope: boolean;
// public readonly showVerticalScopeLine: boolean;
// public readonly showHorizontalScopeLine: boolean;
// public readonly showBracketsInGutter: boolean;
// public readonly showBracketsInRuler: boolean;
// public readonly scopeLineRelativePosition: boolean;
// public readonly colors: string[]; |
typescript | layout: LayoutEnum;
groupbox: GroupboxEnum;
text?: DynamicValue<string>;
}
export interface MenditectDocumentationLinkerPreviewProps {
className: string;
style: string;
styleObject?: CSSProperties;
readOnly: boolean;
link: string; |
typescript | contactFormLink = !this.env.production && contactFormLinkDev ? contactFormLinkDev : this.env.contactFormLink;
constructor() {}
ngOnInit() {}
}
|
typescript | interface Message {
toGoogleAssistantSimple?(): Simple;
}
}
declare module '@jovotech/output/dist/types/models/QuickReply' { |
typescript | d="M16.164 14.561c-.17-.069-.328-.118-.488-.168l-.586-.119h-.1l-.437-.08c-.169 0-.368-.118-.368-.296 0-.179.288-.367.746-.367a.868.868 0 01.736.307.744.744 0 00.994.357.736.736 0 00.432-.709.73.73 0 00-.074-.282 2.042 2.042 0 00-1.333-.99v-.11a.742.742 0 00-.745-.743.747.747 0 00-.746.743v.11a2.051 2.051 0 00-1.382 1.149 1.621 1.621 0 00.12 1.417 1.985 1.985 0 001.292.881l.527.1c.286.033.566.103.835.207.06 0 .1 0 .1.159 0 .128-.289.366-.746.366a.868.868 0 01-.736-.317.745.745 0 00-.994-.347.726.726 0 00-.348.991c.177.341.45.623.785.813.174.097.357.176.547.237v-.01a.741.741 0 00.746.743.747.747 0 00.745-.743v-.109a1.87 1.87 0 001.492-1.713 1.6 1.6 0 00-1.014-1.477z"
fill={fill}
/>
</svg>
);
IconCoins.defaultProps = {
...iconDefaultProps,
};
|
typescript |
partsRoutes.get(
'/:id',
ensureAdminOrProvider,
listProviderPartsController.handle
) |
typescript | start: acc.get(parent)?.start || 0,
end: itemSize + (acc.get(parent)?.end || 0),
});
}
}
return acc;
},
new Map<
TreeItemWithLaneData,
{
start: number;
end: number;
}
>()
); |
typescript | <gh_stars>1-10
import { fetchFromBackend } from "."
export async function loadIngredients() {
return await fetchFromBackend("get", "/ingredients")
}
|
typescript | const protocol = protocolResolver(id);
const propKey = bitStream[Binary[protocol.keyType].read]();
const prop = protocol.keys[propKey];
const propData = protocol.properties[prop];
const value = readProp(bitStream, propData.type, propData.arrayIndexType); // bitStream[Binary[propData.type].read]()
|
typescript | import { EventEmitter } from 'events';
const Emitter = new EventEmitter();
export default Emitter; |
typescript | app.use(expressive.bodyParser.json());
app.get("/api/todos", async (req, res) => {
await res.json([{ name: "Buy some milk" }, {name: "Clean up the house!"}]);
});
app.get("/api/user/{user_id}", async (req, res) => {
await res.json([{ id: req.params.user_id, name: "<NAME>", phone: "12425323" }]);
}); |
typescript | export * from './widget_layout';
export * from './widget_style';
export * from './services-shim';
export * from './viewlist';
export * from './version';
export * from './utils';
export * from './registry';
|
typescript | import { TempleMessageType } from '../../types';
import { withUnlocked } from '../store';
import { getDApp, getNetworkRPC } from './dapp';
import { requestConfirm } from './requestConfirm';
import { ExtensionMessageType, ExtensionSignRequest, ExtensionSignResponse } from './typings';
const HEX_PATTERN = /^[0-9a-fA-F]+$/; |
typescript | var arr1 = [];
arr1.push("some");
arr1.push("more");
arr1.push("stuff");
var arr2 = ["hello","world"];
var arr3 = [];
arr3.push("banana") |
typescript |
const user = {
username: "username",
email: "<EMAIL>",
password: "password",
};
const anotherUser = {
username: "another_username",
email: "<EMAIL>",
password: "password",
} |
typescript |
export default function useMetaMaskOnboarding() {
const onboarding = useRef<MetaMaskOnboarding>();
const [isMetaMaskInstalled, isMetaMaskInstalledSet] = useState<boolean>();
useEffect(() => {
if (typeof window === "undefined") {
return;
} |
typescript | renderer: chooseListrRenderer()
}
);
}
}
],
{
// PARENT_TASK OPTIONS: (Git Validation/Initialization) |
typescript | const verifyTokenCtrl = async (req: Request, res: Response) => {
try {
const { token } = req.body;
const decoded: any = jwt.verify(token, process.env.SECRET_KEY, (err) => {
if (err) return res.status(400).json({ success: false, errorCode: "InvalidToken" });
});
res.status(200).json({
success: true,
msg: "Verify token successful",
decoded,
});
} catch (error) { |
typescript | import NavSidebar from "./NavSidebar";
import Drawer from "./Drawer";
type PropsType = {
setDocument: (document: any) => void;
};
const Container = styled.div`
font-family: Segoe UI;
`;
export const NavBar = ({ setDocument }: PropsType) => {
const [isOpen, setIsOpen] = useState(false);
|
typescript | await tx.wait();
throw null;
} catch (e) {
if (e == null) {
assert(false, `Tx did not threw: [${message}]`)
}
console.log(`Thrown as expected: [${message}] - ${e.reason || e.message}`); |
typescript | marginRight: 6,
borderRadius: 5,
shadowOffset: {
width: 1,
height: 1
},
shadowRadius: 5,
shadowColor: Colors.redShadow,
shadowOpacity: 1
}}>
<Image source={background} style={{ |
typescript | import { gql } from "@apollo/client";
import { ProblemSummaryProps } from "../../molecules/SearchResultTile/interface";
export interface GetProblemsQuery {
problems: Array<ProblemSummaryProps>; |
typescript | return new Formatters.Total().output(issues, fileCount);
case "json":
return new Formatters.Json().output(issues, fileCount);
case "junit":
return new Formatters.Junit().output(issues, fileCount);
case "codeclimate":
return new Formatters.CodeClimate().output(issues, fileCount);
default:
return new Formatters.Standard().output(issues, fileCount);
}
} |
typescript | export interface ColorStopPropertyFigma {
/** Value between 0 and 1 representing position along gradient axis */
position: number;
/** Color attached to corresponding position */
color: ColorPropertyFigma; |
typescript |
const cx = classNames.bind(styles)
interface Props {
className?: string
bg?: string
}
const Badge: FC<Props> = ({ className, children, bg }) => ( |
typescript | export const TWILIO_API_SECRET = process.env.TWILIO_API_SECRET;
export const TWILIO_CHAT_SERVICE_SID = process.env.TWILIO_CHAT_SERVICE_SID;
export const LI_AT_SESSION_COOKIE = process.env.LI_AT_SESSION_COOKIE;
// Unused at the moment
export const TWILIO_NOTIFICATION_SERVICE_SID =
process.env.TWILIO_NOTIFICATION_SERVICE_SID;
export const TWILIO_SYNC_SERVICE_SID =
process.env.TWILIO_SYNC_SERVICE_SID || "default";
|
typescript | * OpenAPI spec version: V1
*
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
import { FileDTO } from './fileDTO';
export interface DirectoryDTO {
directoryName?: string;
directoryPath?: string;
imageDataJson?: string;
childDirectories?: Array<DirectoryDTO>;
files?: Array<FileDTO>; |
typescript | import { expect } from "chai";
import sliceAfter from "./sliceAfter";
describe("spliceAfter", () => {
it("should return the substring after the needle", () => {
expect(sliceAfter("abcdefg", "cd")).to.equal("efg");
});
it("should return an empty string if the needle is not found", () => {
expect(sliceAfter("abcdefg", "ce")).to.equal("");
});
});
|
typescript | },
{
field: 'offset',
desc: '栅格左侧的间隔格数',
defaultValue: '0',
type: 'Number'
},
{
field: 'tag',
desc: '表示渲染的标签',
defaultValue: 'div', |
typescript |
/**
* Strip processing instruction (like <?xml foo="blerg" ?>) tags.
*
* @default true
*/
stripInstruction?: boolean | undefined;
/**
* @default {}
*/
saxOptions?: sax.SAXOptions | undefined;
|
typescript |
export interface IAction {
apply(worklog: Worklog): void;
toString(): string;
} |
typescript | export class Reactor {
private events: object = {};
private getOrCreateEvent(eventName: string): Event {
let event: Event = this.events[eventName];
if (event === undefined) {
event = new Event(eventName);
this.events[eventName] = event;
}
return event;
} |
typescript | connectionLimit: 5
})
const initDatabase = async () => {
await pool.query(`
CREATE TABLE IF NOT EXISTS urls (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
full TEXT NOT NULL,
shortened VARCHAR(255) UNIQUE NOT NULL,
expire DATETIME NULL,
PRIMARY KEY (id))`)
await pool.query(` |
typescript | name: string
birthday: string
occupation: string[]
img: string
status: string
nickname: string
appearance: number[]
portrayed: string
category: string
better_call_saul_appearance: number[]
} |
typescript | handleSendMessage() {
if (!this.currentUid || !this.conv || !this.conv.convId || !this.message) return
sendMessage({
"text": this.message,
"sender": this.currentUid,
}, this.conv)
this.message = "";
}
|
typescript | import '@styles/styles.scss';
import React from 'react';
import ReactDom from 'react-dom';
import App from '@src/pages/App';
//@ts-ignorets-ignore
ReactDom.render(<App />, document.getElementById('root'));
|
typescript | * host key files
*/
Host = 4,
/**
* keyboard interactive
*/
|
typescript | <Example>
<Caption>Is requested?</Caption>
<Text>{isRequested ? 'Yes' : 'No'}</Text>
</Example>
</Page>
);
}; |
typescript | export class JwtClaimsModel {
sub: string;
roles: string[];
}
|
typescript | this.FtpForm.get('sSubDirName').enable();
this.checkCustomize('sTopDirNameRule', this.FtpForm.get('sTopDirNameRule').value);
this.checkCustomize('sSubDirNameRule', this.FtpForm.get('sSubDirNameRule').value);
} else {
this.logger.error(dep, 'Unexcept Path Depth:');
}
}
); |
typescript | import { atom } from 'recoil';
export const searchQueryAtom = atom<string>({
key: 'searchQuery',
default: '',
});
export const searchSettingsQueryAtom = atom<string>({
key: 'searchSettingsQuery',
default: '',
});
|
typescript | import { NgaModule } from '../../theme/nga.module';
import { routing } from './notification.routing';
import { NotificationComponent } from './notification.component';
import { NotificationHomeComponent } from './notification-home/notification-home.component';
@NgModule({ |
typescript | 'Glasses',
'Jewelry',
];
export const WithList = () => (
<Flex flexWrap="wrap">
{data.map((cat, index) => {
return ( |
typescript | const webSocketServer = new WebSocket.Server({ server: server.server });
webSocketServer.on('connection', (webSocket) => {
webpackCompiler.plugin('done', () => {
webSocket.send('compilationDone');
});
});
}
const start = async () => {
try {
await server.listen(8080, '0.0.0.0');
} catch (err) { |
typescript | import { Revocable, SLIP10 } from "..";
import * as BIP32 from "../bip32";
export interface Mnemonic extends Partial<Revocable> {
toSeed(passphrase?: string, slip10?: boolean): Promise<BIP32.Seed | SLIP10.Seed>;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.