conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
public static clone(url: string, path: string, progress: (progress: number) => void): Promise<void> {
return GitProcess.exec([ 'clone', url, path ], path)
}
=======
/** Add a new remote with the given URL. */
public static addRemote(path: string, name: string, url: string): Promise<void> {
return GitProcess.exec([ 'remote', 'add', name, url ], path)
}
>>>>>>>
public static clone(url: string, path: string, progress: (progress: number) => void): Promise<void> {
return GitProcess.exec([ 'clone', url, path ], path)
}
/** Add a new remote with the given URL. */
public static addRemote(path: string, name: string, url: string): Promise<void> {
return GitProcess.exec([ 'remote', 'add', name, url ], path)
} |
<<<<<<<
const withUpdatedGitHubRepository = updatedRepository.withGitHubRepository(
gitHubRepository.withAPI(apiRepo)
=======
return updatedRepository.withGitHubRepository(
updatedGitHubRepository.withAPI(apiRepo)
>>>>>>>
const withUpdatedGitHubRepository = updatedRepository.withGitHubRepository(
updatedGitHubRepository.withAPI(apiRepo) |
<<<<<<<
stashEntriesCreatedOutsideDesktop: 0,
errorWhenSwitchingBranchesWithUncommmittedChanges: 0,
=======
rebaseCurrentBranchMenuCount: 0,
>>>>>>>
stashEntriesCreatedOutsideDesktop: 0,
errorWhenSwitchingBranchesWithUncommmittedChanges: 0,
rebaseCurrentBranchMenuCount: 0, |
<<<<<<<
/** Change the current image diff type. */
public changeImageDiffType(type: ImageDiffType): Promise<void> {
return this.appStore._changeImageDiffType(type)
}
=======
/** Prompt the user to authenticate for a generic git server. */
public promptForGenericGitAuthentication(
repository: Repository | CloningRepository,
retry: RetryAction
): Promise<void> {
return this.appStore.promptForGenericGitAuthentication(repository, retry)
}
/** Save the generic git credentials. */
public async saveGenericGitCredentials(
hostname: string,
username: string,
password: string
): Promise<void> {
GenericGitAuth.setGenericUsername(hostname, username)
await GenericGitAuth.setGenericPassword(hostname, username, password)
}
/** Perform the given retry action. */
public async performRetry(retryAction: RetryAction): Promise<void> {
switch (retryAction.type) {
case RetryActionType.Push:
return this.push(retryAction.repository)
case RetryActionType.Pull:
return this.pull(retryAction.repository)
case RetryActionType.Fetch:
return this.fetch(retryAction.repository)
case RetryActionType.Clone:
await this.clone(retryAction.url, retryAction.path, retryAction.options)
break
default:
return assertNever(retryAction, `Unknown retry action: ${retryAction}`)
}
}
>>>>>>>
/** Prompt the user to authenticate for a generic git server. */
public promptForGenericGitAuthentication(
repository: Repository | CloningRepository,
retry: RetryAction
): Promise<void> {
return this.appStore.promptForGenericGitAuthentication(repository, retry)
}
/** Save the generic git credentials. */
public async saveGenericGitCredentials(
hostname: string,
username: string,
password: string
): Promise<void> {
GenericGitAuth.setGenericUsername(hostname, username)
await GenericGitAuth.setGenericPassword(hostname, username, password)
}
/** Perform the given retry action. */
public async performRetry(retryAction: RetryAction): Promise<void> {
switch (retryAction.type) {
case RetryActionType.Push:
return this.push(retryAction.repository)
case RetryActionType.Pull:
return this.pull(retryAction.repository)
case RetryActionType.Fetch:
return this.fetch(retryAction.repository)
case RetryActionType.Clone:
await this.clone(retryAction.url, retryAction.path, retryAction.options)
break
default:
return assertNever(retryAction, `Unknown retry action: ${retryAction}`)
}
}
public changeImageDiffType(type: ImageDiffType): Promise<void> {
return this.appStore._changeImageDiffType(type)
} |
<<<<<<<
declare function requestIdleCallback(fn: () => void, options?: { timeout: number }): number
// these changes should be pushed into the Electron declarations
declare namespace NodeJS {
// tslint:disable-next-line:interface-name
interface Process extends EventEmitter {
once(event: 'uncaughtException', listener: (error: Error) => void): this
on(event: 'uncaughtException', listener: (error: Error) => void): this
}
}
declare namespace Electron {
// tslint:disable-next-line:interface-name
interface MenuItem {
readonly accelerator?: Electron.Accelerator
readonly submenu?: Electron.Menu
readonly role?: string
readonly type: 'normal' | 'separator' | 'submenu' | 'checkbox' | 'radio'
}
// tslint:disable-next-line:interface-name
interface RequestOptions {
readonly method: string
readonly url: string
readonly headers: any
}
type AppleActionOnDoubleClickPref = 'Maximize' | 'Minimize' | 'None'
// tslint:disable-next-line:interface-name
interface SystemPreferences {
getUserDefault(key: 'AppleActionOnDoubleClick', type: 'string'): AppleActionOnDoubleClickPref
}
// these methods have been marked with optional parameters, where we hadn't assumed this before
// tslint:disable-next-line:interface-name
interface App extends EventEmitter {
makeSingleInstance(callback: (argv: string[], workingDirectory: string) => void): boolean
on(event: 'open-url', listener: (event: Electron.Event, url: string) => void): this
}
}
=======
declare function requestIdleCallback(fn: () => void, options?: { timeout: number }): number
declare interface IDesktopLogger {
/**
* Writes a log message at the 'error' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
error(message: string, error?: Error): void
/**
* Writes a log message at the 'warn' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
warn(message: string, error?: Error): void
/**
* Writes a log message at the 'info' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
info(message: string, error?: Error): void
/**
* Writes a log message at the 'debug' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
debug(message: string, error?: Error): void
}
declare const log: IDesktopLogger
>>>>>>>
declare function requestIdleCallback(fn: () => void, options?: { timeout: number }): number
declare interface IDesktopLogger {
/**
* Writes a log message at the 'error' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
error(message: string, error?: Error): void
/**
* Writes a log message at the 'warn' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
warn(message: string, error?: Error): void
/**
* Writes a log message at the 'info' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
info(message: string, error?: Error): void
/**
* Writes a log message at the 'debug' level.
*
* The error will be persisted to disk as long as the disk transport is
* configured to pass along log messages at this level. For more details
* about the on-disk transport, see log.ts in the main process.
*
* If used from a renderer the log message will also be appended to the
* devtools console.
*
* @param message The text to write to the log file
* @param error An optional error instance that will be formatted to
* include the stack trace (if one is available) and
* then appended to the log message.
*/
debug(message: string, error?: Error): void
}
declare const log: IDesktopLogger
// these changes should be pushed into the Electron declarations
declare namespace NodeJS {
// tslint:disable-next-line:interface-name
interface Process extends EventEmitter {
once(event: 'uncaughtException', listener: (error: Error) => void): this
on(event: 'uncaughtException', listener: (error: Error) => void): this
}
}
declare namespace Electron {
// tslint:disable-next-line:interface-name
interface MenuItem {
readonly accelerator?: Electron.Accelerator
readonly submenu?: Electron.Menu
readonly role?: string
readonly type: 'normal' | 'separator' | 'submenu' | 'checkbox' | 'radio'
}
// tslint:disable-next-line:interface-name
interface RequestOptions {
readonly method: string
readonly url: string
readonly headers: any
}
type AppleActionOnDoubleClickPref = 'Maximize' | 'Minimize' | 'None'
// tslint:disable-next-line:interface-name
interface SystemPreferences {
getUserDefault(key: 'AppleActionOnDoubleClick', type: 'string'): AppleActionOnDoubleClickPref
}
// these methods have been marked with optional parameters, where we hadn't assumed this before
// tslint:disable-next-line:interface-name
interface App extends EventEmitter {
makeSingleInstance(callback: (argv: string[], workingDirectory: string) => void): boolean
on(event: 'open-url', listener: (event: Electron.Event, url: string) => void): this
}
} |
<<<<<<<
import { git, envForAuthentication, expectedAuthenticationErrors, IGitExecutionOptions } from './core'
=======
import {
git,
envForAuthentication,
expectedAuthenticationErrors,
gitNetworkArguments,
} from './core'
>>>>>>>
import {
git,
envForAuthentication,
expectedAuthenticationErrors,
IGitExecutionOptions,
gitNetworkArguments,
} from './core'
<<<<<<<
/**
* Push from the remote to the branch, optionally setting the upstream.
*
* @param repository - The repository from which to push
*
* @param account - The account to use when authenticating with the remote
*
* @param remote - The remote to push the specified branch to
*
* @param branch - The branch to push
*
* @param setUpstream - Whether or not to update the tracking information
* of the specified branch to point to the remote.
*
* @param progressCallback - An optional function which will be invoked
* with information about the current progress
* of the push operation. When provided this enables
* the '--progress' command line flag for
* 'git push'.
*/
export async function push(repository: Repository, account: Account | null, remote: string, branch: string, setUpstream: boolean, progressCallback?: (progress: IPushProgress) => void): Promise<void> {
const args = [ 'push', remote, branch ]
=======
/** Push from the remote to the branch, optionally setting the upstream. */
export async function push(repository: Repository, account: Account | null, remote: string, branch: string, setUpstream: boolean): Promise<void> {
const args = [
...gitNetworkArguments,
'push', remote, branch,
]
>>>>>>>
/**
* Push from the remote to the branch, optionally setting the upstream.
*
* @param repository - The repository from which to push
*
* @param account - The account to use when authenticating with the remote
*
* @param remote - The remote to push the specified branch to
*
* @param branch - The branch to push
*
* @param setUpstream - Whether or not to update the tracking information
* of the specified branch to point to the remote.
*
* @param progressCallback - An optional function which will be invoked
* with information about the current progress
* of the push operation. When provided this enables
* the '--progress' command line flag for
* 'git push'.
*/
export async function push(repository: Repository, account: Account | null, remote: string, branch: string, setUpstream: boolean, progressCallback?: (progress: IPushProgress) => void): Promise<void> {
const args = [
...gitNetworkArguments,
'push', remote, branch,
] |
<<<<<<<
'add-local-repository' | 'create-branch' | 'show-branches' |
'add-repository'
=======
'add-local-repository' | 'create-branch' |
'show-branches' | 'remove-repository'
>>>>>>>
'add-local-repository' | 'create-branch' |
'show-branches' | 'remove-repository' | 'add-repository' |
<<<<<<<
import { Branch } from '../local-git-operations'
=======
import { IAPIUser } from '../../lib/api'
>>>>>>>
import { Branch } from '../local-git-operations'
import { IAPIUser } from '../../lib/api' |
<<<<<<<
/** Should the app check and warn the user about committing large files? */
export function enableFileSizeWarningCheck(): boolean {
return enableDevelopmentFeatures()
}
/** Should the app use the MergeConflictsDialog component and flow? */
export function enableMergeConflictsDialog(): boolean {
return true
=======
/** Should the app set protocol.version=2 for any fetch/push/pull/clone operation? */
export function enableGitProtocolVersionTwo(): boolean {
return enableDevelopmentFeatures()
>>>>>>>
/** Should the app check and warn the user about committing large files? */
export function enableFileSizeWarningCheck(): boolean {
return enableDevelopmentFeatures()
}
/** Should the app set protocol.version=2 for any fetch/push/pull/clone operation? */
export function enableGitProtocolVersionTwo(): boolean {
return enableDevelopmentFeatures() |
<<<<<<<
=======
const allSelected = newFiles.every(f => f.include)
const noneSelected = newFiles.every(f => !f.include)
let includeAll: boolean | null = null
if (allSelected) {
includeAll = true
} else if (noneSelected) {
includeAll = false
}
const workingDirectory = new WorkingDirectoryStatus(newFiles, includeAll)
const newState: IRepositoryState = {
selectedSection: state.selectedSection,
changesState: {
workingDirectory,
selectedFile: state.changesState.selectedFile,
},
historyState: state.historyState,
branch: state.branch,
}
this.updateRepositoryState(repository, newState)
>>>>>>> |
<<<<<<<
initiateAuthRequest(requestUrl: string, params: RedirectParams): Promise<void> {
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest called");
=======
async initiateAuthRequest(requestUrl: string, params: RedirectParams): Promise<void> {
>>>>>>>
async initiateAuthRequest(requestUrl: string, params: RedirectParams): Promise<void> {
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest called");
<<<<<<<
this.authModule.logger.infoPii("RedirectHandler.initiateAuthRequest: Navigate to:" + requestUrl);
=======
this.authModule.logger.infoPii("Navigate to:" + requestUrl);
const navigationOptions: NavigationOptions = {
apiId: ApiId.acquireTokenRedirect,
timeout: params.redirectTimeout,
noHistory: false
};
>>>>>>>
this.authModule.logger.infoPii("RedirectHandler.initiateAuthRequest: Navigate to:" + requestUrl);
const navigationOptions: NavigationOptions = {
apiId: ApiId.acquireTokenRedirect,
timeout: params.redirectTimeout,
noHistory: false
};
<<<<<<<
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate did not return false, navigating");
return BrowserUtils.navigateWindow(requestUrl, params.redirectTimeout, this.authModule.logger);
=======
this.authModule.logger.verbose("onRedirectNavigate did not return false, navigating");
await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
return;
>>>>>>>
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate did not return false, navigating");
await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
return;
<<<<<<<
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate returned false, stopping navigation");
return Promise.resolve();
=======
this.authModule.logger.verbose("onRedirectNavigate returned false, stopping navigation");
return;
>>>>>>>
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate returned false, stopping navigation");
return;
<<<<<<<
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest: Navigating window to navigate url");
return BrowserUtils.navigateWindow(requestUrl, params.redirectTimeout, this.authModule.logger);
=======
this.authModule.logger.verbose("Navigating window to navigate url");
await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
return;
>>>>>>>
this.authModule.logger.verbose("RedirectHandler.initiateAuthRequest: Navigating window to navigate url");
await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
return; |
<<<<<<<
import { TokenResponse } from "./RequestInfo";
import { Account } from "./Account";
=======
import { User } from "./User";
>>>>>>>
import { Account } from "./Account";
<<<<<<<
export type tokenReceivedCallback = (errorDesc: string, token: string, error: string, tokenType: string, accountState: string ) => void;
=======
export type tokenReceivedCallback = (response: AuthResponse) => void;
>>>>>>>
export type tokenReceivedCallback = (response: AuthResponse) => void;
<<<<<<<
loginRedirect(request?: AuthenticationParameters): void {
=======
loginRedirect(request: AuthenticationParameters): void {
// Throw error if callbacks are not set before redirect
if (!this.redirectCallbacksSet) {
throw ClientConfigurationError.createRedirectCallbacksNotSetError();
}
>>>>>>>
loginRedirect(request: AuthenticationParameters): void {
// Throw error if callbacks are not set before redirect
if (!this.redirectCallbacksSet) {
throw ClientConfigurationError.createRedirectCallbacksNotSetError();
}
<<<<<<<
if (this.loginInProgress) {
throw ClientAuthError.createLoginInProgressError();
=======
if (this.userLoginInProgress) {
this.errorReceivedCallback(ClientAuthError.createLoginInProgressError(), this.getUserState(this.silentAuthenticationState));
return;
>>>>>>>
if (this.loginInProgress) {
this.errorReceivedCallback(ClientAuthError.createLoginInProgressError(), this.getAccountState(this.silentAuthenticationState));
return;
<<<<<<<
if (this.tokenReceivedCallback) {
// Clear the cookie in the hash
this.cacheStorage.clearCookie();
// Trigger callback
// TODO: Refactor to new callback pattern
this.tokenReceivedCallback.call(this, errorDesc, token, error, tokenType, this.getAccountState(this.cacheStorage.getItem(Constants.stateLogin, this.inCookie)));
=======
// Clear the cookie in the hash
this.cacheStorage.clearCookie();
const userState = this.getUserState(this.cacheStorage.getItem(Constants.stateLogin, this.inCookie));
if (parentCallback) {
parentCallback(response, authErr);
} else {
if (authErr) {
this.errorReceivedCallback(authErr, userState);
} else if (response) {
if ((stateInfo.requestType === Constants.renewToken) || response.accessToken) {
if (window.parent !== window) {
this.logger.verbose("Window is in iframe, acquiring token silently");
} else {
this.logger.verbose("acquiring token interactive in progress");
}
response.tokenType = Constants.accessToken;
}
else if (stateInfo.requestType === Constants.login) {
response.tokenType = Constants.idToken;
}
this.tokenReceivedCallback(response);
>>>>>>>
// Clear the cookie in the hash
this.cacheStorage.clearCookie();
const accountState = this.getAccountState(this.cacheStorage.getItem(Constants.stateLogin, this.inCookie));
if (parentCallback) {
parentCallback(response, authErr);
} else {
if (authErr) {
this.errorReceivedCallback(authErr, accountState);
} else if (response) {
if ((stateInfo.requestType === Constants.renewToken) || response.accessToken) {
if (window.parent !== window) {
this.logger.verbose("Window is in iframe, acquiring token silently");
} else {
this.logger.verbose("acquiring token interactive in progress");
}
response.tokenType = Constants.accessToken;
}
else if (stateInfo.requestType === Constants.login) {
response.tokenType = Constants.idToken;
}
this.tokenReceivedCallback(response);
<<<<<<<
const errorDesc = requestInfo.parameters[Constants.errorDescription];
const error = requestInfo.parameters[Constants.error];
try {
// We should only send the state back to the developer if it matches with what we received from the server
// TODO: Change this so that it sends back response object or error object based on what is returned from getRequestInfo()
if (tokenReceivedCallback) {
//We should only send the stae back to the developer if it matches with what we received from the server
if (requestInfo.stateMatch) {
tokenReceivedCallback.call(self, errorDesc, token, error, tokenType, this.getAccountState(requestInfo.stateResponse));
}
else {
tokenReceivedCallback.call(self, errorDesc, token, error, tokenType, null);
}
}
} catch (err) {
self.logger.error("Error occurred in token received callback function: " + err);
throw ClientAuthError.createErrorInCallbackFunction(err.toString());
}
=======
self.processCallBack(hash, stateInfo, tokenResponseCallback);
>>>>>>>
self.processCallBack(hash, stateInfo, tokenResponseCallback);
<<<<<<<
//TODO: Break this function - too long
private saveAccessToken(authority: string, tokenResponse: TokenResponse, account: Account, clientInfo: string, idToken: IdToken): void {
=======
private saveAccessToken(response: AuthResponse, authority: string, parameters: any, clientInfo: string): AuthResponse {
>>>>>>>
private saveAccessToken(response: AuthResponse, authority: string, parameters: any, clientInfo: string): AuthResponse {
<<<<<<<
if (tokenResponse.parameters.hasOwnProperty("scope")) {
scope = tokenResponse.parameters["scope"];
=======
if (parameters.hasOwnProperty("scope")) {
// read the scopes
scope = parameters["scope"];
>>>>>>>
if (parameters.hasOwnProperty("scope")) {
// read the scopes
scope = parameters["scope"];
<<<<<<<
// TODO: Figure out where to change this
if (accessTokenCacheItem.key.homeAccountIdentifier === account.homeAccountIdentifier) {
=======
if (accessTokenCacheItem.key.userIdentifier === response.account.userIdentifier) {
>>>>>>>
if (accessTokenCacheItem.key.homeAccountIdentifier === response.account.userIdentifier) {
<<<<<<<
if (tokenResponse.requestType === Constants.login) {
this.loginInProgress = false;
this.cacheStorage.setItem(Constants.loginError, tokenResponse.parameters[Constants.errorDescription] + ":" + tokenResponse.parameters[Constants.error]);
authorityKey = Storage.generateAuthorityKey(tokenResponse.stateResponse);
=======
if (stateInfo.requestType === Constants.login) {
this.userLoginInProgress = false;
this.cacheStorage.setItem(Constants.loginError, hashParams[Constants.errorDescription] + ":" + hashParams[Constants.error]);
authorityKey = Storage.generateAuthorityKey(stateInfo.state);
>>>>>>>
if (stateInfo.requestType === Constants.login) {
this.loginInProgress = false;
this.cacheStorage.setItem(Constants.loginError, hashParams[Constants.errorDescription] + ":" + hashParams[Constants.error]);
authorityKey = Storage.generateAuthorityKey(stateInfo.state);
<<<<<<<
authorityKey = Storage.generateAuthorityKey(tokenResponse.stateResponse);
const accountId = this.getAccount() !== null ? this.getAccount().homeAccountIdentifier : "";
acquireTokenAccountKey = Storage.generateAcquireTokenAccountKey(accountId, tokenResponse.stateResponse);
=======
authorityKey = Storage.generateAuthorityKey(stateInfo.state);
const userKey = this.getUser() !== null ? this.getUser().userIdentifier : "";
acquireTokenUserKey = Storage.generateAcquireTokenUserKey(userKey, stateInfo.state);
}
if (this.isInteractionRequired(hashParams[Constants.errorDescription])) {
error = new InteractionRequiredAuthError(hashParams[Constants.error], hashParams[Constants.errorDescription]);
} else {
error = new ServerError(hashParams[Constants.error], hashParams[Constants.errorDescription]);
>>>>>>>
authorityKey = Storage.generateAuthorityKey(stateInfo.state);
const accountKey = this.getAccount() !== null ? this.getAccount().homeAccountIdentifier : "";
acquireTokenAccountKey = Storage.generateAcquireTokenAccountKey(accountKey, stateInfo.state);
}
if (this.isInteractionRequired(hashParams[Constants.errorDescription])) {
error = new InteractionRequiredAuthError(hashParams[Constants.error], hashParams[Constants.errorDescription]);
} else {
error = new ServerError(hashParams[Constants.error], hashParams[Constants.errorDescription]);
<<<<<<<
let account: Account;
=======
>>>>>>>
let account: Account;
<<<<<<<
if (tokenResponse.parameters.hasOwnProperty(Constants.clientInfo)) {
clientInfo = tokenResponse.parameters[Constants.clientInfo];
account = Account.createAccount(idToken, new ClientInfo(clientInfo));
=======
if (hashParams.hasOwnProperty(Constants.clientInfo)) {
clientInfo = hashParams[Constants.clientInfo];
>>>>>>>
if (hashParams.hasOwnProperty(Constants.clientInfo)) {
clientInfo = hashParams[Constants.clientInfo];
<<<<<<<
account = Account.createAccount(idToken, new ClientInfo(clientInfo));
=======
>>>>>>>
<<<<<<<
acquireTokenAccountKey = Storage.generateAcquireTokenAccountKey(account.homeAccountIdentifier, tokenResponse.stateResponse);
const acquireTokenAccountKey_noaccount = Storage.generateAcquireTokenAccountKey(Constants.no_account, tokenResponse.stateResponse);
=======
const acquireTokenUserKey = Storage.generateAcquireTokenUserKey(response.account.userIdentifier, stateInfo.state);
const acquireTokenUserKey_nouser = Storage.generateAcquireTokenUserKey(Constants.no_user, stateInfo.state);
>>>>>>>
const acquireTokenUserKey = Storage.generateAcquireTokenAccountKey(response.account.userIdentifier, stateInfo.state);
const acquireTokenUserKey_nouser = Storage.generateAcquireTokenAccountKey(Constants.no_account, stateInfo.state);
<<<<<<<
// Check with the account in the Cache
if (!Utils.isEmpty(cachedAccount)) {
acquireTokenAccount = JSON.parse(cachedAccount);
if (account && acquireTokenAccount && Utils.compareAccounts(account, acquireTokenAccount)) {
this.saveAccessToken(authority, tokenResponse, account, clientInfo, idToken);
this.logger.info("The account object received in the response is the same as the one passed in the acquireToken request");
=======
// Check with the user in the Cache
if (!Utils.isEmpty(cachedUser)) {
acquireTokenUser = JSON.parse(cachedUser);
if (response.account && acquireTokenUser && Utils.compareObjects(response.account, acquireTokenUser)) {
response = this.saveAccessToken(response, authority, hashParams, clientInfo);
this.logger.info("The user object received in the response is the same as the one passed in the acquireToken request");
>>>>>>>
// Check with the user in the Cache
if (!Utils.isEmpty(cachedAccount)) {
acquireTokenAccount = JSON.parse(cachedAccount);
if (response.account && acquireTokenAccount && Utils.compareAccounts(response.account, acquireTokenAccount)) {
response = this.saveAccessToken(response, authority, hashParams, clientInfo);
this.logger.info("The user object received in the response is the same as the one passed in the acquireToken request");
}
else {
this.logger.warning(
"The account object created from the response is not the same as the one passed in the acquireToken request");
}
}
else if (!Utils.isEmpty(this.cacheStorage.getItem(acquireTokenUserKey_nouser))) {
response = this.saveAccessToken(response, authority, hashParams, clientInfo);
}
}
// Process id_token
if (hashParams.hasOwnProperty(Constants.idToken)) {
this.logger.info("Fragment has id token");
// login no longer in progress
this.loginInProgress = false;
response = Utils.setResponseIdToken(response, new IdToken(hashParams[Constants.idToken]));
if (hashParams.hasOwnProperty(Constants.clientInfo)) {
clientInfo = hashParams[Constants.clientInfo];
<<<<<<<
} else if (!Utils.isEmpty(this.cacheStorage.getItem(acquireTokenAccountKey_noaccount))) {
this.saveAccessToken(authority, tokenResponse, account, clientInfo, idToken);
=======
} else if (!Utils.isEmpty(this.cacheStorage.getItem(acquireTokenUserKey_nouser))) {
response = this.saveAccessToken(response, authority, hashParams, clientInfo);
>>>>>>>
}
else if (!Utils.isEmpty(this.cacheStorage.getItem(acquireTokenUserKey_nouser))) {
response = this.saveAccessToken(response, authority, hashParams, clientInfo);
<<<<<<<
this.loginInProgress = false;
idToken = new IdToken(tokenResponse.parameters[Constants.idToken]);
if (tokenResponse.parameters.hasOwnProperty(Constants.clientInfo)) {
clientInfo = tokenResponse.parameters[Constants.clientInfo];
=======
this.userLoginInProgress = false;
response = Utils.setResponseIdToken(response, new IdToken(hashParams[Constants.idToken]));
if (hashParams.hasOwnProperty(Constants.clientInfo)) {
clientInfo = hashParams[Constants.clientInfo];
>>>>>>>
this.loginInProgress = false;
response = Utils.setResponseIdToken(response, new IdToken(hashParams[Constants.idToken]));
if (hashParams.hasOwnProperty(Constants.clientInfo)) {
clientInfo = hashParams[Constants.clientInfo];
<<<<<<<
this.account = Account.createAccount(idToken, new ClientInfo(clientInfo));
=======
this.user = User.createUser(response.idToken, new ClientInfo(clientInfo));
response.account = this.user;
>>>>>>>
this.account = Account.createAccount(response.idToken, new ClientInfo(clientInfo));
response.account = this.account;
<<<<<<<
if (idToken.nonce !== this.cacheStorage.getItem(Constants.nonceIdToken, this.inCookie)) {
this.account = null;
=======
if (response.idToken.nonce !== this.cacheStorage.getItem(Constants.nonceIdToken, this.inCookie)) {
this.user = null;
>>>>>>>
if (response.idToken.nonce !== this.cacheStorage.getItem(Constants.nonceIdToken, this.inCookie)) {
this.account = null;
<<<<<<<
this.saveAccessToken(authority, tokenResponse, this.account, clientInfo, idToken);
=======
this.saveAccessToken(response, authority, hashParams, clientInfo);
>>>>>>>
this.saveAccessToken(response, authority, hashParams, clientInfo);
<<<<<<<
// TODO: avoid repeated strings - will this be optimized with error handling?
authorityKey = tokenResponse.stateResponse;
acquireTokenAccountKey = tokenResponse.stateResponse;
=======
authorityKey = stateInfo.state;
acquireTokenUserKey = stateInfo.state;
>>>>>>>
authorityKey = stateInfo.state;
acquireTokenAccountKey = stateInfo.state; |
<<<<<<<
import { DiffSelection, ITextDiff } from '../../models/diff'
=======
import { getTagsToPush, storeTagsToPush } from './helpers/tags-to-push-storage'
>>>>>>>
import { getTagsToPush, storeTagsToPush } from './helpers/tags-to-push-storage'
import { DiffSelection, ITextDiff } from '../../models/diff' |
<<<<<<<
import { ITenantDiscoveryResponse } from './ITenantDiscoveryResponse';
=======
import TelemetryManager from "../telemetry/TelemetryManager";
>>>>>>>
import { ITenantDiscoveryResponse } from './ITenantDiscoveryResponse';
import TelemetryManager from "../telemetry/TelemetryManager"; |
<<<<<<<
const result = await git([ 'log', revisionRange, `--max-count=${limit}`, `--pretty=${prettyFormat}`, '-z', '--no-color', ...additionalArgs ], repository.path)
=======
const result = await git([ 'log', start, `--max-count=${limit}`, `--pretty=${prettyFormat}`, '-z', '--no-color' ], repository.path, { successExitCodes: new Set([ 0, 128 ]) })
// if the repository has an unborn HEAD, return an empty history of commits
if (result.exitCode === 128) {
return new Array<Commit>()
}
>>>>>>>
const result = await git([ 'log', revisionRange, `--max-count=${limit}`, `--pretty=${prettyFormat}`, '-z', '--no-color', ...additionalArgs ], repository.path, { successExitCodes: new Set([ 0, 128 ]) })
// if the repository has an unborn HEAD, return an empty history of commits
if (result.exitCode === 128) {
return new Array<Commit>()
} |
<<<<<<<
const user = this.getUserForRepository(repository)
=======
>>>>>>> |
<<<<<<<
export async function getRemotes(repository: Repository): Promise<ReadonlyArray<string>> {
const result = await git([ 'remote' ], repository.path, 'getRemotes')
const lines = result.stdout
const rows = lines.split('\n')
return rows.filter(r => r.trim().length > 0)
=======
export async function getRemotes(repository: Repository): Promise<ReadonlyArray<IRemote>> {
const result = await git([ 'remote', '-v' ], repository.path, 'getRemotes')
const output = result.stdout
const lines = output.split('\n')
const remotes = lines
.filter(x => x.endsWith('(fetch)'))
.map(x => x.split(/\s+/))
.map(x => ({ name: x[0], url: x[1] }))
return remotes
>>>>>>>
export async function getRemotes(repository: Repository): Promise<ReadonlyArray<IRemote>> {
const result = await git([ 'remote', '-v' ], repository.path, 'getRemotes')
const output = result.stdout
const lines = output.split('\n')
const remotes = lines
.filter(x => x.endsWith('(fetch)'))
.map(x => x.split(/\s+/))
.map(x => ({ name: x[0], url: x[1] }))
return remotes
<<<<<<<
export async function addRemote(repository: Repository, name: string, url: string): Promise<void> {
await git([ 'remote', 'add', name, url ], repository.path, 'addRemote')
}
/** Removes an existing remote, or silently errors if it doesn't exist */
export async function removeRemote(repository: Repository, name: string): Promise<void> {
const options = {
successExitCodes: new Set([ 0, 128 ]),
}
await git([ 'remote', 'remove', name ], repository.path, 'removeRemote', options)
=======
export async function addRemote(path: string, name: string, url: string): Promise<void> {
await git([ 'remote', 'add', name, url ], path, 'addRemote')
}
/** Changes the URL for the remote that matches the given name */
export async function setRemoteURL(repository: Repository, name: string, url: string): Promise<void> {
await git([ 'remote', 'set-url', name, url ], repository.path, 'setRemoteURL')
>>>>>>>
export async function addRemote(repository: Repository, name: string, url: string): Promise<void> {
await git([ 'remote', 'add', name, url ], repository.path, 'addRemote')
}
/** Removes an existing remote, or silently errors if it doesn't exist */
export async function removeRemote(repository: Repository, name: string): Promise<void> {
const options = {
successExitCodes: new Set([ 0, 128 ]),
}
await git([ 'remote', 'remove', name ], repository.path, 'removeRemote', options)
}
/** Changes the URL for the remote that matches the given name */
export async function setRemoteURL(repository: Repository, name: string, url: string): Promise<void> {
await git([ 'remote', 'set-url', name, url ], repository.path, 'setRemoteURL') |
<<<<<<<
const promises = []
if (repositories.length > 15) {
=======
const eligibleRepositories = repositories.filter(repo => !repo.missing)
if (eligibleRepositories.length > 15) {
>>>>>>>
if (repositories.length > 15) {
<<<<<<<
for (const repo of repositories) {
promises.push(this.refreshIndicatorForRepository(repo))
=======
for (const repo of eligibleRepositories) {
await this.refreshIndicatorForRepository(repo)
>>>>>>>
for (const repo of repositories) {
await this.refreshIndicatorForRepository(repo) |
<<<<<<<
import { RepositorySection, Popup, PopupType, Foldout, FoldoutType } from '../app-state'
=======
import {
RepositorySection,
Popup,
PopupType,
Foldout,
FoldoutType,
} from '../app-state'
import { Action } from './actions'
>>>>>>>
import {
RepositorySection,
Popup,
PopupType,
Foldout,
FoldoutType,
} from '../app-state'
<<<<<<<
import { URLActionType, IOpenRepositoryFromURLAction, IUnknownAction } from '../parse-app-url'
import { requestAuthenticatedUser, resolveOAuthRequest, rejectOAuthRequest } from '../../lib/oauth'
=======
import {
URLActionType,
IOpenRepositoryFromURLAction,
IUnknownAction,
} from '../parse-app-url'
import {
requestAuthenticatedUser,
resolveOAuthRequest,
rejectOAuthRequest,
} from '../../lib/oauth'
import { validatedRepositoryPath } from './validated-repository-path'
/**
* Extend Error so that we can create new Errors with a callstack different from
* the callsite.
*/
class IPCError extends Error {
public readonly message: string
public readonly stack: string
public constructor(name: string, message: string, stack: string) {
super(name)
this.name = name
this.message = message
this.stack = stack
}
}
interface IResult<T> {
type: 'result'
readonly result: T
}
interface IError {
type: 'error'
readonly error: Error
}
type IPCResponse<T> = IResult<T> | IError
>>>>>>>
import {
URLActionType,
IOpenRepositoryFromURLAction,
IUnknownAction,
} from '../parse-app-url'
import {
requestAuthenticatedUser,
resolveOAuthRequest,
rejectOAuthRequest,
} from '../../lib/oauth'
<<<<<<<
public addRepositories(paths: ReadonlyArray<string>): Promise<ReadonlyArray<Repository>> {
return this.appStore._addRepositories(paths)
=======
public async addRepositories(
paths: ReadonlyArray<string>
): Promise<ReadonlyArray<Repository>> {
const validatedPaths = new Array<string>()
for (const path of paths) {
const validatedPath = await validatedRepositoryPath(path)
if (validatedPath) {
validatedPaths.push(validatedPath)
} else {
this.postError({
name: 'add-repository',
message: `${path} isn't a git repository.`,
})
}
}
const json = await this.dispatchToSharedProcess<
ReadonlyArray<IRepository>
>({
name: 'add-repositories',
paths: validatedPaths,
})
const addedRepositories = json.map(Repository.fromJSON)
const refreshedRepositories = new Array<Repository>()
for (const repository of addedRepositories) {
const refreshedRepository = await this.refreshGitHubRepositoryInfo(
repository
)
refreshedRepositories.push(refreshedRepository)
}
return refreshedRepositories
>>>>>>>
public addRepositories(
paths: ReadonlyArray<string>
): Promise<ReadonlyArray<Repository>> {
return this.appStore._addRepositories(paths)
<<<<<<<
public removeRepositories(repositories: ReadonlyArray<Repository | CloningRepository>): Promise<void> {
return this.appStore._removeRepositories(repositories)
=======
public async removeRepositories(
repositories: ReadonlyArray<Repository | CloningRepository>
): Promise<void> {
const localRepositories = repositories.filter(
r => r instanceof Repository
) as ReadonlyArray<Repository>
const cloningRepositories = repositories.filter(
r => r instanceof CloningRepository
) as ReadonlyArray<CloningRepository>
cloningRepositories.forEach(r => {
this.appStore._removeCloningRepository(r)
})
const repositoryIDs = localRepositories.map(r => r.id)
await this.dispatchToSharedProcess<ReadonlyArray<number>>({
name: 'remove-repositories',
repositoryIDs,
})
this.showFoldout({ type: FoldoutType.Repository })
}
/** Refresh the associated GitHub repository. */
private async refreshGitHubRepositoryInfo(
repository: Repository
): Promise<Repository> {
const refreshedRepository = await this.appStore._repositoryWithRefreshedGitHubRepository(
repository
)
if (structuralEquals(refreshedRepository, repository)) {
return refreshedRepository
}
const repo = await this.dispatchToSharedProcess<IRepository>({
name: 'update-github-repository',
repository: refreshedRepository,
})
return Repository.fromJSON(repo)
>>>>>>>
public removeRepositories(
repositories: ReadonlyArray<Repository | CloningRepository>
): Promise<void> {
return this.appStore._removeRepositories(repositories)
<<<<<<<
public async updateRepositoryMissing(repository: Repository, missing: boolean): Promise<Repository> {
return this.appStore._updateRepositoryMissing(repository, missing)
=======
public async updateRepositoryMissing(
repository: Repository,
missing: boolean
): Promise<Repository> {
const repo = await this.dispatchToSharedProcess<IRepository>({
name: 'update-repository-missing',
repository,
missing,
})
return Repository.fromJSON(repo)
>>>>>>>
public async updateRepositoryMissing(
repository: Repository,
missing: boolean
): Promise<Repository> {
return this.appStore._updateRepositoryMissing(repository, missing)
<<<<<<<
public selectRepository(repository: Repository | CloningRepository): Promise<Repository | null> {
return this.appStore._selectRepository(repository)
=======
public async selectRepository(
repository: Repository | CloningRepository
): Promise<Repository | null> {
let repo = await this.appStore._selectRepository(repository)
if (repository instanceof Repository) {
repo = await this.refreshGitHubRepositoryInfo(repository)
}
return repo
>>>>>>>
public selectRepository(
repository: Repository | CloningRepository
): Promise<Repository | null> {
return this.appStore._selectRepository(repository)
<<<<<<<
=======
/**
* Perform a function which may need authentication on a repository. This may
* first update the GitHub association for the repository.
*/
private async withAuthenticatingUser<T>(
repository: Repository,
fn: (repository: Repository, account: Account | null) => Promise<T>
): Promise<T> {
let updatedRepository = repository
let account = this.appStore.getAccountForRepository(updatedRepository)
// If we don't have a user association, it might be because we haven't yet
// tried to associate the repository with a GitHub repository, or that
// association is out of date. So try again before we bail on providing an
// authenticating user.
if (!account) {
updatedRepository = await this.refreshGitHubRepositoryInfo(repository)
account = this.appStore.getAccountForRepository(updatedRepository)
}
return fn(updatedRepository, account)
}
>>>>>>>
<<<<<<<
public push(repository: Repository): Promise<void> {
return this.appStore._push(repository)
=======
public async push(repository: Repository): Promise<void> {
return this.withAuthenticatingUser(repository, (repo, user) =>
this.appStore._push(repo, user)
)
>>>>>>>
public push(repository: Repository): Promise<void> {
return this.appStore._push(repository)
<<<<<<<
public pull(repository: Repository): Promise<void> {
return this.appStore._pull(repository)
=======
public async pull(repository: Repository): Promise<void> {
return this.withAuthenticatingUser(repository, (repo, user) =>
this.appStore._pull(repo, user)
)
>>>>>>>
public pull(repository: Repository): Promise<void> {
return this.appStore._pull(repository)
<<<<<<<
public fetchRefspec(repository: Repository, fetchspec: string): Promise<void> {
return this.appStore._fetchRefspec(repository, fetchspec)
=======
public fetchRefspec(
repository: Repository,
fetchspec: string
): Promise<void> {
return this.withAuthenticatingUser(repository, (repo, user) => {
return this.appStore.fetchRefspec(repo, fetchspec, user)
})
>>>>>>>
public fetchRefspec(
repository: Repository,
fetchspec: string
): Promise<void> {
return this.appStore._fetchRefspec(repository, fetchspec)
<<<<<<<
return this.appStore._fetch(repository)
=======
return this.withAuthenticatingUser(repository, (repo, user) =>
this.appStore.fetch(repo, user)
)
>>>>>>>
return this.appStore._fetch(repository)
<<<<<<<
public publishRepository(repository: Repository, name: string, description: string, private_: boolean, account: Account, org: IAPIUser | null): Promise<Repository> {
return this.appStore._publishRepository(repository, name, description, private_, account, org)
=======
public async publishRepository(
repository: Repository,
name: string,
description: string,
private_: boolean,
account: Account,
org: IAPIUser | null
): Promise<Repository> {
await this.appStore._publishRepository(
repository,
name,
description,
private_,
account,
org
)
return this.refreshGitHubRepositoryInfo(repository)
>>>>>>>
public publishRepository(
repository: Repository,
name: string,
description: string,
private_: boolean,
account: Account,
org: IAPIUser | null
): Promise<Repository> {
return this.appStore._publishRepository(
repository,
name,
description,
private_,
account,
org
)
<<<<<<<
public cloneAgain(url: string, path: string, account: Account | null): Promise<void> {
return this.appStore._cloneAgain(url, path, account)
}
=======
public async cloneAgain(
url: string,
path: string,
account: Account | null
): Promise<void> {
const { promise, repository } = this.appStore._clone(url, path, { account })
await this.selectRepository(repository)
const success = await promise
if (!success) {
return
}
// In the background the shared process has updated the repository list.
// To ensure a smooth transition back, we should lookup the new repository
// and update it's state after the clone has completed
const repositories = await this.loadRepositories()
const found = repositories.find(r => r.path === path) || null
if (found) {
const updatedRepository = await this.updateRepositoryMissing(found, false)
await this.selectRepository(updatedRepository)
}
}
>>>>>>>
public cloneAgain(
url: string,
path: string,
account: Account | null
): Promise<void> {
return this.appStore._cloneAgain(url, path, account)
}
<<<<<<<
return this.appStore._deleteBranch(repository, branch)
=======
return this.withAuthenticatingUser(repository, (repo, user) =>
this.appStore._deleteBranch(repo, branch, user)
)
>>>>>>>
return this.appStore._deleteBranch(repository, branch)
<<<<<<<
return this.appStore._removeAccount(account)
=======
return this.dispatchToSharedProcess<void>({
name: 'remove-account',
account,
})
>>>>>>>
return this.appStore._removeAccount(account)
<<<<<<<
private async updateRepositoryPath(repository: Repository, path: string): Promise<void> {
await this.appStore._updateRepositoryPath(repository, path)
=======
private async updateRepositoryPath(
repository: Repository,
path: string
): Promise<void> {
await this.dispatchToSharedProcess<IRepository>({
name: 'update-repository-path',
repository,
path,
})
>>>>>>>
private async updateRepositoryPath(
repository: Repository,
path: string
): Promise<void> {
await this.appStore._updateRepositoryPath(repository, path) |
<<<<<<<
import { withTrampolineEnvForRemoteOperation } from '../trampoline/trampoline-environment'
import { merge } from '../merge'
=======
import { envForRemoteOperation } from './environment'
import { getDefaultBranch } from '../helpers/default-branch'
>>>>>>>
import { withTrampolineEnvForRemoteOperation } from '../trampoline/trampoline-environment'
import { merge } from '../merge'
import { getDefaultBranch } from '../helpers/default-branch'
<<<<<<<
const args = [...networkArguments, 'clone', '--recursive']
=======
const env = await envForRemoteOperation(options.account, url)
const defaultBranch = options.defaultBranch ?? (await getDefaultBranch())
const args = [
...networkArguments,
'-c',
`init.defaultBranch=${defaultBranch}`,
'clone',
'--recursive',
]
>>>>>>>
const defaultBranch = options.defaultBranch ?? (await getDefaultBranch())
const args = [
...networkArguments,
'-c',
`init.defaultBranch=${defaultBranch}`,
'clone',
'--recursive',
] |
<<<<<<<
highlightAppMenuToolbarButton: this.highlightAppMenuToolbarButton,
windowOpen: this.windowOpen,
=======
highlightAccessKeys: this.highlightAccessKeys,
>>>>>>>
highlightAccessKeys: this.highlightAccessKeys,
windowOpen: this.windowOpen, |
<<<<<<<
/** Clone the repository to the path. */
public static clone(url: string, path: string, progress: (progress: string) => void): Promise<void> {
return GitProcess.exec([ 'clone', '--progress', '--', url, path ], __dirname, undefined, process => {
process.stderr.on('data', (chunk: string) => {
progress(chunk)
})
})
}
=======
/** Rename the given branch to a new name. */
public static renameBranch(repository: Repository, branch: Branch, newName: string): Promise<void> {
return GitProcess.exec([ 'branch', '-m', branch.nameWithoutRemote, newName ], repository.path)
}
>>>>>>>
/** Clone the repository to the path. */
public static clone(url: string, path: string, progress: (progress: string) => void): Promise<void> {
return GitProcess.exec([ 'clone', '--progress', '--', url, path ], __dirname, undefined, process => {
process.stderr.on('data', (chunk: string) => {
progress(chunk)
})
})
}
/** Rename the given branch to a new name. */
public static renameBranch(repository: Repository, branch: Branch, newName: string): Promise<void> {
return GitProcess.exec([ 'branch', '-m', branch.nameWithoutRemote, newName ], repository.path)
} |
<<<<<<<
if (output.length === 0) {
// the merge commit will be empty - this is fine!
return { kind: MergeResultKind.Clean, entries: [] }
}
console.time('parseMergeResult')
const mergeResult = parseMergeResult(output)
console.timeEnd('parseMergeResult')
return mergeResult
=======
return parseMergeResult(output)
>>>>>>>
if (output.length === 0) {
// the merge commit will be empty - this is fine!
return { kind: MergeResultKind.Clean, entries: [] }
}
return parseMergeResult(output) |
<<<<<<<
console.log('Parsing license metadata…')
generateLicenseMetadata(outRoot)
=======
moveAnalysisFiles()
>>>>>>>
console.log('Parsing license metadata…')
generateLicenseMetadata(outRoot)
moveAnalysisFiles() |
<<<<<<<
import { IMenuItem } from '../menu-item'
=======
import {
ShowSideBySideDiffDefault,
getShowSideBySideDiff,
setShowSideBySideDiff,
} from '../../ui/lib/diff-mode'
>>>>>>>
import { IMenuItem } from '../menu-item'
import {
ShowSideBySideDiffDefault,
getShowSideBySideDiff,
setShowSideBySideDiff,
} from '../../ui/lib/diff-mode'
<<<<<<<
const showSideBySideDiffDefault = false
const showSideBySideDiffKey = 'show-side-by-side-diff'
const commitSpellcheckEnabledDefault = false
const commitSpellcheckEnabledKey = 'commit-spellcheck-enabled'
=======
>>>>>>>
const showSideBySideDiffDefault = false
const showSideBySideDiffKey = 'show-side-by-side-diff'
const commitSpellcheckEnabledDefault = false
const commitSpellcheckEnabledKey = 'commit-spellcheck-enabled'
<<<<<<<
private showSideBySideDiff: boolean = showSideBySideDiffDefault
/** Whether or not the spellchecker is enabled for commit summary and description */
private commitSpellcheckEnabled: boolean = commitSpellcheckEnabledDefault
/** Items to display in next context menu */
private currentContextMenuItems: IMenuItem[] = []
=======
private showSideBySideDiff: boolean = ShowSideBySideDiffDefault
>>>>>>>
/** Whether or not the spellchecker is enabled for commit summary and description */
private commitSpellcheckEnabled: boolean = commitSpellcheckEnabledDefault
/** Items to display in next context menu */
private currentContextMenuItems: IMenuItem[] = []
private showSideBySideDiff: boolean = ShowSideBySideDiffDefault
<<<<<<<
this.showSideBySideDiff = getBoolean(showSideBySideDiffKey, false)
this.commitSpellcheckEnabled = getBoolean(showSideBySideDiffKey, false)
=======
this.showSideBySideDiff = getShowSideBySideDiff()
>>>>>>>
this.commitSpellcheckEnabled = getBoolean(showSideBySideDiffKey, false)
this.showSideBySideDiff = getShowSideBySideDiff() |
<<<<<<<
import { Branch } from '../../lib/local-git-operations'
=======
import { Branch } from '../local-git-operations'
>>>>>>>
import { Branch } from '../local-git-operations'
<<<<<<<
/** Rename the branch to a new name. */
public renameBranch(repository: Repository, branch: Branch, newName: string): Promise<void> {
return this.appStore._renameBranch(repository, branch, newName)
}
=======
/**
* Delete the branch. This will delete both the local branch and the remote
* branch, and then check out the default branch.
*/
public deleteBranch(repository: Repository, branch: Branch): Promise<void> {
return this.appStore._deleteBranch(repository, branch)
}
>>>>>>>
/** Rename the branch to a new name. */
public renameBranch(repository: Repository, branch: Branch, newName: string): Promise<void> {
return this.appStore._renameBranch(repository, branch, newName)
}
/**
* Delete the branch. This will delete both the local branch and the remote
* branch, and then check out the default branch.
*/
public deleteBranch(repository: Repository, branch: Branch): Promise<void> {
return this.appStore._deleteBranch(repository, branch)
} |
<<<<<<<
return enableBetaFeatures()
=======
return enableDevelopmentFeatures()
}
/**
* Enables a new UI for the repository picker that supports
* grouping and filtering (GitHub) repositories by owner/organization.
*/
export function enableGroupRepositoriesByOwner(): boolean {
return enableBetaFeatures()
>>>>>>>
return enableBetaFeatures()
}
/**
* Enables a new UI for the repository picker that supports
* grouping and filtering (GitHub) repositories by owner/organization.
*/
export function enableGroupRepositoriesByOwner(): boolean {
return enableBetaFeatures() |
<<<<<<<
/**
* Remove the repositories represented by the given IDs from local storage.
*
* When `moveToTrash` is enabled, only the repositories that were successfully
* deleted on disk are removed from the app. If some failed due to files being
* open elsewhere, an error is thrown.
*/
public async removeRepositories(
=======
/** Resume an already started onboarding tutorial */
public resumeTutorial(repository: Repository) {
return this.appStore._resumeTutorial(repository)
}
/** Suspend the onboarding tutorial and go to the no repositories blank slate view */
public pauseTutorial(repository: Repository) {
return this.appStore._pauseTutorial(repository)
}
/** Remove the repositories represented by the given IDs from local storage. */
public removeRepositories(
>>>>>>>
/** Resume an already started onboarding tutorial */
public resumeTutorial(repository: Repository) {
return this.appStore._resumeTutorial(repository)
}
/** Suspend the onboarding tutorial and go to the no repositories blank slate view */
public pauseTutorial(repository: Repository) {
return this.appStore._pauseTutorial(repository)
}
/**
* Remove the repositories represented by the given IDs from local storage.
*
* When `moveToTrash` is enabled, only the repositories that were successfully
* deleted on disk are removed from the app. If some failed due to files being
* open elsewhere, an error is thrown.
*/
public async removeRepositories( |
<<<<<<<
public constructor(name: string, owner: Owner, dbID: number | null, private_: boolean | null = null, fork: boolean | null = null, htmlURL: string | null = null, defaultBranch: string | null = 'master', cloneURL: string | null = null) {
=======
/** Create a new GitHubRepository from its data-only representation. */
public static fromJSON(json: IGitHubRepository): GitHubRepository {
return new GitHubRepository(
json.name,
Owner.fromJSON(json.owner),
json.dbID,
json.private,
json.fork,
json.htmlURL,
json.defaultBranch,
json.cloneURL
)
}
public constructor(
name: string,
owner: Owner,
dbID: number | null,
private_: boolean | null = null,
fork: boolean | null = null,
htmlURL: string | null = null,
defaultBranch: string | null = 'master',
cloneURL: string | null = null
) {
>>>>>>>
public constructor(
name: string,
owner: Owner,
dbID: number | null,
private_: boolean | null = null,
fork: boolean | null = null,
htmlURL: string | null = null,
defaultBranch: string | null = 'master',
cloneURL: string | null = null
) { |
<<<<<<<
import { ClientTestUtils } from "./ClientTestUtils";
=======
import { ClientTestUtils, MockStorageClass } from "./ClientTestUtils";
import { B2cAuthority } from "../../src/authority/B2cAuthority";
>>>>>>>
import { ClientTestUtils, MockStorageClass } from "./ClientTestUtils";
<<<<<<<
afterEach(() => {
const config = null;
=======
beforeEach(() => {
>>>>>>>
afterEach(() => {
const config = null;
<<<<<<<
=======
});
afterEach(() => {
while (B2cAuthority.B2CTrustedHostList.length) {
B2cAuthority.B2CTrustedHostList.pop();
}
>>>>>>> |
<<<<<<<
RadioCheckboxComponent,
RadioGroupComponent,
=======
Error403Component,
RadioCheckboxComponent,
>>>>>>>
RadioCheckboxComponent,
RadioGroupComponent,
Error403Component, |
<<<<<<<
import { Error403Component } from "../pages/error403/error403.component";
=======
import {RadioCheckboxComponent} from "../primary-components/radio-checkbox/radio-checkbox.component";
>>>>>>>
import { Error403Component } from "../pages/error403/error403.component";
import {RadioCheckboxComponent} from "../primary-components/radio-checkbox/radio-checkbox.component";
<<<<<<<
Error403Component,
=======
RadioCheckboxComponent,
>>>>>>>
Error403Component,
RadioCheckboxComponent,
<<<<<<<
Error403Component,
=======
RadioCheckboxComponent,
>>>>>>>
Error403Component,
RadioCheckboxComponent, |
<<<<<<<
public platform;
=======
public assetType = [];
public assetSelected: any;
>>>>>>>
public platform;
public assetType = [];
public assetSelected: any;
<<<<<<<
=======
if (changedFilter.label === 'ASSET TYPE') {
this.assetSelected = changedFilter.selected.replace(/ /g, "_")
}
}
if( changedFilter && (changedFilter.label === 'ASSET IDENTIFIER')){
this.slsLambdaselected = changedFilter.selected;
this.setAsset();
>>>>>>>
if (changedFilter.label === 'ASSET TYPE') {
this.assetSelected = changedFilter.selected.replace(/ /g, "_")
}
}
if( changedFilter && (changedFilter.label === 'ASSET IDENTIFIER')){
this.slsLambdaselected = changedFilter.selected;
this.setAsset(); |
<<<<<<<
api_doc_name: "https://{api_doc_name}.s3.amazonaws.com",
envName: "oss",
multi_env: {multi_env},
slack_support: {slack_support},
serviceTabs: ["{overview}", "{access control}", "{metrics}", "{logs}", "{cost}"],
environmentTabs: ["{env_overview}", "{deployments}", "{code quality}", "{assets}", "{env_logs}"],
urls: {
docs_link: "https://github.com/tmobile/jazz/wiki",
=======
api_doc_name : "https://{api_doc_name}.s3.amazonaws.com",
envName:"oss",
multi_env:"{multi_env}",
serviceTabs:["{overview}","{access control}","{metrics}","{logs}","{cost}"],
environmentTabs:["{env_overview}","{deployments}","{code quality}", "{metrics}", "{assets}","{env_logs}"],
urls:{
docs_link:"https://github.com/tmobile/jazz/wiki",
>>>>>>>
api_doc_name: "https://{api_doc_name}.s3.amazonaws.com",
envName: "oss",
multi_env: {multi_env},
slack_support: {slack_support},
serviceTabs: ["{overview}", "{access control}", "{metrics}", "{logs}", "{cost}"],
environmentTabs: ["{env_overview}", "{deployments}", "{code quality}", "{metrics}", "{assets}", "{env_logs}"],
urls: {
docs_link: "https://github.com/tmobile/jazz/wiki", |
<<<<<<<
this.serviceList.serviceCall();
=======
this.servicelist.serviceCall();
this.showToastPending(
'Service is getting ready',
this.toastmessage.customMessage('successPending', 'createService'),
);
>>>>>>>
this.serviceList.serviceCall();
this.showToastPending(
'Service is getting ready',
this.toastmessage.customMessage('successPending', 'createService'),
);
<<<<<<<
onFilterSelected(event){
if(event == "Function Template"){
this.startNew = false;
this.onSelectionChange(this.runtime);
}
else if(event == "Start New"){
this.startNew = true;
this.deploymentDescriptorText = "";
}
}
=======
/**
* Display pending toast
* @param title Toast title
* @param body Toast body
* @returns
*/
// TODO: Abstract out to service
showToastPending (title: string, body: string): void {
const options = {
body: body,
closeHtml: '<button>Dismiss</button>',
showCloseButton: true,
timeout: 0,
title: title,
type: 'wait',
};
// TODO: Investigate need for manual class addition
const tst = document.getElementById('toast-container');
tst.classList.add('toaster-anim');
this.toasterService.pop(options);
}
>>>>>>>
onFilterSelected(event){
if(event == "Function Template"){
this.startNew = false;
this.onSelectionChange(this.runtime);
}
else if(event == "Start New"){
this.startNew = true;
this.deploymentDescriptorText = "";
}
}
/**
* Display pending toast
* @param title Toast title
* @param body Toast body
* @returns
*/
// TODO: Abstract out to service
showToastPending (title: string, body: string): void {
const options = {
body: body,
closeHtml: '<button>Dismiss</button>',
showCloseButton: true,
timeout: 0,
title: title,
type: 'wait',
};
// TODO: Investigate need for manual class addition
const tst = document.getElementById('toast-container');
tst.classList.add('toaster-anim');
this.toasterService.pop(options);
} |
<<<<<<<
deploymentDescriptorTextJava = javaTemplate.template;
deploymentDescriptorTextNodejs = nodejsTemplate.template;
deploymentDescriptorTextgo = goTemplate.template;
deploymentDescriptorTextpython = pythonTemplate.template;
deploymentDescriptorText = this.deploymentDescriptorTextNodejs;
startNew:boolean = false;
typeofservice:boolean=true;
typeofplatform:boolean=false;
typeofserviceSelected:boolean = false;
typeofplatformSelected:boolean = false;
typeofruntimeSelected:boolean = false;
deploymenttargetSelected:boolean = false;
typeOfRuntime:string = "nodejs";
ids=[
"service-type-section",
"deployment-type-section",
"additional",
"typeevents"
]
isyamlValid:boolean = true;
typeform:boolean=false;
typeevents:boolean=false;
deploymentDescriptorFilterData = ["Function Template", "Start New"];
selectedList:string='Function Template';
sqsStreamString:string = "arn:aws:sqs:" + env_oss.aws.region + ":" + env_oss.aws.account_number + ":";
kinesisStreamString:string = "arn:aws:kinesis:" + env_oss.aws.region + ":" + env_oss.aws.account_number + ":stream/";
dynamoStreamString:string = "arn:aws:dynamo:" + env_oss.aws.region + ":" + env_oss.aws.account_number + ":table/";
=======
sqsStreamString:string;
kinesisStreamString:string;
dynamoStreamString:string;
>>>>>>>
deploymentDescriptorTextJava = javaTemplate.template;
deploymentDescriptorTextNodejs = nodejsTemplate.template;
deploymentDescriptorTextgo = goTemplate.template;
deploymentDescriptorTextpython = pythonTemplate.template;
deploymentDescriptorText = this.deploymentDescriptorTextNodejs;
startNew:boolean = false;
typeofservice:boolean=true;
typeofplatform:boolean=false;
typeofserviceSelected:boolean = false;
typeofplatformSelected:boolean = false;
typeofruntimeSelected:boolean = false;
deploymenttargetSelected:boolean = false;
typeOfRuntime:string = "nodejs";
ids=[
"service-type-section",
"deployment-type-section",
"additional",
"typeevents"
]
isyamlValid:boolean = true;
typeform:boolean=false;
typeevents:boolean=false;
deploymentDescriptorFilterData = ["Function Template", "Start New"];
selectedList:string='Function Template';
sqsStreamString:string = "arn:aws:sqs:" + env_oss.aws.region + ":" + env_oss.aws.account_number + ":";
kinesisStreamString:string = "arn:aws:kinesis:" + env_oss.aws.region + ":" + env_oss.aws.account_number + ":stream/";
dynamoStreamString:string = "arn:aws:dynamo:" + env_oss.aws.region + ":" + env_oss.aws.account_number + ":table/";
sqsStreamString:string;
kinesisStreamString:string;
dynamoStreamString:string;
<<<<<<<
scrollTo(id) {
const ele = document.getElementById(id);
if(ele){
ele.scrollIntoView({ behavior: 'smooth', block: 'center'});
}
}
=======
selectAccountsRegions(){
this.accountMap = env_oss.accountMap;
this.accountList = [];
this.regionList = [];
this.accountMap.map((item)=>{
this.accountList.push(item.account + ' (' + item.accountName + ')' )
if(item.primary){
this.accountSelected = item.account
this.accountDetails = item.account + ' (' + item.accountName + ')'
}
})
this.regionList = this.accountMap[0].regions;
this.regionSelected = this.regionList[0];
this.setAccountandRegion();
}
setAccountandRegion(){
this.sqsStreamString = "arn:aws:sqs:" + this.regionSelected + ":" + this.accountSelected + ":";
this.kinesisStreamString = "arn:aws:kinesis:" + this.regionSelected + ":" + this.accountSelected + ":stream/";
this.dynamoStreamString = "arn:aws:dynamo:" + this.regionSelected + ":" + this.accountSelected + ":table/";
}
>>>>>>>
scrollTo(id) {
const ele = document.getElementById(id);
if(ele){
ele.scrollIntoView({ behavior: 'smooth', block: 'center'});
}
selectAccountsRegions(){
this.accountMap = env_oss.accountMap;
this.accountList = [];
this.regionList = [];
this.accountMap.map((item)=>{
this.accountList.push(item.account + ' (' + item.accountName + ')' )
if(item.primary){
this.accountSelected = item.account
this.accountDetails = item.account + ' (' + item.accountName + ')'
}
})
this.regionList = this.accountMap[0].regions;
this.regionSelected = this.regionList[0];
this.setAccountandRegion();
}
setAccountandRegion(){
this.sqsStreamString = "arn:aws:sqs:" + this.regionSelected + ":" + this.accountSelected + ":";
this.kinesisStreamString = "arn:aws:kinesis:" + this.regionSelected + ":" + this.accountSelected + ":stream/";
this.dynamoStreamString = "arn:aws:dynamo:" + this.regionSelected + ":" + this.accountSelected + ":table/";
}
<<<<<<<
onFilterSelected(event){
if(event == "Function Template"){
this.startNew = false;
this.onSelectionChange(this.runtime);
}
else if(event == "Start New"){
this.startNew = true;
this.deploymentDescriptorText = "";
}
}
=======
onaccountSelected(event){
this.accountMap.map((item,index)=>{
if((item.account + ' (' + item.accountName + ')') === event){
this.accountSelected = item.account
this.accountDetails = item.account + ' (' + item.accountName + ')'
this.regionList = item.regions;
this.regionSelected = this.regionList[0];
}
})
this.setAccountandRegion() ;
}
onregionSelected(event){
this.regionSelected = event;
this.setAccountandRegion();
}
>>>>>>>
onFilterSelected(event){
if(event == "Function Template"){
this.startNew = false;
this.onSelectionChange(this.runtime);
}
else if(event == "Start New"){
this.startNew = true;
this.deploymentDescriptorText = "";
}
}
onaccountSelected(event){
this.accountMap.map((item,index)=>{
if((item.account + ' (' + item.accountName + ')') === event){
this.accountSelected = item.account
this.accountDetails = item.account + ' (' + item.accountName + ')'
this.regionList = item.regions;
this.regionSelected = this.regionList[0];
}
})
this.setAccountandRegion() ;
}
onregionSelected(event){
this.regionSelected = event;
this.setAccountandRegion();
}
<<<<<<<
console.log('nodejsTemplate',nodejsTemplate);
=======
this.selectAccountsRegions();
>>>>>>>
console.log('nodejsTemplate',nodejsTemplate);
this.selectAccountsRegions(); |
<<<<<<<
import {OrderByPipe} from '../core/pipes/order-by.pipe';
=======
import { CopyElementComponent } from '../secondary-components/copy-element/copy-element.component';
>>>>>>>
import {OrderByPipe} from '../core/pipes/order-by.pipe';
import { CopyElementComponent } from '../secondary-components/copy-element/copy-element.component';
<<<<<<<
OrderByPipe,
=======
CopyElementComponent,
>>>>>>>
OrderByPipe,
CopyElementComponent,
<<<<<<<
OrderByPipe,
=======
CopyElementComponent,
>>>>>>>
OrderByPipe,
CopyElementComponent, |
<<<<<<<
// export { default as useKeyboardJs } from './useKeyboardJs';
export { default as useKeyPress } from './useKeyPress';
export { default as useKeyPressEvent } from './useKeyPressEvent';
export { default as useLifecycles } from './useLifecycles';
export { default as useList } from './useList';
export { default as useLocalStorage } from './useLocalStorage';
export { default as useLocation } from './useLocation';
export { default as useLockBodyScroll } from './useLockBodyScroll';
export { default as useLogger } from './useLogger';
export { default as useMap } from './useMap';
export { default as useMedia } from './useMedia';
export { default as useMediaDevices } from './useMediaDevices';
export { default as useMotion } from './useMotion';
export { default as useMount } from './useMount';
export { default as useMouse } from './useMouse';
export { default as useMouseHovered } from './useMouseHovered';
export { default as useNetwork } from './useNetwork';
export { default as useNumber } from './useNumber';
export { default as useObservable } from './useObservable';
export { default as useOrientation } from './useOrientation';
export { default as usePageLeave } from './usePageLeave';
export { default as usePermission } from './usePermission';
export { default as usePrevious } from './usePrevious';
export { default as usePromise } from './usePromise';
export { default as useRaf } from './useRaf';
export { default as useRafLoop } from './useRafLoop';
export { default as useRefMounted } from './useRefMounted';
export { default as useScroll } from './useScroll';
export { default as useScrolling } from './useScrolling';
export { default as useSessionStorage } from './useSessionStorage';
export { default as useSetState } from './useSetState';
export { default as useSize } from './useSize';
export { default as useSpeech } from './useSpeech';
=======
// export { default as useKeyboardJs } from './useKeyboardJs';
export { default as useKeyPress } from './useKeyPress';
export { default as useKeyPressEvent } from './useKeyPressEvent';
export { default as useLifecycles } from './useLifecycles';
export { default as useList } from './useList';
export { default as useLocalStorage } from './useLocalStorage';
export { default as useLocation } from './useLocation';
export { default as useLockBodyScroll } from './useLockBodyScroll';
export { default as useLogger } from './useLogger';
export { default as useMap } from './useMap';
export { default as useMedia } from './useMedia';
export { default as useMediaDevices } from './useMediaDevices';
export { default as useMotion } from './useMotion';
export { default as useMount } from './useMount';
export { default as useMountedState } from './useMountedState';
export { default as useMouse } from './useMouse';
export { default as useMouseHovered } from './useMouseHovered';
export { default as useNetwork } from './useNetwork';
export { default as useNumber } from './useNumber';
export { default as useObservable } from './useObservable';
export { default as useOrientation } from './useOrientation';
export { default as usePageLeave } from './usePageLeave';
export { default as usePermission } from './usePermission';
export { default as usePrevious } from './usePrevious';
export { default as usePromise } from './usePromise';
export { default as useRaf } from './useRaf';
export { default as useRefMounted } from './useRefMounted';
export { default as useScroll } from './useScroll';
export { default as useScrolling } from './useScrolling';
export { default as useSessionStorage } from './useSessionStorage';
export { default as useSetState } from './useSetState';
export { default as useSize } from './useSize';
export { default as useSpeech } from './useSpeech';
>>>>>>>
// export { default as useKeyboardJs } from './useKeyboardJs';
export { default as useKeyPress } from './useKeyPress';
export { default as useKeyPressEvent } from './useKeyPressEvent';
export { default as useLifecycles } from './useLifecycles';
export { default as useList } from './useList';
export { default as useLocalStorage } from './useLocalStorage';
export { default as useLocation } from './useLocation';
export { default as useLockBodyScroll } from './useLockBodyScroll';
export { default as useLogger } from './useLogger';
export { default as useMap } from './useMap';
export { default as useMedia } from './useMedia';
export { default as useMediaDevices } from './useMediaDevices';
export { default as useMotion } from './useMotion';
export { default as useMount } from './useMount';
export { default as useMountedState } from './useMountedState';
export { default as useMouse } from './useMouse';
export { default as useMouseHovered } from './useMouseHovered';
export { default as useNetwork } from './useNetwork';
export { default as useNumber } from './useNumber';
export { default as useObservable } from './useObservable';
export { default as useOrientation } from './useOrientation';
export { default as usePageLeave } from './usePageLeave';
export { default as usePermission } from './usePermission';
export { default as usePrevious } from './usePrevious';
export { default as usePromise } from './usePromise';
export { default as useRaf } from './useRaf';
export { default as useRafLoop } from './useRafLoop';
export { default as useRefMounted } from './useRefMounted';
export { default as useScroll } from './useScroll';
export { default as useScrolling } from './useScrolling';
export { default as useSessionStorage } from './useSessionStorage';
export { default as useSetState } from './useSetState';
export { default as useSize } from './useSize';
export { default as useSpeech } from './useSpeech'; |
<<<<<<<
export const off = (obj: any, ...args: any[]) => obj.removeEventListener(...args);
export type FnReturningPromise = (...args: any[]) => Promise<any>;
export type PromiseType<P extends Promise<any>> = P extends Promise<infer T> ? T : never;
=======
export const off = (obj: any, ...args: any[]) => obj.removeEventListener(...args);
export const isDeepEqual: (a: any, b: any) => boolean = require('fast-deep-equal/react');
>>>>>>>
export const off = (obj: any, ...args: any[]) => obj.removeEventListener(...args);
export type FnReturningPromise = (...args: any[]) => Promise<any>;
export type PromiseType<P extends Promise<any>> = P extends Promise<infer T> ? T : never;
export const isDeepEqual: (a: any, b: any) => boolean = require('fast-deep-equal/react'); |
<<<<<<<
this.spaCacheManager.removeAllAccessTokens(this.clientConfig.auth.clientId, authorityUri, "", homeAccountIdentifier);
=======
this.cacheManager.removeAllAccessTokens(this.config.authOptions.clientId, authorityUri, "", homeAccountIdentifier);
>>>>>>>
this.spaCacheManager.removeAllAccessTokens(this.config.authOptions.clientId, authorityUri, "", homeAccountIdentifier);
<<<<<<<
const responseHandler = new SPAResponseHandler(this.clientConfig.auth.clientId, this.cacheStorage, this.spaCacheManager, this.cryptoUtils, this.logger);
=======
const responseHandler = new SPAResponseHandler(this.config.authOptions.clientId, this.cacheStorage, this.cacheManager, this.cryptoUtils, this.logger);
>>>>>>>
const responseHandler = new SPAResponseHandler(this.config.authOptions.clientId, this.cacheStorage, this.spaCacheManager, this.cryptoUtils, this.logger);
<<<<<<<
const tokenCacheItems: Array<AccessTokenCacheItem> = this.spaCacheManager.getAllAccessTokens(this.clientConfig.auth.clientId, authorityUri || "", resourceId || "", homeAccountIdentifier || "");
=======
const tokenCacheItems: Array<AccessTokenCacheItem> = this.cacheManager.getAllAccessTokens(this.config.authOptions.clientId, authorityUri || "", resourceId || "", homeAccountIdentifier || "");
>>>>>>>
const tokenCacheItems: Array<AccessTokenCacheItem> = this.spaCacheManager.getAllAccessTokens(this.config.authOptions.clientId, authorityUri || "", resourceId || "", homeAccountIdentifier || "");
<<<<<<<
const responseHandler = new SPAResponseHandler(this.clientConfig.auth.clientId, this.cacheStorage, this.spaCacheManager, this.cryptoUtils, this.logger);
=======
const responseHandler = new SPAResponseHandler(this.config.authOptions.clientId, this.cacheStorage, this.cacheManager, this.cryptoUtils, this.logger);
>>>>>>>
const responseHandler = new SPAResponseHandler(this.config.authOptions.clientId, this.cacheStorage, this.spaCacheManager, this.cryptoUtils, this.logger); |
<<<<<<<
import { commands, Disposable, workspace, window, TreeView, ExtensionContext } from "vscode";
import { launchWebDashboard, updatePreferences } from "./DataController";
=======
import { commands, Disposable, workspace, window, TreeView } from "vscode";
import { launchWebDashboard } from "./DataController";
>>>>>>>
import { commands, Disposable, window, ExtensionContext } from "vscode";
import { launchWebDashboard } from "./DataController";
<<<<<<<
commands.registerCommand("codetime.toggleSlackPresence", () => {
toggleSlackPresence();
})
);
cmds.push(
commands.registerCommand("codetime.enterFlowMode", () => {
enableFlow();
=======
commands.registerCommand("codetime.enableFlow", () => {
enableFlow({automated: false});
>>>>>>>
commands.registerCommand("codetime.enableFlow", () => {
enableFlow({ automated: false }); |
<<<<<<<
subscriptions.push(
registerCommand('gatsbyhub.openBrowser', Utilities.openBrowser)
);
=======
subscriptions.push(
createTreeView('commands', {
treeDataProvider: new CommandProvider(),
})
);
>>>>>>>
subscriptions.push(
registerCommand('gatsbyhub.openBrowser', Utilities.openBrowser)
);
subscriptions.push(
createTreeView('commands', {
treeDataProvider: new CommandProvider(),
})
); |
<<<<<<<
// eslint-disable-next-line object-curly-newline
import { ExtensionContext, commands, window, workspace, Uri } from 'vscode';
import * as path from 'path';
import GatsbyCli from './commands/gatsbycli';
import PluginProvider from './models/PluginProvider';
=======
import * as vscode from "vscode";
import { ExtensionContext, commands, window } from "vscode";
import GatsbyCli from "./commands/gatsbycli";
import StatusBar from "./utils/statusBarItem";
import PluginProvider from "./models/PluginProvider";
import Plugin from "./models/Plugin";
import EachPlugin from "./models/EachPlugin";
import PluginData from "./models.PluginData";
>>>>>>>
// eslint-disable-next-line object-curly-newline
import { ExtensionContext, commands, window, workspace, Uri } from 'vscode';
import * as path from 'path';
import GatsbyCli from './commands/gatsbycli';
import PluginProvider from './models/PluginProvider';
import * as vscode from "vscode";
import StatusBar from "./utils/statusBarItem";
import Plugin from "./models/Plugin";
import EachPlugin from "./models/EachPlugin";
import PluginData from "./models.PluginData";
<<<<<<<
/* console.log(Uri.file(path.resolve(__dirname, '../'))); */
const uri = Uri.file(path.resolve(__dirname));
console.log('uri: ', uri);
workspace.fs.readDirectory(uri).then((data) => {
data.forEach((file) => {
if (file[0] === 'package.json') console.log(file[0]);
});
});
=======
>>>>>>>
/* console.log(Uri.file(path.resolve(__dirname, '../'))); */
const uri = Uri.file(path.resolve(__dirname));
console.log('uri: ', uri);
workspace.fs.readDirectory(uri).then((data) => {
data.forEach((file) => {
if (file[0] === 'package.json') console.log(file[0]);
});
});
<<<<<<<
registerCommand('gatsbyhub.openPluginDocs', GatsbyCli.installPlugin)
=======
registerCommand("gatsbyhub.openPluginDocs", GatsbyCli.installPlugin)
>>>>>>>
registerCommand('gatsbyhub.openPluginDocs', GatsbyCli.installPlugin) |
<<<<<<<
import * as vscode from "vscode";
import { ExtensionContext, commands, window } from "vscode";
import GatsbyCli from "./commands/gatsbycli";
import StatusBar from "./utils/statusBarItem";
import PluginProvider from "./models/PluginProvider";
import Plugin from "./models/Plugin";
import EachPlugin from "./models/EachPlugin";
import PluginData from "./models.PluginData";
=======
// eslint-disable-next-line object-curly-newline
import { ExtensionContext, commands, window, workspace, Uri } from 'vscode';
import * as path from 'path';
import GatsbyCli from './commands/gatsbycli';
import PluginProvider from './models/PluginProvider';
>>>>>>>
import { ExtensionContext, commands, window, workspace, Uri } from 'vscode';
import * as path from 'path';
import GatsbyCli from './commands/gatsbycli';
import PluginProvider from './models/PluginProvider';
<<<<<<<
=======
/* console.log(Uri.file(path.resolve(__dirname, '../'))); */
const uri = Uri.file(path.resolve(__dirname));
console.log('uri: ', uri);
workspace.fs.readDirectory(uri).then((data) => {
data.forEach((file) => {
if (file[0] === 'package.json') console.log(file[0]);
});
});
>>>>>>>
/* console.log(Uri.file(path.resolve(__dirname, '../'))); */
const uri = Uri.file(path.resolve(__dirname));
console.log('uri: ', uri);
workspace.fs.readDirectory(uri).then((data) => {
data.forEach((file) => {
if (file[0] === 'package.json') console.log(file[0]);
});
}); |
<<<<<<<
=======
>>>>>>>
<<<<<<<
this._contextualHost = this._container;
this.disposeModal = this.disposeModal;
=======
this._contextualHost = this._container;
>>>>>>>
this._contextualHost = this._container; |
<<<<<<<
// var button = new fabric.Button(_container, {
// "clickHandler": function(e) {
// }
// }
// );
=======
>>>>>>>
// var button = new fabric.Button(_container, {
// "clickHandler": function(e) {
// }
// }
// ); |
<<<<<<<
import { PerPageMessageCount, MessageStatus } from '@/utils/constants'
import { delMedia } from '@/utils/util'
=======
import { PerPageMessageCount, MessageStatus, messageType } from '@/utils/constants'
>>>>>>>
import { delMedia } from '@/utils/util'
import { PerPageMessageCount, MessageStatus, messageType } from '@/utils/constants' |
<<<<<<<
getMessagesByIds(messageIds: any) {
return db.prepare(`SELECT * FROM messages WHERE message_id IN (${messageIds.map(() => '?').join(',')})`).all(messageIds)
}
=======
findMessageById(messageId: any, userId: any) {
return db.prepare('SELECT * FROM messages WHERE message_id = ? AND user_id = ?').get(messageId, userId)
}
>>>>>>>
getMessagesByIds(messageIds: any) {
return db.prepare(`SELECT * FROM messages WHERE message_id IN (${messageIds.map(() => '?').join(',')})`).all(messageIds)
}
findMessageById(messageId: any, userId: any) {
return db.prepare('SELECT * FROM messages WHERE message_id = ? AND user_id = ?').get(messageId, userId)
} |
<<<<<<<
import { remote, nativeImage, ipcRenderer } from 'electron'
import { MimeType } from '@/utils/constants'
=======
import { remote, nativeImage } from 'electron'
import { MimeType, messageType } from '@/utils/constants'
>>>>>>>
import { remote, nativeImage, ipcRenderer } from 'electron'
import { MimeType, messageType } from '@/utils/constants'
<<<<<<<
const identityNumber = getIdentityNumber()
let dir = getMediaNewDir(category, identityNumber, conversationId)
if (!dir) {
=======
let dir
if (messageType(message.category) === 'image') {
dir = getImagePath()
} else if (messageType(message.category) === 'video') {
dir = getVideoPath()
} else if (messageType(message.category) === 'file') {
dir = getDocumentPath()
} else if (messageType(message.category) === 'audio') {
dir = getAudioPath()
} else {
>>>>>>>
const identityNumber = getIdentityNumber()
let dir = getMediaNewDir(category, identityNumber, conversationId)
if (!dir) {
<<<<<<<
const { localPath, name } = processAttachment(mediaUrl, mediaMimeType, category, id, conversationId)
if (category.endsWith('_IMAGE')) {
=======
const { localPath, name } = processAttachment(mediaUrl, mediaMimeType, category, id)
if (messageType(category) === 'image') {
>>>>>>>
const { localPath, name } = processAttachment(mediaUrl, mediaMimeType, category, id, conversationId)
if (messageType(category) === 'image') { |
<<<<<<<
id: `arc-${this.options.id}`,
d: SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, startAngle, endAngle),
class: `background-circle ${customCssClass}`,
=======
"id": `arc-${this.options.id}`,
"d": SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, startAngle, endAngle),
"class": "background-circle",
"stroke-width": this.options.backgroundCircleWidth,
>>>>>>>
id: `arc-${this.options.id}`,
d: SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, startAngle, endAngle),
class: `background-circle ${customCssClass}`,
"stroke-width": this.options.backgroundCircleWidth,
<<<<<<<
id: `arc-${this.options.id}`,
class: `foreground-circle ${customCssClass}`,
d: SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, 0, endAngle),
transform: `rotate(-90, ${this.coordinates.x}, ${this.coordinates.y})`,
=======
"id": `arc-${this.options.id}`,
"class": "foreground-circle",
"d": SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, 0, endAngle),
"transform": `rotate(-90, ${this.coordinates.x}, ${this.coordinates.y})`,
"stroke-width": this.options.foregroundCircleWidth,
>>>>>>>
id: `arc-${this.options.id}`,
class: `foreground-circle ${customCssClass}`,
d: SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, 0, endAngle),
transform: `rotate(-90, ${this.coordinates.x}, ${this.coordinates.y})`,
"stroke-width": this.options.foregroundCircleWidth, |
<<<<<<<
public drawContainer = (additionalAttributes?: object) => {
=======
public drawContainer = () => {
const {minX, minY, width, height} = this.getViewBoxParams();
>>>>>>>
public drawContainer = (additionalAttributes?: object) => {
const {minX, minY, width, height} = this.getViewBoxParams();
<<<<<<<
height: this.size.height / this.heightDivider,
=======
height: this.size.height,
viewBox: `${minX} ${minY} ${width} ${height}`,
>>>>>>>
height: this.size.height / this.heightDivider,
viewBox: `${minX} ${minY} ${width} ${height}`, |
<<<<<<<
id: `arc-${this.options.id}`,
class: `foreground-circle ${customCssClass}`,
d: SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, 0, endAngle),
=======
"id": `arc-${this.options.id}`,
"class": "foreground-circle",
"d": SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, 0, endAngle),
"stroke-width": this.options.foregroundCircleWidth,
>>>>>>>
id: `arc-${this.options.id}`,
class: `foreground-circle ${customCssClass}`,
d: SvgTagsHelper.describeArc(this.coordinates.x, this.coordinates.y, this.radius, 0, endAngle),
"stroke-width": this.options.foregroundCircleWidth, |
<<<<<<<
this.createInstancePropertyDescriptorListener(name);
=======
this.createInstancePropertyDescriptorListener(key, descriptor, prototype);
>>>>>>>
this.createInstancePropertyDescriptorListener(name, descriptor, prototype);
<<<<<<<
const names = Object.getOwnPropertyNames(prototype);
names.forEach((name: string) => {
this.createInstanceActionListener(name);
});
=======
let names = Object.getOwnPropertyNames(prototype);
for (let i = 0; i < names.length; i++) {
this.createInstanceActionListener(names[i], prototype);
}
if (!recurse) {
return;
}
>>>>>>>
const names = Object.getOwnPropertyNames(prototype);
names.forEach((name: string) => {
this.createInstanceActionListener(name, prototype);
});
if (!recurse) {
return;
}
<<<<<<<
Object.keys(this.clazz.prototype).forEach((key: string) => {
this.createInstanceActionListener(key);
});
=======
for (let key in this.clazz.prototype) {
this.createInstanceActionListener(key, this.clazz.prototype);
}
>>>>>>>
Object.keys(this.clazz.prototype).forEach((key: string) => {
this.createInstanceActionListener(key, this.clazz.prototype);
});
<<<<<<<
Object.keys(subKeys).forEach((subKey: string) => {
this.createInstanceActionListener(subKey);
});
=======
for (let subKey in subKeys) {
this.createInstanceActionListener(subKey, this.clazz.prototype);
}
>>>>>>>
Object.keys(subKeys).forEach((subKey: string) => {
this.createInstanceActionListener(subKey, this.clazz.prototype);
});
<<<<<<<
private getMethodStub(key, args): MethodStub {
const methodStub: MethodStubCollection = this.methodStubCollections[key];
if (!methodStub) {
return new ReturnValueMethodStub(-1, [], null);
} else if (methodStub.hasMatchingInAnyGroup(args)) {
=======
private getMethodStub(key: string, args: any[]): MethodStub {
let methodStub: MethodStubCollection = this.methodStubCollections[key];
if (methodStub && methodStub.hasMatchingInAnyGroup(args)) {
>>>>>>>
protected getEmptyMethodStub(key: string, args: any[]): MethodStub {
return new ReturnValueMethodStub(-1, [], null);
}
private createMethodStubsFromPrototypeKeys(): void {
Object.keys(this.clazz.prototype).forEach((key: string) => {
this.createMethodStub(key);
});
}
private createMethodStubsFromClassCode(): void {
const subKeys = this.redundantMethodNameInCodeFinder.find(this.clazz.toString());
Object.keys(subKeys).forEach((subKey: string) => {
this.createMethodStub(subKey);
});
}
private createMethodStubsFromFunctionsCode(): void {
Object.keys(this.clazz.prototype).forEach((key: string) => {
const subKeys = this.redundantMethodNameInCodeFinder.find(this.subKeysInCodeFinder.get(this.clazz.prototype, key));
Object.keys(subKeys).forEach((subKey: string) => {
this.createMethodStub(subKey);
});
});
}
private createPropertyStub(key: string): void {
if (this.mock.hasOwnProperty(key)) {
return;
}
Object.defineProperty(this.mock, key, {
get: this.createMethodToStub(key),
});
}
private createMethodStub(key) {
if (this.mock.hasOwnProperty(key)) {
return;
}
this.mock[key] = this.createMethodToStub(key);
}
private createMethodToStub(key: string): () => any {
return (...args) => {
if (!this.methodStubCollections[key]) {
this.methodStubCollections[key] = new MethodStubCollection();
}
const matchers: Matcher[] = [];
for (const arg of args) {
if (!(arg instanceof Matcher)) {
matchers.push(strictEqual(arg));
} else {
matchers.push(arg);
}
}
return new MethodToStub(this.methodStubCollections[key], matchers, this, key);
};
}
private createInstanceActionListenersFromPrototypeKeys(): void {
Object.keys(this.clazz.prototype).forEach((key: string) => {
this.createInstanceActionListener(key, this.clazz.prototype);
});
}
private createInstanceActionListenersFromClassCode(): void {
const subKeys = this.redundantMethodNameInCodeFinder.find(this.clazz.toString());
Object.keys(subKeys).forEach((subKey: string) => {
this.createInstanceActionListener(subKey, this.clazz.prototype);
});
}
private createInstanceActionListenersFromFunctionsCode(): void {
Object.keys(this.clazz.prototype).forEach((key: string) => {
const subKeys = this.redundantMethodNameInCodeFinder.find(this.subKeysInCodeFinder.get(this.clazz.prototype, key));
Object.keys(subKeys).forEach((subKey: string) => {
this.createInstanceActionListener(subKey, this.clazz.prototype);
});
});
}
private getMethodStub(key: string, args: any[]): MethodStub {
const methodStub: MethodStubCollection = this.methodStubCollections[key];
if (methodStub && methodStub.hasMatchingInAnyGroup(args)) {
<<<<<<<
=======
protected getEmptyMethodStub(key: string, args: any[]): MethodStub {
return new ReturnValueMethodStub(-1, [], null);
}
getActionsByName(name: string): MethodAction[] {
return this.methodActions.filter(action => action.methodName === name);
}
>>>>>>> |
<<<<<<<
if (interactionType === Constants.interactionTypePopup) {
// Generate a popup window
try {
popUpWindow = this.openPopup("about:blank", "msal", Constants.popUpWidth, Constants.popUpHeight);
// Push popup window handle onto stack for tracking
WindowUtils.trackPopup(popUpWindow);
} catch (e) {
this.logger.info(ClientAuthErrorMessage.popUpWindowError.code + ":" + ClientAuthErrorMessage.popUpWindowError.desc);
this.cacheStorage.setItem(ErrorCacheKeys.ERROR, ClientAuthErrorMessage.popUpWindowError.code);
this.cacheStorage.setItem(ErrorCacheKeys.ERROR_DESC, ClientAuthErrorMessage.popUpWindowError.desc);
if (reject) {
reject(ClientAuthError.createPopupWindowError());
}
}
if (!popUpWindow) {
return;
}
}
try {
if (!acquireTokenAuthority.hasCachedMetadata()) {
this.logger.verbose("No cached metadata for authority");
await AuthorityFactory.saveMetadataFromNetwork(acquireTokenAuthority, this.telemetryManager, request.correlationId);
} else {
this.logger.verbose("Cached metadata found for authority");
}
=======
acquireTokenAuthority.resolveEndpointsAsync(this.telemetryManager, request.correlationId).then(async () => {
>>>>>>>
try {
if (!acquireTokenAuthority.hasCachedMetadata()) {
this.logger.verbose("No cached metadata for authority");
await AuthorityFactory.saveMetadataFromNetwork(acquireTokenAuthority, this.telemetryManager, request.correlationId);
} else {
this.logger.verbose("Cached metadata found for authority");
}
<<<<<<<
} catch (err) {
=======
}).catch((err) => {
>>>>>>>
} catch (err) { |
<<<<<<<
template?: string;
context?: { [name: string]: any; };
transporterName?: string;
=======
template?: string;
context?: {
[name: string]: any;
};
attachments?: {
filename: string,
contents?: any,
path?: string,
contentType?: string
cid: string
}[]
>>>>>>>
template?: string;
context?: {
[name: string]: any;
};
transporterName?: string;
attachments?: {
filename: string,
contents?: any,
path?: string,
contentType?: string
cid: string
}[] |
<<<<<<<
config: {[key: string]: any};
fields: Field[];
=======
>>>>>>>
config: {[key: string]: any}; |
<<<<<<<
import { formatError, uniqBy, Predicate, groupBy } from '../common/utils';
import { Repository, RefType, UpstreamRef } from '../typings/git';
=======
import { formatError, uniqBy, Predicate } from '../common/utils';
import { Repository, RefType, UpstreamRef, Branch } from '../typings/git';
>>>>>>>
import { formatError, uniqBy, Predicate } from '../common/utils';
import { Repository, RefType, UpstreamRef } from '../typings/git';
<<<<<<<
return this.addCommentToPendingReview(pullRequest, pendingReviewId, body, { inReplyTo: String(reply_to.id) });
=======
return this.addCommentToPendingReview(pullRequest, pendingReviewId, body, { inReplyTo: reply_to.graphNodeId });
>>>>>>>
return this.addCommentToPendingReview(pullRequest, pendingReviewId, body, { inReplyTo: reply_to.graphNodeId });
<<<<<<<
const reviewComments = await this.getPullRequestComments(pullRequest);
// Group comments by file and position
const commentsByFile = groupBy(reviewComments, comment => comment.path!);
for (let file in commentsByFile) {
const fileComments = commentsByFile[file];
const commentThreads = groupBy(fileComments, (comment: Comment) => String(comment.position === undefined ? comment.originalPosition! : comment.position));
// Loop through threads, for each thread, see if there is a matching review, push all comments to it
for (let i in commentThreads) {
const comments = commentThreads[i];
const reviewId = comments[0].pullRequestReviewId;
if (reviewId) {
const matchingEvent = reviewEvents.find(review => review.id === reviewId);
if (matchingEvent) {
if (matchingEvent.comments) {
matchingEvent.comments = matchingEvent.comments.concat(comments);
} else {
matchingEvent.comments = comments;
}
}
}
=======
const reviewComments = await this.getPullRequestComments(pullRequest) as CommentNode[];
const reviewEventsById = reviewEvents.reduce((index, evt) => {
index[evt.id] = evt;
evt.comments = [];
return index;
}, {});
const commentsById = reviewComments.reduce((index, evt) => {
index[evt.id] = evt;
return index;
}, {});
const roots: CommentNode[] = [];
let i = reviewComments.length; while (i --> 0) {
const c: CommentNode = reviewComments[i];
if (!c.inReplyToId) {
roots.unshift(c);
continue;
>>>>>>>
const reviewComments = await this.getPullRequestComments(pullRequest) as CommentNode[];
const reviewEventsById = reviewEvents.reduce((index, evt) => {
index[evt.id] = evt;
evt.comments = [];
return index;
}, {} as { [key: number]: CommonReviewEvent });
const commentsById = reviewComments.reduce((index, evt) => {
index[evt.id] = evt;
return index;
}, {} as { [key: number]: CommentNode });
const roots: CommentNode[] = [];
let i = reviewComments.length; while (i --> 0) {
const c: CommentNode = reviewComments[i];
if (!c.inReplyToId) {
roots.unshift(c);
continue; |
<<<<<<<
const repository = new GitHubRepository(remote, this._credentialStore, this._telemetry);
await repository.resolveRemote();
=======
const repository = new GitHubRepository(remote, this._credentialStore);
resolveRemotePromises.push(repository.resolveRemote());
>>>>>>>
const repository = new GitHubRepository(remote, this._credentialStore, this._telemetry);
resolveRemotePromises.push(repository.resolveRemote()); |
<<<<<<<
import { Repository } from '../git/api';
import { Comment } from './comment';
=======
import { Repository } from '../typings/git';
import { IRawFileChange } from '../github/interface';
>>>>>>>
import { Repository } from '../git/api';
import { IRawFileChange } from '../github/interface'; |
<<<<<<<
import { GitErrorCodes } from './git/api';
=======
import { GitErrorCodes } from './typings/git';
import { Comment } from './common/comment';
import { PullRequestManager } from './github/pullRequestManager';
import { PullRequestModel } from './github/pullRequestModel';
>>>>>>>
import { GitErrorCodes } from './git/api';
import { Comment } from './common/comment';
import { PullRequestManager } from './github/pullRequestManager';
import { PullRequestModel } from './github/pullRequestModel'; |
<<<<<<<
import { TimelineEvent, EventType, ReviewEvent } from '../common/timelineEvent';
=======
import { exec } from '../common/git';
import { TimelineEvent, EventType, ReviewEvent, CommitEvent } from '../common/timelineEvent';
>>>>>>>
import { TimelineEvent, EventType, ReviewEvent, CommitEvent } from '../common/timelineEvent'; |
<<<<<<<
const gitChangeType = getGitChangeType(review.status);
let originalFileExist = false;
=======
let originalFileExist;
>>>>>>>
let originalFileExist = false; |
<<<<<<<
import { IPullRequestModel, IPullRequestManager, ITelemetry } from '../github/interface';
import { Repository, GitErrorCodes, Branch } from '../git/api';
=======
import { ITelemetry } from '../github/interface';
import { Repository, GitErrorCodes, Branch } from '../typings/git';
>>>>>>>
import { ITelemetry } from '../github/interface';
import { Repository, GitErrorCodes, Branch } from '../git/api'; |
<<<<<<<
export function convertIssuesCreateCommentResponseToComment(comment: Octokit.IssuesCreateCommentResponse | Octokit.IssuesEditCommentResponse, githubRepository: GitHubRepository): IComment {
=======
export function convertIssuesCreateCommentResponseToComment(comment: Octokit.IssuesCreateCommentResponse | Octokit.IssuesUpdateCommentResponse, githubRepository: GitHubRepository): Comment {
>>>>>>>
export function convertIssuesCreateCommentResponseToComment(comment: Octokit.IssuesCreateCommentResponse | Octokit.IssuesUpdateCommentResponse, githubRepository: GitHubRepository): IComment {
<<<<<<<
export function convertPullRequestsGetCommentsResponseItemToComment(comment: Octokit.PullRequestsGetCommentsResponseItem | Octokit.PullRequestsEditCommentResponse, githubRepository: GitHubRepository): IComment {
let ret: IComment = {
=======
export function convertPullRequestsGetCommentsResponseItemToComment(comment: Octokit.PullsListCommentsResponseItem | Octokit.PullsUpdateCommentResponse, githubRepository: GitHubRepository): Comment {
let ret: Comment = {
>>>>>>>
export function convertPullRequestsGetCommentsResponseItemToComment(comment: Octokit.PullsListCommentsResponseItem | Octokit.PullsUpdateCommentResponse, githubRepository: GitHubRepository): IComment {
let ret: IComment = { |
<<<<<<<
import { IPullRequestManager, IPullRequestModel, IPullRequestsPagingOptions, PRType, ReviewEvent, ITelemetry, IPullRequestEditData, IRawPullRequest, IRawFileChange } from './interface';
=======
import { IPullRequestsPagingOptions, PRType, ReviewEvent, ITelemetry, IPullRequestEditData, PullRequest, IRawFileChange } from './interface';
>>>>>>>
import { IPullRequestsPagingOptions, PRType, ReviewEvent, ITelemetry, IPullRequestEditData, PullRequest, IRawFileChange } from './interface';
<<<<<<<
async getReviewComments(pullRequest: IPullRequestModel, reviewId: number): Promise<Comment[]> {
Logger.debug(`Fetch comments of review #${reviewId} in PR #${pullRequest.prNumber} - enter`, PullRequestManager.ID);
const { octokit, remote } = await (pullRequest as PullRequestModel).githubRepository.ensure();
const reviewData = await octokit.pullRequests.getReviewComments({
owner: remote.owner,
repo: remote.repositoryName,
number: pullRequest.prNumber,
review_id: reviewId
});
Logger.debug(`Fetch comments of review #${reviewId} in PR #${pullRequest.prNumber} - `, PullRequestManager.ID);
const rawComments = reviewData.data.map(comment => this.addCommentPermissions(convertPullRequestsGetCommentsResponseItemToComment(comment), remote));
return rawComments;
}
async getTimelineEvents(pullRequest: IPullRequestModel): Promise<TimelineEvent[]> {
=======
async getTimelineEvents(pullRequest: PullRequestModel): Promise<TimelineEvent[]> {
>>>>>>>
async getTimelineEvents(pullRequest: PullRequestModel): Promise<TimelineEvent[]> {
<<<<<<<
const { octokit, query, remote } = await (pullRequest as PullRequestModel).githubRepository.ensure();
=======
const { octokit, remote } = await pullRequest.githubRepository.ensure();
let ret = await octokit.issues.getEventsTimeline({
owner: remote.owner,
repo: remote.repositoryName,
number: pullRequest.prNumber,
per_page: 100
});
Logger.debug(`Fetch timeline events of PR #${pullRequest.prNumber} - done`, PullRequestManager.ID);
>>>>>>>
const { octokit, query, remote } = await pullRequest.githubRepository.ensure();
<<<<<<<
async createIssueComment(pullRequest: IPullRequestModel, text: string): Promise<Comment> {
const { octokit, remote } = await (pullRequest as PullRequestModel).githubRepository.ensure();
=======
async createIssueComment(pullRequest: PullRequestModel, text: string): Promise<Github.IssuesCreateCommentResponse> {
const { octokit, remote } = await pullRequest.githubRepository.ensure();
>>>>>>>
async createIssueComment(pullRequest: PullRequestModel, text: string): Promise<Comment> {
const { octokit, remote } = await pullRequest.githubRepository.ensure();
<<<<<<<
const item = convertRESTPullRequestToRawPullRequest(data);
=======
const item: PullRequest = {
number: data.number,
body: data.body,
title: data.title,
html_url: data.html_url,
user: data.user,
labels: [],
state: data.state,
merged: false,
assignee: data.assignee,
created_at: data.created_at,
updated_at: data.updated_at,
head: data.head,
base: data.base,
node_id: data.node_id
};
>>>>>>>
const item = convertRESTPullRequestToRawPullRequest(data);
<<<<<<<
async closePullRequest(pullRequest: IPullRequestModel): Promise<IRawPullRequest> {
=======
async closePullRequest(pullRequest: PullRequestModel): Promise<any> {
>>>>>>>
async closePullRequest(pullRequest: PullRequestModel): Promise<PullRequest> {
<<<<<<<
private async parseRESTTimelineEvents(pullRequest: IPullRequestModel, remote: Remote, events: any[]): Promise<TimelineEvent[]> {
=======
private async parseTimelineEvents(pullRequest: PullRequestModel, remote: Remote, events: any[]): Promise<TimelineEvent[]> {
>>>>>>>
private async parseRESTTimelineEvents(pullRequest: PullRequestModel, remote: Remote, events: any[]): Promise<TimelineEvent[]> { |
<<<<<<<
import Github = require('@octokit/rest');
=======
import * as Octokit from '@octokit/rest';
>>>>>>>
import Octokit = require('@octokit/rest'); |
<<<<<<<
import { Configuration } from '../authentication/configuration';
import { formatError } from '../common/utils';
import { GitHubManager } from '../authentication/githubserver';
=======
import { Configuration } from "../configuration";
import { formatError, uniqBy } from '../common/utils';
>>>>>>>
import { Configuration } from '../authentication/configuration';
import { GitHubManager } from '../authentication/githubserver';
import { formatError, uniqBy } from '../common/utils';
<<<<<<<
const potentialRemotes = this._repository.remotes.filter(remote => remote.host);
const gitHubRemotes = await Promise.all(potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri())))
.then(results => potentialRemotes.filter((_, index, __) => results[index]));
=======
let gitHubRemotes = this._repository.remotes.filter(remote => remote.host && remote.host.toLowerCase() === "github.com");
gitHubRemotes = uniqBy(gitHubRemotes, remote => `${remote.host}:${remote.owner}/${remote.repositoryName}`);
>>>>>>>
const potentialRemotes = this._repository.remotes.filter(remote => remote.host);
let gitHubRemotes = await Promise.all(potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri())))
.then(results => potentialRemotes.filter((_, index, __) => results[index]));
gitHubRemotes = uniqBy(gitHubRemotes, remote => `${remote.host}:${remote.owner}/${remote.repositoryName}`); |
<<<<<<<
import { AuthResponse, buildResponseStateOnly, setResponseIdToken } from "./AuthResponse";
// default authority
=======
import { AuthResponse, buildResponseStateOnly } from "./AuthResponse";
import TelemetryManager from "./telemetry/TelemetryManager";
import { TelemetryPlatform, TelemetryConfig } from './telemetry/TelemetryTypes';
// default authority
>>>>>>>
import { AuthResponse, buildResponseStateOnly, setResponseIdToken } from "./AuthResponse";
import TelemetryManager from "./telemetry/TelemetryManager";
import { TelemetryPlatform, TelemetryConfig } from './telemetry/TelemetryTypes';
// default authority
<<<<<<<
let hash = UrlProcessor.getHashFromUrl(urlFragment);
=======
const hash = Utils.getHashFromUrl(urlFragment);
>>>>>>>
let hash = UrlProcessor.getHashFromUrl(urlFragment);
<<<<<<<
setResponseIdToken(response, idToken);
=======
Utils.setResponseIdToken(response, idTokenObj);
>>>>>>>
setResponseIdToken(response, idTokenObj);
<<<<<<<
response = setResponseIdToken(response, new IdToken(this.cacheStorage.getItem(Constants.idTokenKey)));
=======
idTokenObj = new IdToken(this.cacheStorage.getItem(Constants.idTokenKey));
response = Utils.setResponseIdToken(response, idTokenObj);
>>>>>>>
idTokenObj = new IdToken(this.cacheStorage.getItem(Constants.idTokenKey));
response = setResponseIdToken(response, idTokenObj);
<<<<<<<
response = setResponseIdToken(response, new IdToken(hashParams[Constants.idToken]));
=======
// set the idToken
idTokenObj = new IdToken(hashParams[Constants.idToken]);
response = Utils.setResponseIdToken(response, idTokenObj);
>>>>>>>
// set the idToken
idTokenObj = new IdToken(hashParams[Constants.idToken]);
response = setResponseIdToken(response, idTokenObj);
<<<<<<<
authority = UrlProcessor.replaceTenantPath(authority, response.idToken.tenantId);
=======
authority = Utils.replaceTenantPath(authority, idTokenObj.tenantId);
>>>>>>>
authority = UrlProcessor.replaceTenantPath(authority, idTokenObj.tenantId); |
<<<<<<<
export type RefreshTokenRequest = {
scopes: Array<string>;
=======
export type RefreshTokenRequest = BaseAuthRequest & {
>>>>>>>
export type RefreshTokenRequest = BaseAuthRequest & {
<<<<<<<
redirectUri?: string;
authority?: string;
};
=======
};
>>>>>>>
redirectUri?: string;
}; |
<<<<<<<
import { Type } from "@thi.ng/malloc";
import * as assert from "assert";
import { AttribPool } from "../src/attrib-pool";
=======
import { Type } from "@thi.ng/api";
import { AttribPool } from "../src/attrib-pool";
// import * as assert from "assert";
>>>>>>>
import { Type } from "@thi.ng/api";
import * as assert from "assert";
import { AttribPool } from "../src/attrib-pool";
<<<<<<<
pos: {
type: Type.F32,
size: 2, // 8 bytes
byteOffset: 0,
data: [[1, 2], [3, 4]]
},
id: {
type: Type.U32,
size: 1, // 4 bytes
byteOffset: 8,
data: [1, 2],
index: 4
},
index: {
type: Type.U16,
size: 1, // 2 bytes
byteOffset: 12,
data: [10, 20]
},
col: {
type: Type.U8,
size: 4, // 4 bytes
byteOffset: 14,
data: [[128, 129, 130, 131], [255, 254, 253, 252]],
index: 6
}
=======
pos: {
type: Type.F32,
default: [0, 0],
size: 2,
byteOffset: 0
},
id: { type: Type.U32, default: 0, size: 1, byteOffset: 8 },
index: { type: Type.U16, default: 0, size: 1, byteOffset: 12 },
col: {
type: Type.I8,
default: [0, 0, 0, 0],
size: 4,
byteOffset: 14
}
>>>>>>>
pos: {
type: Type.F32,
size: 2, // 8 bytes
byteOffset: 0,
data: [[1, 2], [3, 4]]
},
id: {
type: Type.U32,
size: 1, // 4 bytes
byteOffset: 8,
data: [1, 2],
index: 4
},
index: {
type: Type.U16,
size: 1, // 2 bytes
byteOffset: 12,
data: [10, 20]
},
col: {
type: Type.U8,
size: 4, // 4 bytes
byteOffset: 14,
data: [[128, 129, 130, 131], [255, 254, 253, 252]],
index: 6
} |
<<<<<<<
import { MatOpM } from "./api";
import { invert33, invert44 } from "./invert";
import { mat44to33 } from "./m44-m33";
import { transpose33, transpose44 } from "./transpose";
=======
import { MatOpMU } from "./api";
import { invert33 } from "./invert";
import { mat44to33 } from "./m44-m33";
import { transpose33 } from "./transpose";
>>>>>>>
import { MatOpMU } from "./api";
import { invert33, invert44 } from "./invert";
import { mat44to33 } from "./m44-m33";
import { transpose33, transpose44 } from "./transpose"; |
<<<<<<<
path: '', data: { preload: true, }, loadChildren: './components/components/components.module#ComponentsModule',
}, {
// preload: true loads the module immediately
path: '', data: { preload: true, }, loadChildren: './components/echarts/components.module#ComponentsModule',
}, {
path: '**', redirectTo: '/',
=======
path: '',
data: { preload: true },
loadChildren: './components/components/components.module#ComponentsModule',
},
{
path: '**',
redirectTo: '/',
>>>>>>>
path: '',
data: { preload: true },
loadChildren: './components/components/components.module#ComponentsModule',
},
{
// preload: true loads the module immediately
path: '',
data: { preload: true, },
loadChildren: './components/echarts/components.module#ComponentsModule',
},
{
path: '**',
redirectTo: '/', |
<<<<<<<
import { BuildComponent } from './build/build.component';
=======
import { ProjectService } from './project.service';
>>>>>>>
import { BuildComponent } from './build/build.component';
import { ProjectService } from './project.service'; |
<<<<<<<
import { primaryColor } from '../../build/config/lessModifyVars';
=======
import { primaryColor, themeMode } from '../../build/config/themeConfig';
import { isProdMode } from '/@/utils/env';
>>>>>>>
import { primaryColor, themeMode } from '../../build/config/themeConfig'; |
<<<<<<<
export { CommonAuthorizationUrlRequest } from "./request/CommonAuthorizationUrlRequest";
export { CommonAuthorizationCodeRequest } from "./request/CommonAuthorizationCodeRequest";
export { CommonRefreshTokenRequest } from "./request/CommonRefreshTokenRequest";
export { CommonClientCredentialRequest } from "./request/CommonClientCredentialRequest";
export { CommonOnBehalfOfRequest } from "./request/CommonOnBehalfOfRequest";
export { CommonSilentFlowRequest } from "./request/CommonSilentFlowRequest";
export { CommonDeviceCodeRequest } from "./request/CommonDeviceCodeRequest";
export { CommonEndSessionRequest } from "./request/CommonEndSessionRequest";
=======
export { AuthorizationUrlRequest } from "./request/AuthorizationUrlRequest";
export { AuthorizationCodeRequest } from "./request/AuthorizationCodeRequest";
export { RefreshTokenRequest } from "./request/RefreshTokenRequest";
export { ClientCredentialRequest } from "./request/ClientCredentialRequest";
export { OnBehalfOfRequest } from "./request/OnBehalfOfRequest";
export { SilentFlowRequest } from "./request/SilentFlowRequest";
export { DeviceCodeRequest } from "./request/DeviceCodeRequest";
export { EndSessionRequest } from "./request/EndSessionRequest";
export { UsernamePasswordRequest } from "./request/UsernamePasswordRequest";
>>>>>>>
export { CommonAuthorizationUrlRequest } from "./request/CommonAuthorizationUrlRequest";
export { CommonAuthorizationCodeRequest } from "./request/CommonAuthorizationCodeRequest";
export { CommonRefreshTokenRequest } from "./request/CommonRefreshTokenRequest";
export { CommonClientCredentialRequest } from "./request/CommonClientCredentialRequest";
export { CommonOnBehalfOfRequest } from "./request/CommonOnBehalfOfRequest";
export { CommonSilentFlowRequest } from "./request/CommonSilentFlowRequest";
export { CommonDeviceCodeRequest } from "./request/CommonDeviceCodeRequest";
export { CommonEndSessionRequest } from "./request/CommonEndSessionRequest";
export { UsernamePasswordRequest } from "./request/UsernamePasswordRequest"; |
<<<<<<<
url = URLToolkit.buildAbsoluteURL(self.location.href, url, { alwaysNormalize: true });
=======
this.stopLoad();
const media = this.media;
if (media && this.url) {
this.detachMedia();
this.attachMedia(media);
}
url = URLToolkit.buildAbsoluteURL(window.location.href, url, { alwaysNormalize: true });
>>>>>>>
this.stopLoad();
const media = this.media;
if (media && this.url) {
this.detachMedia();
this.attachMedia(media);
}
url = URLToolkit.buildAbsoluteURL(self.location.href, url, { alwaysNormalize: true }); |
<<<<<<<
this.media = media;
this.emit(Events.MEDIA_ATTACHING, { media: media });
=======
this._media = media;
this.trigger(HlsEvents.MEDIA_ATTACHING, { media: media });
>>>>>>>
this._media = media;
this.emit(Events.MEDIA_ATTACHING, { media: media });
<<<<<<<
this.emit(Events.MEDIA_DETACHING);
this.media = null;
=======
this.trigger(HlsEvents.MEDIA_DETACHING);
this._media = null;
>>>>>>>
this.emit(Events.MEDIA_DETACHING);
this._media = null; |
<<<<<<<
private _trySkipBufferHole (partial: Fragment | null): number {
const { hls, media } = this;
=======
private _trySkipBufferHole (partial: Fragment | null) {
const { config, hls, media } = this;
>>>>>>>
private _trySkipBufferHole (partial: Fragment | null): number {
const { config, hls, media } = this; |
<<<<<<<
private unparsedVttFrags: Array<FragLoadedData | FragDecryptedData> = [];
private cueRanges: Record<string, Array<[number, number]>> = {};
=======
private unparsedVttFrags: Array<{ frag: Fragment, payload: ArrayBuffer }> = [];
>>>>>>>
private unparsedVttFrags: Array<FragLoadedData | FragDecryptedData> = [];
<<<<<<<
=======
private readonly cea608Parser1!: Cea608Parser;
private readonly cea608Parser2!: Cea608Parser;
private lastSn: number = -1;
private prevCC: number = -1;
private vttCCs: VTTCCs = newVTTCCs();
constructor (hls) {
super(hls,
Event.MEDIA_ATTACHING,
Event.MEDIA_DETACHING,
Event.FRAG_PARSING_USERDATA,
Event.FRAG_DECRYPTED,
Event.MANIFEST_LOADING,
Event.MANIFEST_LOADED,
Event.FRAG_LOADED,
Event.INIT_PTS_FOUND);
>>>>>>>
<<<<<<<
let ranges = this.cueRanges[trackName];
if (!ranges) {
ranges = this.cueRanges[trackName] = [];
}
=======
>>>>>>>
<<<<<<<
for (let i = ranges.length; i--;) {
const cueRange = ranges[i];
const overlap = intersection(cueRange[0], cueRange[1], startTime, endTime);
=======
for (let i = cueRanges.length; i--;) {
let cueRange = cueRanges[i];
let overlap = intersection(cueRange[0], cueRange[1], startTime, endTime);
>>>>>>>
for (let i = cueRanges.length; i--;) {
const cueRange = cueRanges[i];
const overlap = intersection(cueRange[0], cueRange[1], startTime, endTime);
<<<<<<<
this.cueRanges = {};
=======
if (this.cea608Parser1 && this.cea608Parser2) {
this.cea608Parser1.reset();
this.cea608Parser2.reset();
}
>>>>>>>
if (this.cea608Parser1 && this.cea608Parser2) {
this.cea608Parser1.reset();
this.cea608Parser2.reset();
}
<<<<<<<
if (sn !== lastSn + 1) {
if (cea608Parser) {
cea608Parser.reset();
=======
if (frag.sn !== lastSn + 1) {
if (cea608Parser1 && cea608Parser2) {
cea608Parser1.reset();
cea608Parser2.reset();
>>>>>>>
if (sn !== lastSn + 1) {
if (cea608Parser1 && cea608Parser2) {
cea608Parser1.reset();
cea608Parser2.reset();
<<<<<<<
onSubtitleTracksCleared () {
this.tracks = [];
this.captionsTracks = {};
}
onFragParsingUserdata (event: Events.FRAG_PARSING_USERDATA, data: FragParsingUserdataData) {
if (!this.enabled || !this.cea608Parser) {
=======
onFragParsingUserdata (data: { samples: Array<any> }) {
const { cea608Parser1, cea608Parser2 } = this;
if (!this.enabled || !(cea608Parser1 && cea608Parser2)) {
>>>>>>>
onSubtitleTracksCleared () {
this.tracks = [];
this.captionsTracks = {};
}
onFragParsingUserdata (event: Events.FRAG_PARSING_USERDATA, data: FragParsingUserdataData) {
const { cea608Parser1, cea608Parser2 } = this;
if (!this.enabled || !(cea608Parser1 && cea608Parser2)) {
<<<<<<<
const cea608Parser = this.cea608Parser as Cea608Parser;
=======
>>>>>>> |
<<<<<<<
import { BufferHelper } from '../utils/buffer-helper';
=======
import EventHandler from '../event-handler';
import { BufferHelper, Bufferable } from '../utils/buffer-helper';
>>>>>>>
import { BufferHelper, Bufferable } from '../utils/buffer-helper';
<<<<<<<
import Hls from '../hls';
import { FragLoadingData, MediaAttachedData, FragLoadedData, FragBufferedData, ErrorData } from '../types/events';
=======
import { LevelLoadedData } from '../types/events';
import Hls from '../hls';
>>>>>>>
import Hls from '../hls';
import { FragLoadingData, FragLoadedData, FragBufferedData, ErrorData, LevelLoadedData } from '../types/events';
<<<<<<<
class AbrController {
protected hls: Hls;
private _media: HTMLMediaElement | null = null;
=======
class AbrController extends EventHandler {
protected hls: Hls;
>>>>>>>
class AbrController {
protected hls: Hls;
<<<<<<<
constructor (hls: Hls) {
=======
constructor (hls) {
super(hls, Events.FRAG_LOADING,
Events.FRAG_LOADED,
Events.FRAG_BUFFERED,
Events.LEVEL_LOADED,
Events.ERROR);
>>>>>>>
constructor (hls: Hls) {
<<<<<<<
this._registerListeners();
}
private _registerListeners () {
const { hls } = this;
hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
hls.on(Events.MEDIA_DETACHED, this.onMediaDetached, this);
hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
hls.on(Events.ERROR, this.onError, this);
}
private _unregisterListeners () {
const { hls } = this;
hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
hls.off(Events.MEDIA_DETACHED, this.onMediaDetached, this);
hls.off(Events.FRAG_LOADING, this.onFragLoading, this);
hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
hls.off(Events.ERROR, this.onError, this);
=======
const config = hls.config;
this._bwEstimator = new EwmaBandWidthEstimator(config.abrEwmaSlowVoD, config.abrEwmaFastVoD, config.abrEwmaDefaultEstimate);
>>>>>>>
const config = hls.config;
this._bwEstimator = new EwmaBandWidthEstimator(config.abrEwmaSlowVoD, config.abrEwmaFastVoD, config.abrEwmaDefaultEstimate);
this._registerListeners();
}
private _registerListeners () {
const { hls } = this;
hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
hls.on(Events.ERROR, this.onError, this);
}
private _unregisterListeners () {
const { hls } = this;
hls.off(Events.FRAG_LOADING, this.onFragLoading, this);
hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
hls.off(Events.ERROR, this.onError, this);
<<<<<<<
onMediaAttached (data: MediaAttachedData) {
this._media = data.media;
}
onMediaDetached () {
this._media = null;
}
onFragLoading (data: FragLoadingData) {
=======
protected onFragLoading (data: { frag: Fragment }) {
>>>>>>>
private onFragLoading (data: FragLoadingData) {
<<<<<<<
// lazy init of BwEstimator, rationale is that we use different params for Live/VoD
// so we need to wait for stream manifest / playlist type to instantiate it.
if (!this._bwEstimator) {
const hls = this.hls;
const config = hls.config;
const level = hls.levels[frag.level];
let isLive = false;
if (level.details) {
isLive = level.details.live;
}
let ewmaFast;
let ewmaSlow;
if (isLive) {
ewmaFast = config.abrEwmaFastLive;
ewmaSlow = config.abrEwmaSlowLive;
} else {
ewmaFast = config.abrEwmaFastVoD;
ewmaSlow = config.abrEwmaSlowVoD;
}
this._bwEstimator = new EwmaBandWidthEstimator(hls, ewmaSlow, ewmaFast, config.abrEwmaDefaultEstimate);
}
=======
protected onLevelLoaded (data: LevelLoadedData) {
const config = this.hls.config;
if (data.details.live) {
this._bwEstimator.update(config.abrEwmaSlowLive, config.abrEwmaFastLive);
} else {
this._bwEstimator.update(config.abrEwmaSlowVoD, config.abrEwmaFastVoD);
>>>>>>>
private onLevelLoaded (data: LevelLoadedData) {
const config = this.hls.config;
if (data.details.live) {
this._bwEstimator.update(config.abrEwmaSlowLive, config.abrEwmaFastLive);
} else {
this._bwEstimator.update(config.abrEwmaSlowVoD, config.abrEwmaFastVoD);
<<<<<<<
_abandonRulesCheck () {
const { fragCurrent: frag, hls, _media: media } = this;
const { autoLevelEnabled, config } = hls;
=======
private _abandonRulesCheck () {
const { fragCurrent: frag, hls } = this;
const { autoLevelEnabled, config, media } = hls;
>>>>>>>
private _abandonRulesCheck () {
const { fragCurrent: frag, hls } = this;
const { autoLevelEnabled, config, media } = hls;
<<<<<<<
onFragLoaded (data: FragLoadedData) {
=======
protected onFragLoaded (data: { frag: Fragment }) {
>>>>>>>
private onFragLoaded (data: FragLoadedData) {
<<<<<<<
onFragBuffered (data: FragBufferedData) {
=======
protected onFragBuffered (data: { frag: Fragment }) {
>>>>>>>
private onFragBuffered (data: FragBufferedData) {
<<<<<<<
onError (data: ErrorData) {
=======
protected onError (data) {
>>>>>>>
private onError (data: ErrorData) {
<<<<<<<
const { fragCurrent, hls, lastLoadedFragLevel: currentLevel, _media: video } = this;
const { maxAutoLevel, levels, config, minAutoLevel } = hls;
=======
const { fragCurrent, hls, lastLoadedFragLevel: currentLevel } = this;
const { maxAutoLevel, levels, config, minAutoLevel, media } = hls;
>>>>>>>
const { fragCurrent, hls, lastLoadedFragLevel: currentLevel } = this;
const { maxAutoLevel, levels, config, minAutoLevel, media } = hls; |
<<<<<<<
import { logger } from '../utils/logger';
import type { TimelineController } from '../controller/timeline-controller';
import type { CaptionScreen } from './cea-608-parser';
=======
import { CaptionScreen } from './cea-608-parser';
import type TimelineController from '../controller/timeline-controller';
>>>>>>>
import type { TimelineController } from '../controller/timeline-controller';
import type { CaptionScreen } from './cea-608-parser';
<<<<<<<
timelineController: TimelineController;
trackName: string;
startTime: number | null;
endTime: number | null;
screen: CaptionScreen | null;
=======
private timelineController: TimelineController;
private cueRanges: Array<[number, number]> = [];
private trackName: string;
private startTime: number | null = null;
private endTime: number | null = null;
private screen: CaptionScreen | null = null;
>>>>>>>
private timelineController: TimelineController;
private cueRanges: Array<[number, number]> = [];
private trackName: string;
private startTime: number | null = null;
private endTime: number | null = null;
private screen: CaptionScreen | null = null;
<<<<<<<
if (!this.screen) {
logger.warn('Called dispatchCue from output filter before newCue.');
return;
}
this.timelineController.addCues(this.trackName, this.startTime, this.endTime as number, this.screen);
=======
this.timelineController.addCues(this.trackName, this.startTime, this.endTime as number, this.screen as CaptionScreen, this.cueRanges);
>>>>>>>
this.timelineController.addCues(this.trackName, this.startTime, this.endTime as number, this.screen as CaptionScreen, this.cueRanges); |
<<<<<<<
export type BufferInfo = {
len: number,
start: number,
end: number,
nextStart?: number,
};
=======
const noopBuffered: TimeRanges = {
length: 0,
start: () => 0,
end: () => 0
};
>>>>>>>
export type BufferInfo = {
len: number,
start: number,
end: number,
nextStart?: number,
};
const noopBuffered: TimeRanges = {
length: 0,
start: () => 0,
end: () => 0
};
<<<<<<<
const buffered = media.buffered;
=======
let buffered = BufferHelper.getBuffered(media);
>>>>>>>
const buffered = BufferHelper.getBuffered(media);
<<<<<<<
const vbuffered = media.buffered;
const buffered: BufferTimeRange[] = [];
=======
let vbuffered = BufferHelper.getBuffered(media);
let buffered: BufferTimeRange[] = [];
>>>>>>>
const vbuffered = BufferHelper.getBuffered(media);
const buffered: BufferTimeRange[] = []; |
<<<<<<<
onSubtitleFragProcessed (event: Events.SUBTITLE_FRAG_PROCESSED, data: SubtitleFragProcessed) {
const { frag } = data;
=======
onSubtitleFragProcessed (data: SubtitleFragProcessed) {
const { frag, success } = data;
>>>>>>>
onSubtitleFragProcessed (event: Events.SUBTITLE_FRAG_PROCESSED, data: SubtitleFragProcessed) {
const { frag, success } = data; |
<<<<<<<
async handleServerTokenResponse(
serverTokenResponse: ServerAuthorizationTokenResponse,
authority: Authority,
cachedNonce?: string,
cachedState?: string,
requestScopes?: string[],
oboAssertion?: string,
handlingRefreshTokenResponse?: boolean): Promise<AuthenticationResult> {
=======
async handleServerTokenResponse(serverTokenResponse: ServerAuthorizationTokenResponse, authority: Authority, resourceRequestMethod?: string,
resourceRequestUri?: string, cachedNonce?: string, cachedState?: string, requestScopes?: string[], oboAssertion?: string): Promise<AuthenticationResult> {
>>>>>>>
async handleServerTokenResponse(
serverTokenResponse: ServerAuthorizationTokenResponse,
authority: Authority,
resourceRequestMethod?: string,
resourceRequestUri?: string,
cachedNonce?: string,
cachedState?: string,
requestScopes?: string[],
oboAssertion?: string,
handlingRefreshTokenResponse?: boolean): Promise<AuthenticationResult> {
<<<<<<<
let cacheContext;
try {
if (this.persistencePlugin && this.serializableCache) {
this.logger.verbose("Persistence enabled, calling beforeCacheAccess");
cacheContext = new TokenCacheContext(this.serializableCache, true);
await this.persistencePlugin.beforeCacheAccess(cacheContext);
}
/*
* When saving a refreshed tokens to the cache, it is expected that the account that was used is present in the cache.
* If not present, we should return null, as it's the case that another application called removeAccount in between
* the calls to getAllAccounts and acquireTokenSilent. We should not overwrite that removal.
*/
if (handlingRefreshTokenResponse && cacheRecord.account) {
const key = cacheRecord.account.generateAccountKey();
const account = this.cacheStorage.getAccount(key);
if (!account) {
this.logger.warning("Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache");
return null;
}
}
this.cacheStorage.saveCacheRecord(cacheRecord);
} finally {
if (this.persistencePlugin && this.serializableCache && cacheContext) {
this.logger.verbose("Persistence enabled, calling afterCacheAccess");
await this.persistencePlugin.afterCacheAccess(cacheContext);
}
}
return ResponseHandler.generateAuthenticationResult(cacheRecord, idTokenObj, false, requestStateObj);
=======
this.cacheStorage.saveCacheRecord(cacheRecord);
return await ResponseHandler.generateAuthenticationResult(this.cryptoObj, cacheRecord, idTokenObj, false, requestStateObj, resourceRequestMethod, resourceRequestUri);
>>>>>>>
let cacheContext;
try {
if (this.persistencePlugin && this.serializableCache) {
this.logger.verbose("Persistence enabled, calling beforeCacheAccess");
cacheContext = new TokenCacheContext(this.serializableCache, true);
await this.persistencePlugin.beforeCacheAccess(cacheContext);
}
/*
* When saving a refreshed tokens to the cache, it is expected that the account that was used is present in the cache.
* If not present, we should return null, as it's the case that another application called removeAccount in between
* the calls to getAllAccounts and acquireTokenSilent. We should not overwrite that removal.
*/
if (handlingRefreshTokenResponse && cacheRecord.account) {
const key = cacheRecord.account.generateAccountKey();
const account = this.cacheStorage.getAccount(key);
if (!account) {
this.logger.warning("Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache");
return null;
}
}
this.cacheStorage.saveCacheRecord(cacheRecord);
} finally {
if (this.persistencePlugin && this.serializableCache && cacheContext) {
this.logger.verbose("Persistence enabled, calling afterCacheAccess");
await this.persistencePlugin.afterCacheAccess(cacheContext);
}
}
return ResponseHandler.generateAuthenticationResult(this.cryptoObj, cacheRecord, idTokenObj, false, requestStateObj, resourceRequestMethod, resourceRequestUri); |
<<<<<<<
code = {
templateInterpolationExercise: displayAngularComponentWithHtml(baseCode, `<h1>Hello, {{user.firstName}}</h1>`),
parentComponentSkeleton: {
code: `import { Component } from '@angular/core';
@Component({
selector: 'parent',
template: '<child>...</child>'
})
export class ParentComponent {}
`,
path: 'parent.component.ts',
type: 'typescript',
},
childComponentSkeleton: {
code: `import { Component } from '@angular/core';
@Component({
selector: 'child',
template: '<p>I'm a child!</p>'
})
export class ChildComponent {}
`,
path: 'child.component.ts',
type: 'typescript',
},
appModule: {
code: `import { NgModule } from '@angular/core';
import { ChildComponent } from './child.component';
import { ParentComponent } from './parent.component';
@NgModule({
declarations: [ ChildComponent, ParentComponent ]
})
export class AppModule {}`,
path: 'app.module.ts',
type: 'typescript',
},
parentComponent: {
code: `import { Component } from '@angular/core';
import { Result } from './result.model';
@Component({
selector: 'parent',
template: '<child [data]=”results()”>
</child>'
})
export class Parent {
results(): Result[] {...}
}`,
path: 'parent.component.ts',
type: 'typescript',
},
childComponent: {
code: `import { Component, Input } from '@angular/core';
import { Result }from './result.model';
@Component({
selector: 'child',
template: '<p *ngFor=”let result of data”>{{result}}</p>'
})
export class Child {
@Input() data: Result[];
}`,
path: 'child.component.ts',
type: 'typescript',
},
};
title = 'Experiments';
description = '';
prereqs = '';
=======
>>>>>>>
code = {
templateInterpolationExercise: displayAngularComponentWithHtml(baseCode, `<h1>Hello, {{user.firstName}}</h1>`),
parentComponentSkeleton: {
code: `import { Component } from '@angular/core';
@Component({
selector: 'parent',
template: '<child>...</child>'
})
export class ParentComponent {}
`,
path: 'parent.component.ts',
type: 'typescript',
},
childComponentSkeleton: {
code: `import { Component } from '@angular/core';
@Component({
selector: 'child',
template: '<p>I'm a child!</p>'
})
export class ChildComponent {}
`,
path: 'child.component.ts',
type: 'typescript',
},
appModule: {
code: `import { NgModule } from '@angular/core';
import { ChildComponent } from './child.component';
import { ParentComponent } from './parent.component';
@NgModule({
declarations: [ ChildComponent, ParentComponent ]
})
export class AppModule {}`,
path: 'app.module.ts',
type: 'typescript',
},
parentComponent: {
code: `import { Component } from '@angular/core';
import { Result } from './result.model';
@Component({
selector: 'parent',
template: '<child [data]=”results()”>
</child>'
})
export class Parent {
results(): Result[] {...}
}`,
path: 'parent.component.ts',
type: 'typescript',
},
childComponent: {
code: `import { Component, Input } from '@angular/core';
import { Result }from './result.model';
@Component({
selector: 'child',
template: '<p *ngFor=”let result of data”>{{result}}</p>'
})
export class Child {
@Input() data: Result[];
}`,
path: 'child.component.ts',
type: 'typescript',
},
};
title = 'Experiments';
description = '';
prereqs = ''; |
<<<<<<<
if (active) {
setTimeout(() => introJs().start(), 1000);
=======
// check if both tours ran TODO: unhardcode this check
if (active && localStorage.numTours <= 2) {
setTimeout(() => introJs().start(), 2000);
localStorage.numTours = +localStorage.numTours + 1;
>>>>>>>
// check if both tours ran TODO: unhardcode this check
if (active && localStorage.numTours <= 2) {
setTimeout(() => introJs().start(), 1000);
localStorage.numTours = +localStorage.numTours + 1; |
<<<<<<<
import {Component, ElementRef, HostListener, Input} from '@angular/core';
=======
import {Component, ElementRef, HostListener, OnInit} from '@angular/core';
>>>>>>>
import {Component, ElementRef, HostListener, OnInit, Input} from '@angular/core';
<<<<<<<
export class ResizeComponent {
@Input() isVertical: boolean;
private MIN_WIDTH = 400;
private MIN_HEIGHT = 200;
private isMouseDown: boolean;
private initOffset;
private initSize;
private minSize;
private size;
=======
export class ResizeComponent implements OnInit {
private initOffsetX: number;
private initWidth: number;
private minWidth = 400;
isMouseDown: boolean;
width: number;
>>>>>>>
export class ResizeComponent implements OnInit {
@Input() isVertical: boolean;
private MIN_WIDTH = 400;
private MIN_HEIGHT = 200;
private isMouseDown: boolean;
private initOffset;
private initSize;
private minSize;
private size;
<<<<<<<
this.initSize = this.size;
if (!this.isVertical) {
this.initOffset = e.clientX;
} else {
this.initOffset = e.clientY;
}
=======
this.initOffsetX = e.clientX;
this.initWidth = this.width;
>>>>>>>
this.initSize = this.size;
if (!this.isVertical) {
this.initOffset = e.clientX;
} else {
this.initOffset = e.clientY;
} |
<<<<<<<
import { SimpleTestsProgressComponent } from '@codelab/utils/src/lib/test-results/simple-tests-progress/simple-tests-progress.component';
=======
import { DirectivesModule } from '../directives/directives.module';
import { SimpleTestsProgressComponent } from './tests-progress/simple-tests-progress.component';
import { SimpleTestsComponent } from './tests/simple-tests.component';
import { SimpleTestDescriptionComponent } from './test-description/simple-test-description.component';
>>>>>>>
import { DirectivesModule } from '../directives/directives.module';
import { SimpleTestsProgressComponent } from '@codelab/utils/src/lib/test-results/simple-tests-progress/simple-tests-progress.component';
<<<<<<<
MatSelectModule,
TestResultsModule,
TestResultsModule
=======
MatSelectModule,
DirectivesModule
>>>>>>>
MatSelectModule,
TestResultsModule,
DirectivesModule |
<<<<<<<
import { AngularFireModule } from 'angularfire2';
import { AngularFireDatabaseProvider } from 'angularfire2/database';
=======
import { NgModule } from '@angular/core';
>>>>>>>
import { AngularFireModule } from 'angularfire2';
import { AngularFireDatabaseProvider } from 'angularfire2/database';
import { NgModule } from '@angular/core';
<<<<<<<
// Note! We are using AngularFire2 v4. There are a lot of breaking changes.
// See: https://github.com/angular/angularfire2/issues/854
export const af = AngularFireModule.initializeApp(firebaseConfig);
=======
export const angularFire = AngularFireModule.initializeApp(firebaseConfig);
>>>>>>>
// Note! We are using AngularFire2 v4. There are a lot of breaking changes.
// See: https://github.com/angular/angularfire2/issues/854
export const angularFire = AngularFireModule.initializeApp(firebaseConfig); |
<<<<<<<
declarations: [FeedbackPageComponent, DateRangeComponent],
providers: [GithubService],
=======
declarations: [FeedbackPageComponent],
>>>>>>>
declarations: [FeedbackPageComponent, DateRangeComponent], |
<<<<<<<
const accessTokenValue = new AccessTokenValue(parameters[Constants.accessToken], idTokenObj.rawIdToken, expiresIn, clientInfo);
=======
const accessTokenValue = new AccessTokenValue(parameters[Constants.accessToken], response.idToken.rawIdToken, expiration.toString(), clientInfo);
>>>>>>>
const accessTokenValue = new AccessTokenValue(parameters[Constants.accessToken], idTokenObj.rawIdToken, expiration.toString(), clientInfo);
<<<<<<<
const accessTokenValue = new AccessTokenValue(parameters[Constants.idToken], parameters[Constants.idToken], idTokenObj.expiration, clientInfo);
=======
const accessTokenValue = new AccessTokenValue(parameters[Constants.idToken], parameters[Constants.idToken], expiration.toString(), clientInfo);
>>>>>>>
const accessTokenValue = new AccessTokenValue(parameters[Constants.idToken], parameters[Constants.idToken], idTokenObj.expiration, clientInfo);
<<<<<<<
let exp = Number(idTokenObj.expiration);
if (exp) {
accessTokenResponse.expiresOn = new Date(exp * 1000);
} else {
this.logger.error("Could not parse expiresIn parameter");
}
=======
}
if (expiration) {
accessTokenResponse.expiresOn = new Date(expiration * 1000);
} else {
this.logger.error("Could not parse expiresIn parameter");
>>>>>>>
let exp = Number(idTokenObj.expiration);
if (expiration) {
accessTokenResponse.expiresOn = new Date(expiration * 1000);
} else {
this.logger.error("Could not parse expiresIn parameter");
} |
<<<<<<<
const USER_ENDPOINT: IDBEndpoint = 'v3_users' as any
=======
// TODO - fix links to main repo and handle with prefix_endpoint type checking
const USER_ENDPOINT = 'v3_users'
>>>>>>>
const USER_ENDPOINT: IDBEndpoint = 'v3_users' as any
// TODO - fix links to main repo and handle with prefix_endpoint type checking |
<<<<<<<
const testResource = "https://login.contoso.com/endpt";
expect(() => spaResponseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, testResource, RANDOM_TEST_GUID)).to.throw(ClientAuthErrorMessage.invalidIdToken.desc);
expect(() => spaResponseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, testResource, RANDOM_TEST_GUID)).to.throw(ClientAuthError);
=======
const testResource = "";
expect(() => responseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, testResource, RANDOM_TEST_GUID)).to.throw(ClientAuthErrorMessage.invalidIdToken.desc);
expect(() => responseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, testResource, RANDOM_TEST_GUID)).to.throw(ClientAuthError);
>>>>>>>
const testResource = "";
expect(() => responseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, testResource, RANDOM_TEST_GUID)).to.throw(ClientAuthErrorMessage.invalidIdToken.desc);
expect(() => responseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, testResource, RANDOM_TEST_GUID)).to.throw(ClientAuthError);
<<<<<<<
spaResponseHandler = new SPAResponseHandler(TEST_CONFIG.MSAL_CLIENT_ID, cacheStorage, cacheHelpers, cryptoInterface, logger);
const testServerParams: ServerAuthorizationTokenResponse = {
token_type: TEST_CONFIG.TOKEN_TYPE_BEARER,
scope: "openid profile email",
expires_in: TEST_TOKEN_LIFETIMES.DEFAULT_EXPIRES_IN,
ext_expires_in: TEST_TOKEN_LIFETIMES.DEFAULT_EXPIRES_IN,
access_token: TEST_TOKENS.ACCESS_TOKEN,
refresh_token: TEST_TOKENS.REFRESH_TOKEN,
id_token: TEST_TOKENS.IDTOKEN_V2
};
const testResource = "https://login.contoso.com/endpt";
=======
>>>>>>>
<<<<<<<
expect(() => spaResponseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, testResource, RANDOM_TEST_GUID)).to.throw(ClientAuthErrorMessage.accountMismatchError.desc);
=======
expect(() => responseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, "", RANDOM_TEST_GUID)).to.throw(ClientAuthErrorMessage.accountMismatchError.desc);
>>>>>>>
expect(() => responseHandler.createTokenResponse(testServerParams, `${Constants.DEFAULT_AUTHORITY}/`, "", RANDOM_TEST_GUID)).to.throw(ClientAuthErrorMessage.accountMismatchError.desc); |
<<<<<<<
login: `${CA_BASE_URL}/tods/api/lgn`,
logout: `${CA_BASE_URL}/tods/api/lgout`,
list: `${CA_BASE_URL}/tods/api/vhcllst`,
lock: `${CA_BASE_URL}/tods/api/drlck`,
unlock: `${CA_BASE_URL}/tods/api/drulck`,
start: `${CA_BASE_URL}/tods/api/rfon`,
stop: `${CA_BASE_URL}/tods/api/rfoff`,
myAccount: `${CA_BASE_URL}/tods/api/acctinfo`,
status: `${CA_BASE_URL}/tods/api/lstvhclsts`,
remoteStatus: `${CA_BASE_URL}/tods/api/rltmvhclsts`,
verifyPin: `${CA_BASE_URL}/tods/api/vrfypin`,
verifyToken: `${CA_BASE_URL}/tods/api/vrfytnc`,
vehicleInfo: `${CA_BASE_URL}/tods/api/sltvhcl`,
nextService: `${CA_BASE_URL}/tods/api/nxtsvc`,
preferedDealer : `${CA_BASE_URL}/tods/api/gtprfrdlr`
};
export const EU_ENDPOINTS = {
session: `${EU_BASE_URL}/api/v1/user/oauth2/authorize?response_type=code&state=test&client_id=6d477c38-3ca4-4cf3-9557-2a1929a94654&redirect_uri=${EU_BASE_URL}/api/v1/user/oauth2/redirect`,
login: `${EU_BASE_URL}/api/v1/user/signin`,
redirectUri: `${EU_BASE_URL}/api/v1/user/oauth2/redirect`,
token: `${EU_BASE_URL}/api/v1/user/oauth2/token`
=======
login: 'https://mybluelink.ca/tods/api/lgn',
logout: 'https://mybluelink.ca/tods/api/lgout',
// Account
myAccount: 'https://mybluelink.ca/tods/api/acctinfo',
nextService: 'https://mybluelink.ca/tods/api/nxtsvc',
preferedDealer : 'https://mybluelink.ca/tods/api/gtprfrdlr',
// Vehicle
vehicleList: 'https://mybluelink.ca/tods/api/vhcllst',
vehicleInfo: "https://mybluelink.ca/tods/api/sltvhcl",
status: 'https://mybluelink.ca/tods/api/lstvhclsts',
remoteStatus: 'https://mybluelink.ca/tods/api/rltmvhclsts',
// Car commands with preauth (PIN)
lock: 'https://mybluelink.ca/tods/api/drlck',
unlock: 'https://mybluelink.ca/tods/api/drulck',
start: 'https://mybluelink.ca/tods/api/evc/rfon',
stop: 'https://mybluelink.ca/tods/api/evc/rfoff',
locate: 'https://mybluelink.ca/tods/api/fndmcr',
hornlight: "https://mybluelink.ca/tods/api/hornlight",
// System
verifyAccountToken: "https://mybluelink.ca/tods/api/vrfyacctkn",
verifyPin: 'https://mybluelink.ca/tods/api/vrfypin',
verifyToken: 'https://mybluelink.ca/tods/api/vrfytnc',
>>>>>>>
login: 'https://mybluelink.ca/tods/api/lgn',
logout: 'https://mybluelink.ca/tods/api/lgout',
// Account
myAccount: 'https://mybluelink.ca/tods/api/acctinfo',
nextService: 'https://mybluelink.ca/tods/api/nxtsvc',
preferedDealer : 'https://mybluelink.ca/tods/api/gtprfrdlr',
// Vehicle
vehicleList: 'https://mybluelink.ca/tods/api/vhcllst',
vehicleInfo: "https://mybluelink.ca/tods/api/sltvhcl",
status: 'https://mybluelink.ca/tods/api/lstvhclsts',
remoteStatus: 'https://mybluelink.ca/tods/api/rltmvhclsts',
// Car commands with preauth (PIN)
lock: 'https://mybluelink.ca/tods/api/drlck',
unlock: 'https://mybluelink.ca/tods/api/drulck',
start: 'https://mybluelink.ca/tods/api/evc/rfon',
stop: 'https://mybluelink.ca/tods/api/evc/rfoff',
locate: 'https://mybluelink.ca/tods/api/fndmcr',
hornlight: "https://mybluelink.ca/tods/api/hornlight",
// System
verifyAccountToken: "https://mybluelink.ca/tods/api/vrfyacctkn",
verifyPin: 'https://mybluelink.ca/tods/api/vrfypin',
verifyToken: 'https://mybluelink.ca/tods/api/vrfytnc',
};
export const EU_ENDPOINTS = {
session: `${EU_BASE_URL}/api/v1/user/oauth2/authorize?response_type=code&state=test&client_id=6d477c38-3ca4-4cf3-9557-2a1929a94654&redirect_uri=${EU_BASE_URL}/api/v1/user/oauth2/redirect`,
login: `${EU_BASE_URL}/api/v1/user/signin`,
redirectUri: `${EU_BASE_URL}/api/v1/user/oauth2/redirect`,
token: `${EU_BASE_URL}/api/v1/user/oauth2/token` |
<<<<<<<
expect(html).not.toContain('<div id="marp-vscode" data-zoom="1">')
expect(html).not.toContain('<style id="marp-vscode-style">')
expect(html).not.toContain('svg')
expect(html).not.toContain('img')
=======
for (const markdown of [baseMd, confusingMd]) {
const html = extendMarkdownIt(new markdownIt()).render(markdown)
expect(html).not.toContain('<div id="marp-vscode">')
expect(html).not.toContain('<style id="marp-vscode-style">')
expect(html).not.toContain('svg')
expect(html).not.toContain('img')
}
>>>>>>>
for (const markdown of [baseMd, confusingMd]) {
const html = extendMarkdownIt(new markdownIt()).render(markdown)
expect(html).not.toContain('<div id="marp-vscode" data-zoom="1">')
expect(html).not.toContain('<style id="marp-vscode-style">')
expect(html).not.toContain('svg')
expect(html).not.toContain('img')
} |
<<<<<<<
import { isPrimitive } from '../utils/objects';
import * as stateManager from '../state-manager'
=======
import * as gate from './gate'
import { mergeValidationRules, showValidationErrorsFromServer } from '../validation/validation';
import { DotvvmPostbackError } from '../shared-classes';
>>>>>>>
import * as gate from './gate'
import { mergeValidationRules, showValidationErrorsFromServer } from '../validation/validation';
import { DotvvmPostbackError } from '../shared-classes';
import { isPrimitive } from '../utils/objects';
import * as stateManager from '../state-manager'
<<<<<<<
return await processPostbackResponse(options, initialState, result);
=======
return await processPostbackResponse(options, context, postedViewModel, response.result, response.response!);
>>>>>>>
return await processPostbackResponse(options, context, postedViewModel, initialState, response.result, response.response!);
<<<<<<<
async function processPostbackResponse(options: PostbackOptions, initialState: any, result: PostbackResponse): Promise<DotvvmAfterPostBackEventArgs> {
events.postbackCommitInvoked.trigger({});
=======
async function processPostbackResponse(options: PostbackOptions, context: any, postedViewModel: any, result: PostbackResponse, response: Response): Promise<DotvvmAfterPostBackEventArgs> {
events.postbackCommitInvoked.trigger({
...options,
response,
serverResponseObject: result
});
>>>>>>>
async function processPostbackResponse(options: PostbackOptions, context: any, postedViewModel: any, initialState: any, result: PostbackResponse, response: Response): Promise<DotvvmAfterPostBackEventArgs> {
events.postbackCommitInvoked.trigger({
...options,
response,
serverResponseObject: result
});
<<<<<<<
updater.updateViewModelAndControls(result);
events.postbackViewModelUpdated.trigger({});
=======
mergeValidationRules(result)
updater.updateViewModelAndControls(result, false);
events.postbackViewModelUpdated.trigger({
...options,
response,
serverResponseObject: result
});
>>>>>>>
mergeValidationRules(result)
updater.updateViewModelAndControls(result);
events.postbackViewModelUpdated.trigger({
...options,
response,
serverResponseObject: result
}); |
<<<<<<<
_initialUrl: string
=======
_initialUrl: string,
_validationRules: ValidationRuleTable,
_stateManager: StateManager<RootViewModel>
>>>>>>>
_initialUrl: string,
_stateManager: StateManager<RootViewModel>
<<<<<<<
replaceTypeInfo(thisViewModel.typeMetadata);
const viewModel: RootViewModel =
deserialization.deserialize(thisViewModel.viewModel, {}, true)
const vmObservable = ko.observable(viewModel)
=======
const manager = new StateManager<RootViewModel>(thisViewModel.viewModel, events.newState)
>>>>>>>
replaceTypeInfo(thisViewModel.typeMetadata);
const manager = new StateManager<RootViewModel>(thisViewModel.viewModel, events.newState)
<<<<<<<
_rootViewModel: vmObservable
=======
_stateManager: manager,
_validationRules: thisViewModel.validationRules || {}
>>>>>>>
_stateManager: manager
<<<<<<<
_rootViewModel: currentState!._rootViewModel
};
=======
_validationRules: a.serverResponseObject.validationRules || {},
_stateManager: currentState!._stateManager
}
>>>>>>>
_stateManager: currentState!._stateManager
} |
<<<<<<<
const allEvents = { ...dotvvm.events, ...validationEvents };
for (const event of keys(allEvents)) {
if ("subscribe" in (allEvents as any)[event]) {
function h(args: any) {
if (consoleOutput) {
console.debug("Event " + event, args.postbackId ?? "")
}
eventHistory.push({ event, args })
}
(allEvents as any)[event].subscribe(h)
=======
for (const event of keys(dotvvm.events)) {
if ("subscribe" in (dotvvm.events as any)[event]) {
var h = function (args: any) {
console.debug("Event " + event, args.postbackClientId ?? args.postbackId ?? "")
};
(dotvvm.events as any)[event].subscribe(h)
>>>>>>>
const allEvents = { ...dotvvm.events, ...validationEvents };
for (const event of keys(allEvents)) {
if ("subscribe" in (allEvents as any)[event]) {
var h = function (args: any) {
if (consoleOutput) {
console.debug("Event " + event, args.postbackId ?? "")
}
eventHistory.push({ event, args })
}
(allEvents as any)[event].subscribe(h) |
<<<<<<<
constructor(public sender: HTMLElement | undefined, public viewModel: any, public viewModelName: string, public validationTargetPath: any, public serverResponseObject: any, public postbackClientId: number) {
=======
constructor(public sender: HTMLElement, public viewModel: any, public viewModelName: string, public validationTargetPath: any, public serverResponseObject: any, public postbackClientId: number, public commandResult: any = null) {
>>>>>>>
constructor(public sender: HTMLElement | undefined, public viewModel: any, public viewModelName: string, public validationTargetPath: any, public serverResponseObject: any, public postbackClientId: number, public commandResult: any = null) { |
<<<<<<<
export const postbackHandlersStarted = new DotvvmEvent<{}>("dotvvm.events.postbackHandlersStarted");
export const postbackHandlersCompleted = new DotvvmEvent<{}>("dotvvm.events.postbackHandlersCompleted");
export const postbackResponseReceived = new DotvvmEvent<{}>("dotvvm.events.postbackResponseReceived");
export const postbackCommitInvoked = new DotvvmEvent<{}>("dotvvm.events.postbackCommitInvoked");
export const postbackViewModelUpdated = new DotvvmEvent<{}>("dotvvm.events.postbackViewModelUpdated");
export const postbackRejected = new DotvvmEvent<{}>("dotvvm.events.postbackRejected");
export const staticCommandMethodInvoking = new DotvvmEvent<{ args: any[], command: string }>("dotvvm.events.staticCommandMethodInvoking");
export const staticCommandMethodInvoked = new DotvvmEvent<{ args: any[], command: string, result: any, xhr: XMLHttpRequest }>("dotvvm.events.staticCommandMethodInvoked");
export const staticCommandMethodFailed = new DotvvmEvent<{ args: any[], command: string, xhr: XMLHttpRequest, error?: any }>("dotvvm.events.staticCommandMethodInvoked");
export const newState = new DotvvmEvent<RootViewModel>("dotvvm.events.newState");
=======
export const postbackHandlersStarted = new DotvvmEvent<DotvvmPostbackHandlersStartedEventArgs>("dotvvm.events.postbackHandlersStarted");
export const postbackHandlersCompleted = new DotvvmEvent<DotvvmPostbackHandlersCompletedEventArgs>("dotvvm.events.postbackHandlersCompleted");
export const postbackResponseReceived = new DotvvmEvent<DotvvmPostbackResponseReceivedEventArgs>("dotvvm.events.postbackResponseReceived");
export const postbackCommitInvoked = new DotvvmEvent<DotvvmPostbackCommitInvokedEventArgs>("dotvvm.events.postbackCommitInvoked");
export const postbackViewModelUpdated = new DotvvmEvent<DotvvmPostbackViewModelUpdatedEventArgs>("dotvvm.events.postbackViewModelUpdated");
export const postbackRejected = new DotvvmEvent<DotvvmPostbackRejectedEventArgs>("dotvvm.events.postbackRejected");
export const staticCommandMethodInvoking = new DotvvmEvent<DotvvmStaticCommandMethodInvokingEventArgs>("dotvvm.events.staticCommandMethodInvoking");
export const staticCommandMethodInvoked = new DotvvmEvent<DotvvmStaticCommandMethodInvokedEventArgs>("dotvvm.events.staticCommandMethodInvoked");
export const staticCommandMethodFailed = new DotvvmEvent<DotvvmStaticCommandMethodFailedEventArgs>("dotvvm.events.staticCommandMethodInvoked");
>>>>>>>
export const postbackHandlersStarted = new DotvvmEvent<DotvvmPostbackHandlersStartedEventArgs>("dotvvm.events.postbackHandlersStarted");
export const postbackHandlersCompleted = new DotvvmEvent<DotvvmPostbackHandlersCompletedEventArgs>("dotvvm.events.postbackHandlersCompleted");
export const postbackResponseReceived = new DotvvmEvent<DotvvmPostbackResponseReceivedEventArgs>("dotvvm.events.postbackResponseReceived");
export const postbackCommitInvoked = new DotvvmEvent<DotvvmPostbackCommitInvokedEventArgs>("dotvvm.events.postbackCommitInvoked");
export const postbackViewModelUpdated = new DotvvmEvent<DotvvmPostbackViewModelUpdatedEventArgs>("dotvvm.events.postbackViewModelUpdated");
export const postbackRejected = new DotvvmEvent<DotvvmPostbackRejectedEventArgs>("dotvvm.events.postbackRejected");
export const staticCommandMethodInvoking = new DotvvmEvent<DotvvmStaticCommandMethodInvokingEventArgs>("dotvvm.events.staticCommandMethodInvoking");
export const staticCommandMethodInvoked = new DotvvmEvent<DotvvmStaticCommandMethodInvokedEventArgs>("dotvvm.events.staticCommandMethodInvoked");
export const staticCommandMethodFailed = new DotvvmEvent<DotvvmStaticCommandMethodFailedEventArgs>("dotvvm.events.staticCommandMethodInvoked");
export const newState = new DotvvmEvent<RootViewModel>("dotvvm.events.newState"); |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.