Angular Intercept Check refresh token

 https://medium.com/angular-in-depth/top-10-ways-to-use-interceptors-in-angular-db450f8a62d6

import { Injectable } from "@angular/core";

import {
	HttpEvent, HttpInterceptor, HttpHandler,
	HttpRequest, HttpErrorResponse
	} from "@angular/common/http";
	import { throwError, Observable, BehaviorSubject, of } from "rxjs";
	import { catchError, filter, take, switchMap } from "rxjs/operators";
	@Injectable()
	export class AuthInterceptor implements HttpInterceptor {
	private AUTH_HEADER = "Authorization";
	private token = "secrettoken";
	private refreshTokenInProgress = false;
	private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(null);
	intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
	if (!req.headers.has('Content-Type')) {
	req = req.clone({
	headers: req.headers.set('Content-Type', 'application/json')
	});
	}
	req = this.addAuthenticationToken(req);
	return next.handle(req).pipe(
	catchError((error: HttpErrorResponse) => {
	if (error && error.status === 401) {
	// 401 errors are most likely going to be because we have an expired token that we need to refresh.
	if (this.refreshTokenInProgress) {
	// If refreshTokenInProgress is true, we will wait until refreshTokenSubject has a non-null value
	// which means the new token is ready and we can retry the request again
	return this.refreshTokenSubject.pipe(
	filter(result => result !== null),
	take(1),
	switchMap(() => next.handle(this.addAuthenticationToken(req)))
	);
	} else {
	this.refreshTokenInProgress = true;
	// Set the refreshTokenSubject to null so that subsequent API calls will wait until the new token has been retrieved
	this.refreshTokenSubject.next(null);
	return this.refreshAccessToken().pipe(
	switchMap((success: boolean) => {
	this.refreshTokenSubject.next(success);
	return next.handle(this.addAuthenticationToken(req));
	}),
	// When the call to refreshToken completes we reset the refreshTokenInProgress to false
	// for the next time the token needs to be refreshed
	finalize(() => this.refreshTokenInProgress = false)
	);
	}
	} else {
	return throwError(error);
	}
	})
	);
	}
	private refreshAccessToken(): Observable<any> {
	return of("secret token");
	}
	private addAuthenticationToken(request: HttpRequest<any>): HttpRequest<any> {
	// If we do not have a token yet then we should not set the header.
	// Here we could first retrieve the token from where we store it.
	if (!this.token) {
	return request;
	}
	// If you are calling an outside domain then do not add the token.
	if (!request.url.match(/www.mydomain.com\//)) {
	return request;
	}
	return request.clone({
	headers: request.headers.set(this.AUTH_HEADER, "Bearer " + this.token)
	});
	}
	}

Grant access to a workspace

 https://support.atlassian.com/bitbucket-cloud/docs/grant-access-to-a-workspace/

Group access on future repositories

When you create a repository in a workspace with existing user groups, Bitbucket determines if the workspace has any groups with the Default Access permissions of Read, Write, or Admin. If it does, Bitbucket adds those groups to the new repository with the default permission. If you specify None for the default permissions, Bitbucket ignores that group and doesn't add it.

To update the group permissions for only one repository, you can do so from the User and group access page of the repository settings.

Split large string in n-size chunks in JavaScript

 https://stackoverflow.com/questions/7033639/split-large-string-in-n-size-chunks-in-javascript

You can do something like this:

"1234567890".match(/.{1,2}/g);
// Results in:
["12", "34", "56", "78", "90"]

The method will still work with strings whose size is not an exact multiple of the chunk-size:

"123456789".match(/.{1,2}/g);
// Results in:
["12", "34", "56", "78", "9"]

In general, for any string out of which you want to extract at-most n-sized substrings, you would do:

str.match(/.{1,n}/g); // Replace n with the size of the substring

If your string can contain newlines or carriage returns, you would do:

str.match(/(.|[\r\n]){1,n}/g); // Replace n with the size of the substring

As far as performance, I tried this out with approximately 10k characters and it took a little over a second on Chrome. YMMV.

This can also be used in a reusable function:

function chunkString(str, length) {
  return str.match(new RegExp('.{1,' + length + '}', 'g'));
}